diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 2f3ef94a..b922a059 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -23,11 +23,11 @@ jobs:
with:
ruby-version: ${{ matrix.ruby }}
bundler-cache: true
- - name: Run BCDD::Result.configuration test (Minitest)
+ - name: Run Solid::Result.configuration test (Minitest)
run: bundle exec rake test_configuration TEST_CONFIG_FREEZING=true
- - name: Run BCDD::Result.event_logs test (Minitest)
- run: bundle exec rake test_event_logs_duration BCDD_RESULT_TEST_EVENT_LOGS_DURATION=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
diff --git a/.rubocop.yml b/.rubocop.yml
index cab50a23..ba21a822 100644
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -18,7 +18,7 @@ AllCops:
Lint/RescueException:
Exclude:
- - lib/bcdd/result/event_logs/tracking/enabled.rb
+ - lib/solid/result/event_logs/tracking/enabled.rb
Layout/LineLength:
Max: 120
@@ -34,7 +34,7 @@ Lint/UnderscorePrefixedVariableName:
Lint/UnusedMethodArgument:
Exclude:
- - lib/bcdd/result/event_logs/listener.rb
+ - lib/solid/result/event_logs/listener.rb
Style/AccessModifierDeclarations:
Enabled: false
@@ -68,17 +68,17 @@ Naming/VariableName:
Metrics/BlockLength:
Exclude:
- - bcdd-result.gemspec
+ - solid-result.gemspec
- test/**/*.rb
Metrics/ClassLength:
Exclude:
- - lib/bcdd/result/_self.rb
+ - lib/solid/result/_self.rb
- test/**/*.rb
Metrics/AbcSize:
Exclude:
- - lib/bcdd/result/event_logs/tracking/enabled.rb
+ - lib/solid/result/event_logs/tracking/enabled.rb
Minitest/MultipleAssertions:
Enabled: false
@@ -95,4 +95,4 @@ Minitest/AssertWithExpectedArgument:
Naming/FileName:
Exclude:
- - lib/bcdd-result.rb
+ - lib/solid-result.rb
diff --git a/CHANGELOG.md b/CHANGELOG.md
index fcf407c8..78c95b28 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,41 +1,43 @@
- [\[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)
+ - [Changed](#changed-1)
- [\[0.13.0\] - 2024-02-01](#0130---2024-02-01)
- [Added](#added-2)
- - [Changed](#changed-1)
+ - [Changed](#changed-2)
- [\[0.12.0\] - 2024-01-07](#0120---2024-01-07)
- [Added](#added-3)
- - [Changed](#changed-2)
+ - [Changed](#changed-3)
- [\[0.11.0\] - 2024-01-02](#0110---2024-01-02)
- [Added](#added-4)
- - [Changed](#changed-3)
+ - [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-4)
+ - [Changed](#changed-5)
- [Fixed](#fixed)
- [\[0.9.0\] - 2023-12-12](#090---2023-12-12)
- [Added](#added-6)
- - [Changed](#changed-5)
+ - [Changed](#changed-6)
- [\[0.8.0\] - 2023-12-11](#080---2023-12-11)
- [Added](#added-7)
- - [Changed](#changed-6)
+ - [Changed](#changed-7)
- [Removed](#removed)
- [\[0.7.0\] - 2023-10-27](#070---2023-10-27)
- [Added](#added-8)
- - [Changed](#changed-7)
+ - [Changed](#changed-8)
- [\[0.6.0\] - 2023-10-11](#060---2023-10-11)
- [Added](#added-9)
- - [Changed](#changed-8)
+ - [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-9)
+ - [Changed](#changed-10)
- [Removed](#removed-1)
- [\[0.3.0\] - 2023-09-26](#030---2023-09-26)
- [Added](#added-12)
@@ -47,6 +49,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
diff --git a/Gemfile b/Gemfile
index a65cc761..647f46e2 100644
--- a/Gemfile
+++ b/Gemfile
@@ -2,7 +2,7 @@
source 'https://rubygems.org'
-# Specify your gem's dependencies in bcdd-result.gemspec
+# Specify your gem's dependencies in solid-result.gemspec
gemspec
gem 'rake', '~> 13.1'
diff --git a/README.md b/README.md
index 5499d2c7..c8854e75 100644
--- a/README.md
+++ b/README.md
@@ -1,15 +1,15 @@
-
🔀 BCDD::Result
+ 🔀 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 (`BCDD::Result::Success`) or failure (`BCDD::Result::Failure`).
+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?**
@@ -22,7 +22,7 @@ Use it to enable the [Railway Oriented Programming](https://fsharpforfunandprofi
- [Supported Ruby](#supported-ruby)
- [Installation](#installation)
- [Usage](#usage)
- - [`BCDD::Result` *versus* `Result`](#bcddresult-versus-result)
+ - [`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)
@@ -40,13 +40,13 @@ Use it to enable the [Railway Oriented Programming](https://fsharpforfunandprofi
- [`result.data`](#resultdata)
- [Railway Oriented Programming](#railway-oriented-programming)
- [`result.and_then`](#resultand_then)
- - [`BCDD::Result.mixin`](#bcddresultmixin)
+ - [`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)
- - [`BCDD::Result::Expectations`](#bcddresultexpectations)
+ - [`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)
@@ -60,34 +60,34 @@ Use it to enable the [Railway Oriented Programming](https://fsharpforfunandprofi
- [Success()](#success)
- [Failure()](#failure)
- [Pattern Matching Support](#pattern-matching-support)
- - [`BCDD::Result::Expectations.mixin` add-ons](#bcddresultexpectationsmixin-add-ons)
- - [`BCDD::Context`](#bcddcontext)
+ - [`Solid::Result::Expectations.mixin` add-ons](#solidresultexpectationsmixin-add-ons)
+ - [`Solid::Output`](#solidoutput)
- [Defining successes and failures](#defining-successes-and-failures)
- [Hash methods](#hash-methods)
- - [`BCDD::Context.mixin`](#bcddcontextmixin)
+ - [`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)
- - [`BCDD::Context::Expectations`](#bcddcontextexpectations)
+ - [`Solid::Output::Expectations`](#solidoutputexpectations)
- [Mixin add-ons](#mixin-add-ons)
- [Pattern Matching](#pattern-matching)
- - [`BCDD::Result`](#bcddresult)
+ - [`Solid::Result`](#solidresult)
- [`Array`/`Find` patterns](#arrayfind-patterns)
- [`Hash` patterns](#hash-patterns)
- - [`BCDD::Context`](#bcddcontext-1)
+ - [`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)
-- [`BCDD::Result.event_logs`](#bcddresultevent_logs)
+- [`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)
-- [`BCDD::Result.configuration`](#bcddresultconfiguration)
- - [`BCDD::Result.config`](#bcddresultconfig)
-- [`BCDD::Result#and_then!`](#bcddresultand_then)
+- [`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)
@@ -112,7 +112,7 @@ Version | 2.7 | 3.0 | 3.1 | 3.2 | 3.3 | Head
Add this line to your application's Gemfile:
```ruby
-gem 'bcdd-result'
+gem 'solid-result'
```
And then execute:
@@ -121,73 +121,73 @@ And then execute:
If bundler is not being used to manage dependencies, install the gem by executing:
- $ gem install bcdd-result
+ $ gem install solid-result
And require it in your code:
- require 'bcdd/result'
+ require 'solid/result'
-⬆️ back to top
+⬆️ back to top
## Usage
To create a result, you must define a type (symbol) and its value (any kind of object). e.g.,
```ruby
-BCDD::Result::Success(:ok, :1) #
- # The value can be any kind of object
-BCDD::Result::Failure(:err, 'the value') #
+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
-BCDD::Result::Success(:ok) #
- # The type is mandatory and the value is optional
-BCDD::Result::Failure(:err) #
+Solid::Result::Success(:ok) #
+ # The type is mandatory and the value is optional
+Solid::Result::Failure(:err) #
```
-⬆️ back to top
+⬆️ back to top
-#### `BCDD::Result` *versus* `Result`
+#### `Solid::Result` *versus* `Result`
-This gem provides a way to create constant aliases for `BCDD::Result` and other classes/modules.
+This gem provides a way to create constant aliases for `Solid::Result` and other classes/modules.
-To enable it, you must call the `BCDD::Result.configuration` method and pass a block to it. You can turn the aliases you want on/off in this block.
+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
-BCDD::Result.configuration do |config|
+Solid::Result.configuration do |config|
config.constant_alias.enable!('Result')
end
```
-So, instead of using `BCDD::Result` everywhere, you can use `Result` as an alias/shortcut.
+So, instead of using `Solid::Result` everywhere, you can use `Result` as an alias/shortcut.
```ruby
-Result::Success(:ok) #
+Result::Success(:ok) #
-Result::Failure(:err) #
+Result::Failure(:err) #
```
-If you have enabled constant aliasing, all examples in this README that use `BCDD::Result` can be implemented using `Result`.
+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 [BCDD::Result.configuration]() section for more information.
+There are other aliases and configurations available. Check the [Solid::Result.configuration]() section for more information.
-⬆️ back to top
+⬆️ back to top
## Reference
### Basic methods
-Both `BCDD::Result::Success` and `BCDD::Result::Failure` are composed of the same methods. Look at the basic ones:
+Both `Solid::Result::Success` and `Solid::Result::Failure` are composed of the same methods. Look at the basic ones:
-**BCDD::Result::Success**
+**Solid::Result::Success**
```ruby
################
# With a value #
################
-result = BCDD::Result::Success(:ok, my: 'value')
+result = Solid::Result::Success(:ok, my: 'value')
result.success? # true
result.failure? # false
@@ -198,7 +198,7 @@ result.value # {:my => "value"}
###################
# Without a value #
###################
-result = BCDD::Result::Success(:yes)
+result = Solid::Result::Success(:yes)
result.success? # true
result.failure? # false
@@ -207,13 +207,13 @@ result.type # :yes
result.value # nil
```
-**BCDD::Result::Failure**
+**Solid::Result::Failure**
```ruby
################
# With a value #
################
-result = BCDD::Result::Failure(:err, 'my_value')
+result = Solid::Result::Failure(:err, 'my_value')
result.success? # false
result.failure? # true
@@ -224,7 +224,7 @@ result.value # "my_value"
###################
# Without a value #
###################
-result = BCDD::Result::Failure(:no)
+result = Solid::Result::Failure(:no)
result.success? # false
result.failure? # true
@@ -235,34 +235,34 @@ result.value # nil
In both cases, the `type` must be a symbol, and the `value` can be any kind of object.
-⬆️ back to top
+⬆️ 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 = BCDD::Result::Success(:ok)
+result = Solid::Result::Success(:ok)
result.is?(:ok) # true
result.ok? # true
-result = BCDD::Result::Failure(:err)
+result = Solid::Result::Failure(:err)
result.is?(:err) # true
result.err? # true
```
-⬆️ back to top
+⬆️ back to top
#### Checking types with `result.success?` or `result.failure?`
-`BCDD::Result#success?` and `BCDD::Result#failure?` are methods that allow you to check if the result is a success or a 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 = BCDD::Result::Success(:ok)
+result = Solid::Result::Success(:ok)
result.success?(:ok)
@@ -271,10 +271,10 @@ result.success?(:ok)
result.success? && result.type == :ok
```
-The same is valid for `BCDD::Result#failure?`.
+The same is valid for `Solid::Result#failure?`.
```ruby
-result = BCDD::Result::Failure(:err)
+result = Solid::Result::Failure(:err)
result.failure?(:err)
@@ -283,7 +283,7 @@ result.failure?(:err)
result.failure? && result.type == :err
```
-⬆️ back to top
+⬆️ back to top
### Result Hooks
@@ -292,20 +292,20 @@ 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 BCDD::Result::Failure(:invalid_arg, 'arg1 must be numeric')
- arg2.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg2 must be numeric')
+ 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 BCDD::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
+ return Solid::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
- BCDD::Result::Success(:division_completed, arg1 / arg2)
+ Solid::Result::Success(:division_completed, arg1 / arg2)
end
```
-⬆️ back to top
+⬆️ back to top
#### `result.on`
-When you use `BCDD::Result#on`, the block will be executed only when the type matches the result type.
+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.
@@ -313,7 +313,7 @@ The value of the result will be available as the first argument of the block.
```ruby
result = divide(nil, 2)
-#
+#
output =
result
@@ -340,15 +340,15 @@ result.object_id == output.object_id # true
*PS: The `divide()` implementation is [here](#result-hooks).*
-⬆️ back to top
+⬆️ back to top
#### `result.on_type`
-`BCDD::Result#on_type` is an alias of `BCDD::Result#on`.
+`Solid::Result#on_type` is an alias of `Solid::Result#on`.
```ruby
result = divide(nil, 2)
-#
+#
output =
result
@@ -362,11 +362,11 @@ result.object_id == output.object_id # true
*PS: The `divide()` implementation is [here](#result-hooks).*
-⬆️ back to top
+⬆️ back to top
#### `result.on_success`
-The `BCDD::Result#on_success` method is quite similar to the `BCDD::Result#on` hook, but with a few key differences:
+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.
@@ -389,7 +389,7 @@ divide(4, 4).on_failure { |error| puts error }
*PS: The `divide()` implementation is [here](#result-hooks).*
-⬆️ back to top
+⬆️ back to top
#### `result.on_failure`
@@ -416,11 +416,11 @@ divide(4, 0).on_success { |number| puts number }
*PS: The `divide()` implementation is [here](#result-hooks).*
-⬆️ back to top
+⬆️ back to top
#### `result.on_unknown`
-`BCDD::Result#on_unknown` will execute the block when no other hook (`#on`, `#on_type`, `#on_failure`, `#on_success`) has been executed.
+`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.
@@ -437,7 +437,7 @@ divide(4, 2)
*PS: The `divide()` implementation is [here](#result-hooks).*
-⬆️ back to top
+⬆️ back to top
#### `result.handle`
@@ -487,13 +487,13 @@ end
*PS: The `divide()` implementation is [here](#result-hooks).*
-⬆️ back to top
+⬆️ back to top
### Result Value
-To access the result value, you can simply call `BCDD::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 `BCDD::Result#value_or`.
+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`
@@ -501,12 +501,12 @@ However, there may be instances where you need to retrieve the value of a succes
```ruby
def divide(arg1, arg2)
- arg1.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg)
- arg2.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg)
+ arg1.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg)
+ arg2.is_a?(::Numeric) or return Solid::Result::Failure(:invalid_arg)
- return BCDD::Result::Failure(:division_by_zero) if arg2.zero?
+ return Solid::Result::Failure(:division_by_zero) if arg2.zero?
- BCDD::Result::Success(:division_completed, arg1 / arg2)
+ Solid::Result::Success(:division_completed, arg1 / arg2)
end
# When the result is success
@@ -520,22 +520,22 @@ divide(100, 0).value_or { 0 } # 0
*PS: The `divide()` implementation is [here](#result-hooks).*
-⬆️ back to top
+⬆️ back to top
### Result Data
#### `result.data`
-The `BCDD::Result#data` exposes the result attributes (kind, type, value) directly and as a hash (`to_h`/`to_hash`) and array (`to_a`/`to_ary`).
+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 = BCDD::Result::Success(:ok, 1)
+result = Solid::Result::Success(:ok, 1)
-success_data = result.data # #
+success_data = result.data # #
success_data.kind # :success
success_data.type # :ok
@@ -563,7 +563,7 @@ 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
+⬆️ back to top
### Railway Oriented Programming
@@ -589,20 +589,20 @@ module Divide
private
def validate_numbers(arg1, arg2)
- arg1.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg1 must be numeric')
- arg2.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg2 must be numeric')
+ 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')
- BCDD::Result::Success(:ok, [arg1, arg2])
+ Solid::Result::Success(:ok, [arg1, arg2])
end
def validate_nonzero(numbers)
- return BCDD::Result::Success(:ok, numbers) if numbers.last.nonzero?
+ return Solid::Result::Success(:ok, numbers) if numbers.last.nonzero?
- BCDD::Result::Failure(:division_by_zero, 'arg2 must not be zero')
+ Solid::Result::Failure(:division_by_zero, 'arg2 must not be zero')
end
def divide((number1, number2))
- BCDD::Result::Success(:division_completed, number1 / number2)
+ Solid::Result::Success(:division_completed, number1 / number2)
end
end
```
@@ -611,25 +611,25 @@ Example of outputs:
```ruby
Divide.call('4', 2)
-#
+#
Divide.call(2, '2')
-#
+#
Divide.call(2, 0)
-#
+#
Divide.call(2, 2)
-#
+#
```
-⬆️ back to top
+⬆️ back to top
-#### `BCDD::Result.mixin`
+#### `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 `BCDD::Result::Success()`/`BCDD::Result::Failure()` is that the former will utilize the target object (which has received the include/extend) as the result's source.
+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.
@@ -637,7 +637,7 @@ Because the result has a source, the `#and_then` method can call methods from it
```ruby
class Divide
- include BCDD::Result.mixin
+ include Solid::Result.mixin
attr_reader :arg1, :arg2
@@ -674,18 +674,18 @@ class Divide
end
end
-Divide.new(4, 2).call #
+Divide.new(4, 2).call #
-Divide.new(4, 0).call #
-Divide.new('4', 2).call #
-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, BCDD::Result.mixin
+ extend self, Solid::Result.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
@@ -713,26 +713,26 @@ module Divide
end
end
-Divide.call(4, 2) #
+Divide.call(4, 2) #
-Divide.call(4, 0) #
-Divide.call('4', 2) #
-Divide.call(4, '2') #
+Divide.call(4, 0) #
+Divide.call('4', 2) #
+Divide.call(4, '2') #
```
-⬆️ back to top
+⬆️ 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 `BCDD::Result::Success()`/`BCDD::Result::Failure()`, or results from another `BCDD::Result.mixin` instance with `#and_then`, it will raise an error because the sources are different.
+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, BCDD::Result.mixin
+ extend self, Solid::Result.mixin
def call(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
@@ -742,7 +742,7 @@ module ValidateNonzero
end
module Divide
- extend self, BCDD::Result.mixin
+ extend self, Solid::Result.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
@@ -774,17 +774,17 @@ 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! (BCDD::Result::Error::InvalidResultSource)
+# 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: #
+# 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, BCDD::Result.mixin
+ extend self, Solid::Result.mixin
def call(numbers)
return Success(:ok, numbers) unless numbers.last.zero?
@@ -794,7 +794,7 @@ module ValidateNonzero
end
module Divide
- extend self, BCDD::Result.mixin
+ extend self, Solid::Result.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
@@ -832,21 +832,21 @@ Look at the output of the code above:
```ruby
Divide.call(2, 0)
-#
+#
```
-⬆️ back to top
+⬆️ back to top
##### Dependency Injection
-The `BCDD::Result#and_then` accepts a second argument that will be used to share a value with the source's method.
+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, BCDD::Result.mixin
+ extend self, Solid::Result.mixin
def call(arg1, arg2, logger: ::Logger.new(STDOUT))
validate_numbers(arg1, arg2)
@@ -887,23 +887,23 @@ 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
+⬆️ back to top
##### Add-ons
-The `BCDD::Result.mixin` also accepts the `config:` argument. It is a hash that will be used to define custom behaviors for the mixin.
+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 `BCDD::Result.configuration`.
+You can turn it off by passing `given: false` to the `config:` argument or using the `Solid::Result.configuration`.
**continue**
@@ -915,7 +915,7 @@ In this example below, the `validate_nonzero` will return a `Success(:division_c
```ruby
module Divide
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Given([arg1, arg2])
@@ -949,11 +949,11 @@ module Divide
end
```
-⬆️ back to top
+⬆️ back to top
-### `BCDD::Result::Expectations`
+### `Solid::Result::Expectations`
-This feature lets you define contracts for your results' types and values. There are two ways to use it: the standalone (`BCDD::Result::Expectations.new`) and the mixin (`BCDD::Result::Expectations.mixin`) mode.
+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.
@@ -963,7 +963,7 @@ The _**standalone mode**_ creates an object that knows how to produce and valida
```ruby
module Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
@@ -986,18 +986,18 @@ Look what happens if you try to create a result without one of the expected type
```ruby
Divide::Result::Success(:ok)
# type :ok is not allowed. Allowed types: :numbers, :division_completed
-# (BCDD::Result::Contract::Error::UnexpectedType)
+# (Solid::Result::Contract::Error::UnexpectedType)
Divide::Result::Failure(:err)
# type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero
-# (BCDD::Result::Contract::Error::UnexpectedType)
+# (Solid::Result::Contract::Error::UnexpectedType)
```
-The _**mixin mode**_ is similar to `BCDD::Result::Mixin`, but it also defines the expectations for the result's types and values.
+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 BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
@@ -1036,15 +1036,15 @@ This mode also defines an `Result` constant to be used inside and outside the mo
Now that you know the two modes, let's understand how expectations can be beneficial and powerful for defining contracts.
-⬆️ back to top
+⬆️ back to top
#### Type checking - Result Hooks
-The `BCDD::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`.
+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, `BCDD::Result::Expectations` will also verify if the result type is valid/expected. In case of an invalid type, an error will be raised.
+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:**
@@ -1057,7 +1057,7 @@ result.success?(:division_completed) # true
result.success?(:ok)
# type :ok is not allowed. Allowed types: :numbers, :division_completed
-# (BCDD::Result::Contract::Error::UnexpectedType)
+# (Solid::Result::Contract::Error::UnexpectedType)
```
**Failure example:**
@@ -1071,16 +1071,16 @@ result.failure?(:division_by_zero) # false
result.failure?(:err)
# type :err is not allowed. Allowed types: :invalid_arg, :division_by_zero
-# (BCDD::Result::Contract::Error::UnexpectedType)
+# (Solid::Result::Contract::Error::UnexpectedType)
```
*PS: The `Divide` implementation is [here](#standalone-versus-mixin-mode).*
-⬆️ back to top
+⬆️ back to top
##### `#on` and `#on_type`
-If you use `#on` or `#on_type` to execute a block, `BCDD::Result::Expectations` will check whether the result type is valid/expected. Otherwise, an error will be raised.
+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)
@@ -1093,16 +1093,16 @@ result
result.on(:number) { |_| :this_type_does_not_exist }
# type :number is not allowed. Allowed types: :numbers, :division_completed, :invalid_arg, :division_by_zero
-# (BCDD::Result::Contract::Error::UnexpectedType)
+# (Solid::Result::Contract::Error::UnexpectedType)
```
*PS: The `Divide` implementation is [here](#standalone-versus-mixin-mode).*
-⬆️ back to top
+⬆️ back to top
##### `#on_success` and `#on_failure`
-If you use `#on_success` or `#on_failure` to execute a block, `BCDD::Result::Expectations` will check whether the result type is valid/expected. Otherwise, an error will be raised.
+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')
@@ -1119,20 +1119,20 @@ result
result.on_success(:ok) { |_| :this_type_does_not_exist }
# type :ok is not allowed. Allowed types: :numbers, :division_completed
-# (BCDD::Result::Contract::Error::UnexpectedType)
+# (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
-# (BCDD::Result::Contract::Error::UnexpectedType)
+# (Solid::Result::Contract::Error::UnexpectedType)
```
*PS: The `Divide` implementation is [here](#standalone-versus-mixin-mode).*
-⬆️ back to top
+⬆️ back to top
##### `#handle`
-The `BCDD::Result::Expectations` will also be applied on all the handlers defined by the `#handle` method/block.
+The `Solid::Result::Expectations` will also be applied on all the handlers defined by the `#handle` method/block.
```ruby
result = Divide.call(10, 2)
@@ -1140,26 +1140,26 @@ 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 (BCDD::Result::Contract::Error::UnexpectedType)
+# 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 (BCDD::Result::Contract::Error::UnexpectedType)
+# 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 (BCDD::Result::Contract::Error::UnexpectedType)
+# 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
+⬆️ back to top
#### Type checking - Result Creation
-The `BCDD::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.
+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).
@@ -1167,7 +1167,7 @@ This works for both modes (standalone and mixin).
```ruby
module Divide
- extend BCDD::Result::Expectations.mixin(success: :ok, failure: :err)
+ 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')
@@ -1181,20 +1181,20 @@ end
Divide.call('4', 2)
# type :invalid_arg is not allowed. Allowed types: :err
-# (BCDD::Result::Contract::Error::UnexpectedType)
+# (Solid::Result::Contract::Error::UnexpectedType)
Divide.call(4, 2)
# type :division_completed is not allowed. Allowed types: :ok
-# (BCDD::Result::Contract::Error::UnexpectedType)
+# (Solid::Result::Contract::Error::UnexpectedType)
```
-⬆️ back to top
+⬆️ back to top
##### Standalone mode
```ruby
module Divide
- Result = BCDD::Result::Expectations.new(success: :ok, failure: :err)
+ 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')
@@ -1208,14 +1208,14 @@ end
Divide.call('4', 2)
# type :invalid_arg is not allowed. Allowed types: :err
-# (BCDD::Result::Contract::Error::UnexpectedType)
+# (Solid::Result::Contract::Error::UnexpectedType)
Divide.call(4, 2)
# type :division_completed is not allowed. Allowed types: :ok
-# (BCDD::Result::Contract::Error::UnexpectedType)
+# (Solid::Result::Contract::Error::UnexpectedType)
```
-⬆️ back to top
+⬆️ back to top
#### Value checking - Result Creation
@@ -1227,7 +1227,7 @@ To define expectations for your result's values, you must declare a Hash with th
```ruby
module Divide
- extend BCDD::Result::Expectations.mixin(
+ extend Solid::Result::Expectations.mixin(
success: {
numbers: ->(value) { value.is_a?(Array) && value.size == 2 && value.all?(Numeric) },
division_completed: Numeric
@@ -1253,7 +1253,7 @@ end
```ruby
module Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: {
numbers: ->(value) { value.is_a?(Array) && value.size == 2 && value.all?(Numeric) },
division_completed: Numeric
@@ -1277,35 +1277,35 @@ end
The value validation will only be performed through the methods `Success()` and `Failure()`.
-⬆️ back to top
+⬆️ back to top
##### Success()
```ruby
Divide::Result::Success(:ok)
-# type :ok is not allowed. Allowed types: :numbers, :division_completed (BCDD::Result::Contract::Error::UnexpectedType)
+# 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 (BCDD::Result::Contract::Error::UnexpectedValue)
+# 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 (BCDD::Result::Contract::Error::UnexpectedValue)
+# 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 (BCDD::Result::Contract::Error::UnexpectedType)
+# 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 (BCDD::Result::Contract::Error::UnexpectedValue)
+# 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 (BCDD::Result::Contract::Error::UnexpectedValue)
+# value {:msg=>"arg2 must not be zero"} is not allowed for :division_by_zero type (Solid::Result::Contract::Error::UnexpectedValue)
```
-⬆️ back to top
+⬆️ back to top
##### Pattern Matching Support
@@ -1313,11 +1313,11 @@ The value checking has support for handling pattern-matching errors, and the cle
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 `BCDD::Result.configuration` or by allowing it directly on the mixin config.
+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 BCDD::Result::Expectations.mixin(
+ extend Solid::Result::Expectations.mixin(
config: {
pattern_matching: { nil_as_valid_value_checking: true }
},
@@ -1338,24 +1338,24 @@ module Divide
end
Divide.call(10, 5)
-# value "2" is not allowed for :division_completed type ("2": Float === "2" does not return true) (BCDD::Result::Contract::Error::UnexpectedValue)
+# value "2" is not allowed for :division_completed type ("2": Float === "2" does not return true) (Solid::Result::Contract::Error::UnexpectedValue)
```
-⬆️ back to top
+⬆️ back to top
-#### `BCDD::Result::Expectations.mixin` add-ons
+#### `Solid::Result::Expectations.mixin` add-ons
-The `BCDD::Result::Expectations.mixin` also accepts the `config:` argument. It is a hash that can be used to define custom behaviors for the mixin.
+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 `BCDD::Result.mixin(config: { addon: { continue: true } })`. The key difference is that the expectations will ignore the `Continue(value)`.
+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 BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :division_completed,
failure: %i[invalid_arg division_by_zero]
@@ -1388,64 +1388,64 @@ class Divide
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 (BCDD::Result::Contract::Error::UnexpectedType)
+# type :ok is not allowed. Allowed types: :division_completed (Solid::Result::Contract::Error::UnexpectedType)
```
-⬆️ back to top
+⬆️ back to top
-### `BCDD::Context`
+### `Solid::Output`
-The `BCDD::Context` 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.
+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 `BCDD::Context` has the `#and_expose` method to expose only the desired keys from the accumulated result.
+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 `BCDD::Result`, you can declare success and failures directly from `BCDD::Context`.
+As the `Solid::Result`, you can declare success and failures directly from `Solid::Output`.
```ruby
-BCDD::Context::Success(:ok, a: 1, b: 2)
-#1, :b=>2}>
+Solid::Output::Success(:ok, a: 1, b: 2)
+#1, :b=>2}>
-BCDD::Context::Failure(:err, message: 'something went wrong')
-#"something went wrong"}>
+Solid::Output::Failure(:err, message: 'something went wrong')
+#"something went wrong"}>
```
-But different from `BCDD::Result` that accepts any value, the `BCDD::Context` only takes keyword arguments.
+But different from `Solid::Result` that accepts any value, the `Solid::Output` only takes keyword arguments.
```ruby
-BCDD::Context::Success(:ok, [1, 2])
+Solid::Output::Success(:ok, [1, 2])
# wrong number of arguments (given 2, expected 1) (ArgumentError)
-BCDD::Context::Failure(:err, { message: 'something went wrong' })
+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
#
-BCDD::Context::Success(:ok, **{ message: 'hashes can be converted to keyword arguments' })
-#"hashes can be converted 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
+⬆️ back to top
#### Hash methods
-The `BCDD::Context` 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:
+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 = BCDD::Context::Success(:ok, a: 1, b: 2, c: {d: 4})
+result = Solid::Output::Success(:ok, a: 1, b: 2, c: {d: 4})
result[:a] # 1
result.fetch(:a) # 1
@@ -1457,13 +1457,13 @@ result.values_at(:a, :b) # [1, 2]
result.fetch_values(:a, :b) # [1, 2]
```
-These methods are available for `BCDD::Context::Success` and `BCDD::Context::Failure` instances.
+These methods are available for `Solid::Output::Success` and `Solid::Output::Failure` instances.
-⬆️ back to top
+⬆️ back to top
-#### `BCDD::Context.mixin`
+#### `Solid::Output.mixin`
-As in the `BCDD::Result`, you can use the `BCDD::Context.mixin` to add the `Success()` and `Failure()` methods to your classes/modules.
+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:
@@ -1473,7 +1473,7 @@ Let's see this feature and the data accumulation in action:
require 'logger'
class Divide
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(arg1, arg2, logger: ::Logger.new(STDOUT))
validate_numbers(arg1, arg2)
@@ -1510,29 +1510,29 @@ end
Divide.new.call(10, 5)
# I, [2023-10-27T01:51:46.905004 #76915] INFO -- : The division result is 2
-#2}>
+#2}>
Divide.new.call('10', 5)
-#"arg1 must be numeric"}>
+#"arg1 must be numeric"}>
Divide.new.call(10, '5')
-#"arg2 must be numeric"}>
+#"arg2 must be numeric"}>
Divide.new.call(10, 0)
-#"arg2 must not be zero"}>
+#"arg2 must not be zero"}>
```
-⬆️ back to top
+⬆️ back to top
##### `and_expose`
-This allows you to expose only the desired keys from the accumulated result. It can be used with any `BCDD::Context` object.
+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 BCDD::Context.mixin
+ include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
@@ -1562,7 +1562,7 @@ class Divide
end
Divide.new.call(10, 5)
-#2}>
+#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.
@@ -1571,20 +1571,20 @@ 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}>
+#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
+⬆️ back to top
##### Module example (Singleton Methods)
-`BCDD::Context.mixin` can also produce singleton methods. Below is an example using a module (but it could be a class, too).
+`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, BCDD::Context.mixin
+ extend self, Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
@@ -1614,29 +1614,29 @@ module Divide
end
Divide.call(10, 5)
-#2}>
+#2}>
Divide.call('10', 5)
-#"arg1 must be numeric"}>
+#"arg1 must be numeric"}>
Divide.call(10, '5')
-#"arg2 must be numeric"}>
+#"arg2 must be numeric"}>
Divide.call(10, 0)
-#"arg2 must not be zero"}>
+#"arg2 must not be zero"}>
```
-⬆️ back to top
+⬆️ back to top
-#### `BCDD::Context::Expectations`
+#### `Solid::Output::Expectations`
-The `BCDD::Context::Expectations` is a `BCDD::Result::Expectations` with the `BCDD::Context` features.
+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 BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: {
pattern_matching: { nil_as_valid_value_checking: true }
},
@@ -1660,48 +1660,48 @@ class Divide
end
Divide.new.call(10, 5)
-#2}>
+#2}>
```
-As in the `BCDD::Result::Expectations.mixin`, the `BCDD::Context::Expectations.mixin` will add a Result constant in the target class. It can generate success/failure results, which ensure the mixin expectations.
+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}>
+#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) (BCDD::Result::Contract::Error::UnexpectedValue)
+# 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
+⬆️ back to top
#### Mixin add-ons
-The `BCDD::Context.mixin` and `BCDD::Context::Expectations.mixin` also accepts the `config:` argument. And it works the same way as the `BCDD::Result` mixins.
+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 `BCDD::Result.configuration`.
+You can turn it off by passing `given: false` to the `config:` argument or using the `Solid::Result.configuration`.
-The `Given()` addon for a BCDD::Context 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.
+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 `BCDD::Context.mixin(config: { addon: { continue: true } })` or `BCDD::Context::Expectations.mixin(config: { addon: { continue: true } })` creates the `Continue(value)` method and change the `Success()` behavior to terminate the step chain.
+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 `BCDD::Context` features to see in action with this add-on:
+Let's use a mix of `Solid::Output` features to see in action with this add-on:
```ruby
module Division
require 'logger'
- extend self, BCDD::Context::Expectations.mixin(
+ extend self, Solid::Output::Expectations.mixin(
config: {
addon: { continue: true },
pattern_matching: { nil_as_valid_value_checking: true }
@@ -1751,39 +1751,39 @@ end
Division.call(14, 2)
# I, [2023-10-27T02:01:05.812388 #77823] INFO -- : The division result is 7
-#7}>
+#7}>
Division.call(0, 2)
-##0}>
+##0}>
Division.call('14', 2)
-#"arg1 must be numeric"}>
+#"arg1 must be numeric"}>
Division.call(14, '2')
-#"arg2 must be numeric"}>
+#"arg2 must be numeric"}>
Division.call(14, 0)
-#"arg2 must not be zero"}>
+#"arg2 must not be zero"}>
```
-⬆️ back to top
+⬆️ back to top
## Pattern Matching
-The `BCDD::Result` and `BCDD::Context` also provides support to pattern matching.
+The `Solid::Result` and `Solid::Output` also provides support to pattern matching.
-### `BCDD::Result`
+### `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 BCDD::Result::Failure(:invalid_arg, 'arg1 must be numeric')
- arg2.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg2 must be numeric')
+ 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 BCDD::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
+ return Solid::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
- BCDD::Result::Success(:division_completed, arg1 / arg2)
+ Solid::Result::Success(:division_completed, arg1 / arg2)
end
```
@@ -1791,61 +1791,61 @@ end
```ruby
case Divide.call(4, 2)
-in BCDD::Failure[:invalid_arg, msg] then puts msg
-in BCDD::Failure[:division_by_zero, msg] then puts msg
-in BCDD::Success[:division_completed, num] then puts num
+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 BCDD::Failure[:invalid_arg, msg] then puts msg
-in BCDD::Failure[:division_by_zero, msg] then puts msg
-in BCDD::Success[:division_completed, num] then puts num
+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
+⬆️ back to top
#### `Hash` patterns
```ruby
case Divide.call(10, 2)
-in BCDD::Failure(type: :invalid_arg, value: msg) then puts msg
-in BCDD::Failure(type: :division_by_zero, value: msg) then puts msg
-in BCDD::Success(type: :division_completed, value: num) then puts num
+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 BCDD::Failure(type: :invalid_arg, value: msg) then puts msg
-in BCDD::Failure(type: :division_by_zero, value: msg) then puts msg
-in BCDD::Success(type: :division_completed, value: num) then puts num
+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 `BCDD::Result::Success` and `BCDD::Result::Failure` as patterns.
+You can also use `Solid::Result::Success` and `Solid::Result::Failure` as patterns.
-⬆️ back to top
+⬆️ back to top
-### `BCDD::Context`
+### `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 BCDD::Context::Failure(:invalid_arg, err: 'arg1 must be numeric')
- arg2.is_a?(::Numeric) or return BCDD::Context::Failure(:invalid_arg, err: 'arg2 must be numeric')
+ 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 BCDD::Context::Failure(:division_by_zero, err: 'arg2 must not be zero') if arg2.zero?
+ return Solid::Output::Failure(:division_by_zero, err: 'arg2 must not be zero') if arg2.zero?
- BCDD::Context::Success(:division_completed, num: arg1 / arg2)
+ Solid::Output::Success(:division_completed, num: arg1 / arg2)
end
```
@@ -1853,23 +1853,23 @@ end
```ruby
case Divide.call(4, 2)
-in BCDD::Failure[:invalid_arg, {msg:}] then puts msg
-in BCDD::Failure[:division_by_zero, {msg:}] then puts msg
-in BCDD::Success[:division_completed, {num:}] then puts num
+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 BCDD::Failure[:invalid_arg, {msg:}] then puts msg
-in BCDD::Failure[:division_by_zero, {msg:}] then puts msg
-in BCDD::Success[:division_completed, {num:}] then puts num
+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
+⬆️ back to top
#### `Hash` patterns
@@ -1877,67 +1877,67 @@ If you don't provide the keys :type and :value, the pattern will match the resul
```ruby
case Divide.call(10, 2)
-in BCDD::Failure({msg:}) then puts msg
-in BCDD::Success({num:}) then puts num
+in Solid::Failure({msg:}) then puts msg
+in Solid::Success({num:}) then puts num
end
```
```ruby
case Divide.call(10, 2)
-in BCDD::Failure(type: :invalid_arg, value: {msg:}) then puts msg
-in BCDD::Failure(type: :division_by_zero, value: {msg:}) then puts msg
-in BCDD::Success(type: :division_completed, value: {num:}) then puts num
+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 BCDD::Failure(type: :invalid_arg, value: {msg:}) then puts {msg:}
-in BCDD::Failure(type: :division_by_zero, value: {msg:}) then puts msg
-in BCDD::Success(type: :division_completed, value: {num:}) then puts num
+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 `BCDD::Context::Success` and `BCDD::Context::Failure` as patterns.
+You can also use `Solid::Output::Success` and `Solid::Output::Failure` as patterns.
-⬆️ back to top
+⬆️ back to top
### How to pattern match without the concept of success and failure
-You can use the classes `BCDD::Result` and `BCDD::Context` as patterns, and the pattern matching will work 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 BCDD::Context(:invalid_arg, {msg:}) then puts msg
-in BCDD::Context(:division_by_zero, {msg:}) then puts msg
-in BCDD::Context(:division_completed, {num:}) then puts num
+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 BCDD::Result(:invalid_arg, msg) then puts msg
-in BCDD::Result(:division_by_zero, msg) then puts msg
-in BCDD::Result(:division_completed, num) then puts num
+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 `BCDD::Result` will also work with the `BCDD::Context`, but the opposite won't.
+The `Solid::Result` will also work with the `Solid::Output`, but the opposite won't.
-⬆️ back to top
+⬆️ back to top
-## `BCDD::Result.event_logs`
+## `Solid::Result.event_logs`
-Use `BCDD::Result.event_logs(&block)` to track all the results produced in the same or between different operations (it works with `BCDD::Result` and `BCDD::Context`). 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.
+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 `BCDD::Result.event_logs`, the final one will expose all the event log records through the `BCDD::Result#event_logs` method.
+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 BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
- BCDD::Result.event_logs(name: 'Division', desc: 'divide two numbers') do
+ Solid::Result.event_logs(name: 'Division', desc: 'divide two numbers') do
Given([arg1, arg2])
.and_then(:require_numbers)
.and_then(:check_for_zeros)
@@ -1970,10 +1970,10 @@ class Division
end
module SumDivisionsByTwo
- extend self, BCDD::Result.mixin
+ extend self, Solid::Result.mixin
def call(*numbers)
- BCDD::Result.event_logs(name: 'SumDivisionsByTwo') do
+ Solid::Result.event_logs(name: 'SumDivisionsByTwo') do
divisions = numbers.map { |number| Division.new.call(number, 2) }
if divisions.any?(&:failure?)
@@ -1990,7 +1990,7 @@ Let's see the result of the `SumDivisionsByTwo` call:
```ruby
result = SumDivisionsByTwo.call(20, 10)
-# => #
+# => #
result.event_logs
{
@@ -2081,7 +2081,7 @@ result.event_logs
}
```
-⬆️ back to top
+⬆️ back to top
### `metadata: {ids:}`
@@ -2138,21 +2138,21 @@ Use these data structures to build your own visualization.
# }
```
-⬆️ back to top
+⬆️ back to top
### Configuration
#### Turning on/off
-You can use `BCDD::Result.config.feature.disable!(event_logs)` and `BCDD::Result.config.feature.enable!(event_logs)` to turn on/off the `BCDD::Result.event_logs` feature.
+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
-BCDD::Result.configuration do |config|
+Solid::Result.configuration do |config|
config.feature.disable!(event_logs)
end
result = SumDivisionsByTwo.call(20, 10)
-# => #
+# => #
result.event_logs
{
@@ -2165,7 +2165,7 @@ result.event_logs
}
```
-⬆️ back to top
+⬆️ back to top
#### Setting a `trace_id` fetcher
@@ -2174,14 +2174,14 @@ You can define a lambda (arity 0) to fetch the trace_id. This lambda will be cal
Use to correlate different or the same operation (executed multiple times).
```ruby
-BCDD::Result.config.event_logs.trace_id = -> { Thread.current[:bcdd_result_event_logs_trace_id] }
+Solid::Result.config.event_logs.trace_id = -> { Thread.current[:solid_result_event_logs_trace_id] }
```
-⬆️ back to top
+⬆️ 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 `BCDD::Result::EventLogs::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.
@@ -2189,17 +2189,17 @@ Use it to build your additional logic on top of the tracking. Examples:
- 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 `BCDD::Result.config.event_logs.listener=`:
+After implementing your listener, you can set it to the `Solid::Result.config.event_logs.listener=`:
```ruby
-BCDD::Result.config.event_logs.listener = MyEventLogsListener
+Solid::Result.config.event_logs.listener = MyEventLogsListener
```
See the example below to understand how to implement one:
```ruby
class MyEventLogsListener
- include BCDD::Result::EventLogs::Listener
+ 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
@@ -2275,11 +2275,11 @@ class MyEventLogsListener
end
```
-⬆️ back to top
+⬆️ back to top
#### Setting multiple `listeners`
-You can use `BCDD::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.
+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.
@@ -2287,7 +2287,7 @@ You can use `BCDD::Result::EventLogs::Listeners[]` to creates a listener of list
```ruby
class AroundAndThenListener
- include BCDD::Result::EventLogs::Listener
+ include Solid::Result::EventLogs::Listener
# It must be a static/singleton method.
def self.around_and_then?
@@ -2300,7 +2300,7 @@ class AroundAndThenListener
end
class AroundEventLogsListener
- include BCDD::Result::EventLogs::Listener
+ include Solid::Result::EventLogs::Listener
# It must be a static/singleton method.
def self.around_event_logs?
@@ -2313,7 +2313,7 @@ class AroundEventLogsListener
end
class MyEventLogsListener
- include BCDD::Result::EventLogs::Listener
+ include Solid::Result::EventLogs::Listener
end
```
@@ -2321,7 +2321,7 @@ How to use it:
```ruby
# The listeners will be called in the order they were added.
-BCDD::Result.config.event_logs.listener = BCDD::Result::EventLogs::Listeners[
+Solid::Result.config.event_logs.listener = Solid::Result::EventLogs::Listeners[
MyEventLogsListener,
AroundAndThenListener,
AroundEventLogsListener
@@ -2330,19 +2330,19 @@ BCDD::Result.config.event_logs.listener = BCDD::Result::EventLogs::Listeners[
> 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
+⬆️ back to top
-## `BCDD::Result.configuration`
+## `Solid::Result.configuration`
-The `BCDD::Result.configuration` allows you to configure default behaviors for `BCDD::Result` and `BCDD::Context` through a configuration block. After using it, the configuration is frozen, ensuring the expected behaviors for your application.
+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 `BCDD::Result.configuration(freeze: false) {}` to avoid the freezing. This can be useful in tests. Please be sure to use it with caution.
+> 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
-BCDD::Result.configuration do |config|
+Solid::Result.configuration do |config|
config.addon.enable!(:given, :continue)
- config.constant_alias.enable!('Result', 'BCDD::Context')
+ config.constant_alias.enable!('Result', 'Solid::Output')
config.pattern_matching.disable!(:nil_as_valid_value_checking)
@@ -2356,129 +2356,124 @@ Let's see what each configuration in the example above does:
### `config.addon.enable!(:given, :continue)`
-This configuration enables the `Continue()` method for `BCDD::Result.mixin`, `BCDD::Context.mixin`, `BCDD::Result::Expectation.mixin`, and `BCDD::Context::Expectation.mixin`. Link to documentations: [(1)](#add-ons) [(2)](#mixin-add-ons).
+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', 'BCDD::Context')`
+### `config.constant_alias.enable!('Result', 'Solid::Output')`
-This configuration make `Result` a constant alias for `BCDD::Result`, and `BCDD::Context` a constant alias for `BCDD::Context`.
+This configuration make `Result` a constant alias for `Solid::Result`, and `Solid::Output` a constant alias for `Solid::Output`.
Link to documentations:
-- [Result alias](#bcddresult-versus-result)
-- [Context aliases](#constant-aliases)
+- [Result alias](#solidresult-versus-result)
### `config.pattern_matching.disable!(:nil_as_valid_value_checking)`
-This configuration disables the `nil_as_valid_value_checking` for `BCDD::Result` and `BCDD::Context`. Link to [documentation](#pattern-matching-support).
+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 `BCDD::Result` and `BCDD::Context`. The expectations are helpful in development and test environments, but they can be disabled in production environments for performance gain.
+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
+⬆️ back to top
-### `BCDD::Result.config`
+### `Solid::Result.config`
-The `BCDD::Result.config` allows you to access the current configuration.
+The `Solid::Result.config` allows you to access the current configuration.
-#### **BCDD::Result.config.addon**
+#### **Solid::Result.config.addon**
```ruby
-BCDD::Result.config.addon.enabled?(:continue)
-BCDD::Result.config.addon.enabled?(:given)
+Solid::Result.config.addon.enabled?(:continue)
+Solid::Result.config.addon.enabled?(:given)
-BCDD::Result.config.addon.options
+Solid::Result.config.addon.options
# {
# :continue=>{
# :enabled=>false,
# :affects=>[
-# "BCDD::Result.mixin",
-# "BCDD::Context.mixin",
-# "BCDD::Result::Expectations.mixin",
-# "BCDD::Context::Expectations.mixin"
+# "Solid::Result.mixin",
+# "Solid::Output.mixin",
+# "Solid::Result::Expectations.mixin",
+# "Solid::Output::Expectations.mixin"
# ]
# },
# :given=>{
# :enabled=>true,
# :affects=>[
-# "BCDD::Result.mixin",
-# "BCDD::Context.mixin",
-# "BCDD::Result::Expectations.mixin",
-# "BCDD::Context::Expectations.mixin"
+# "Solid::Result.mixin",
+# "Solid::Output.mixin",
+# "Solid::Result::Expectations.mixin",
+# "Solid::Output::Expectations.mixin"
# ]
# }
# }
```
-#### **BCDD::Result.config.constant_alias**
+#### **Solid::Result.config.constant_alias**
```ruby
-BCDD::Result.config.constant_alias.enabled?('Result')
-BCDD::Result.config.constant_alias.enabled?('Context')
-BCDD::Result.config.constant_alias.enabled?('BCDD::Context')
+Solid::Result.config.constant_alias.enabled?('Result')
-BCDD::Result.config.constant_alias.options
+Solid::Result.config.constant_alias.options
# {
-# "Result"=>{:enabled=>false, :affects=>["Object"]},
-# "Context"=>{:enabled=>false, :affects=>["Object"]},
-# "BCDD::Context"=>{:enabled=>false, :affects=>["BCDD"]}
+# "Result"=>{:enabled=>false, :affects=>["Object"]}
# }
```
-#### **BCDD::Result.config.pattern_matching**
+#### **Solid::Result.config.pattern_matching**
```ruby
-BCDD::Result.config.pattern_matching.enabled?(:nil_as_valid_value_checking)
+Solid::Result.config.pattern_matching.enabled?(:nil_as_valid_value_checking)
-BCDD::Result.config.pattern_matching.options
+Solid::Result.config.pattern_matching.options
# {
# :nil_as_valid_value_checking=>{
# :enabled=>false,
# :affects=>[
-# "BCDD::Result::Expectations,
-# "BCDD::Context::Expectations"
+# "Solid::Result::Expectations,
+# "Solid::Output::Expectations"
# ]
# }
# }
```
-#### **BCDD::Result.config.feature**
+#### **Solid::Result.config.feature**
```ruby
-BCDD::Result.config.feature.enabled?(:expectations)
+Solid::Result.config.feature.enabled?(:expectations)
-BCDD::Result.config.feature.options
+Solid::Result.config.feature.options
# {
# :expectations=>{
# :enabled=>true,
# :affects=>[
-# "BCDD::Result::Expectations,
-# "BCDD::Context::Expectations"
+# "Solid::Result::Expectations,
+# "Solid::Output::Expectations"
# ]
# },
# event_logs=>{
# :enabled=>true,
# :affects=>[
-# "BCDD::Result",
-# "BCDD::Context"
+# "Solid::Result",
+# "Solid::Output"
# ]
# },
# :and_then!=>{
# :enabled=>false,
# :affects=>[
-# "BCDD::Result",
-# "BCDD::Context"
+# "Solid::Result",
+# "Solid::Output"
# ]
# },
# }
```
-⬆️ back to top
+⬆️ back to top
-## `BCDD::Result#and_then!`
+## `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.
@@ -2513,15 +2508,15 @@ class PlaceOrder < Micro::Case
end
```
-To facilitate migration for users accustomed to the above approaches, `bcdd-result` includes the `BCDD::Result#and_then!`/`BCDD::Context#and_then!` methods, which will invoke the method `call` of the given operation and expect it to return a `BCDD::Result`/`BCDD::Context` object.
+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
-BCDD::Result.configure do |config|
+Solid::Result.configure do |config|
config.feature.enable!(:and_then!)
end
class PlaceOrder
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(**input)
Given(input)
@@ -2533,17 +2528,17 @@ class PlaceOrder
end
```
-⬆️ back to top
+⬆️ back to top
#### Dependency Injection
Like `#and_then`, `#and_then!` also supports an additional argument for dependency injection.
-**In BCDD::Result**
+**In Solid::Result**
```ruby
class PlaceOrder
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call(input, logger:)
Given(input)
@@ -2553,11 +2548,11 @@ class PlaceOrder
end
```
-**In BCDD::Context**
+**In Solid::Output**
```ruby
class PlaceOrder
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(logger:, **input)
Given(input)
@@ -2567,12 +2562,12 @@ class PlaceOrder
end
```
-⬆️ back to top
+⬆️ back to top
#### Configuration
```ruby
-BCDD::Result.configure do |config|
+Solid::Result.configure do |config|
config.feature.enable!(:and_then!)
config.and_then!.default_method_name_to_call = :perform
@@ -2585,7 +2580,7 @@ end
- `default_method_name_to_call`: Sets a default method other than `:call` for `and_then!`.
-⬆️ back to top
+⬆️ back to top
#### Analysis: Why is `and_then!` an Anti-pattern?
@@ -2597,9 +2592,9 @@ The `and_then!` approach, despite its brevity, introduces several issues:
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 `bcdd-result`.
+It should be a temporary solution, primarily for assisting in migration from another to gem to `solid-result`.
-⬆️ back to top
+⬆️ back to top
#### `#and_then` versus `#and_then!`
@@ -2607,11 +2602,11 @@ The main difference between the `#and_then` and `#and_then!` is that the latter
Attention: to ensure the correct behavior, do not mix `#and_then` and `#and_then!` in the same result chain.
-⬆️ back to top
+⬆️ back to top
#### Analysis: Why is `#and_then` the antidote/standard?
-The `BCDD::Result#and_then`/`BCDD::Context#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:
+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.
@@ -2621,7 +2616,7 @@ See this example to understand what your code should look like:
```ruby
class PlaceOrder
- include BCDD::Context.mixin(config: { addon: { continue: true } })
+ include Solid::Output.mixin(config: { addon: { continue: true } })
def call(**input)
Given(input)
@@ -2663,13 +2658,13 @@ class PlaceOrder
end
```
-⬆️ back to top
+⬆️ back to top
## About
[Rodrigo Serradura](https://github.com/serradura) created this project. He is the B/CDD process/method 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 B/CDD in code.
-⬆️ back to top
+⬆️ back to top
## Development
@@ -2677,20 +2672,20 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
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
+⬆️ back to top
## Contributing
-Bug reports and pull requests are welcome on GitHub at https://github.com/B-CDD/bcdd-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/B-CDD/bcdd-result/blob/master/CODE_OF_CONDUCT.md).
+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
+⬆️ 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
+⬆️ back to top
## Code of Conduct
-Everyone interacting in the BCDD::Result project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/B-CDD/bcdd-result/blob/master/CODE_OF_CONDUCT.md).
+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).
diff --git a/bin/console b/bin/console
index 46985834..5731da02 100755
--- a/bin/console
+++ b/bin/console
@@ -2,7 +2,7 @@
# frozen_string_literal: true
require 'bundler/setup'
-require 'bcdd/result'
+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.
diff --git a/examples/multiple_listeners/Rakefile b/examples/multiple_listeners/Rakefile
index e01e0cf7..0ddb4c53 100644
--- a/examples/multiple_listeners/Rakefile
+++ b/examples/multiple_listeners/Rakefile
@@ -17,19 +17,19 @@ end
# rake BREAK_USER_TOKEN_CREATION=t
#
# rake BREAK_ACCOUNT_CREATION=t HIDE_GIVEN_AND_CONTINUE=t
-task default: %i[bcdd_result_event_logs]
+task default: %i[solid_result_event_logs]
-desc 'creates an account and an owner user through BCDD::Result'
-task :bcdd_result_event_logs do
+desc 'creates an account and an owner user through Solid::Result'
+task :solid_result_event_logs do
require_relative 'config'
- BCDD::Result.configuration do |config|
+ Solid::Result.configuration do |config|
config.feature.disable!(:event_logs) if ENV['DISABLE_EVENT_LOGS']
unless ENV['DISABLE_LISTENER']
- config.event_logs.listener = BCDD::Result::EventLogs::Listeners[
+ config.event_logs.listener = Solid::Result::EventLogs::Listeners[
EventLogsListener::Stdout,
- BCDD::Result::EventLogsRecord::Listener
+ Solid::Result::EventLogsRecord::Listener
]
end
end
@@ -49,7 +49,7 @@ task :bcdd_result_event_logs do
nil
end
- puts "\nBCDD::Result::EventLogsRecord.count: #{BCDD::Result::EventLogsRecord.count}"
+ puts "\nSolid::Result::EventLogsRecord.count: #{Solid::Result::EventLogsRecord.count}"
puts "\nBenchmark: #{bench}"
end
diff --git a/examples/multiple_listeners/app/models/account/owner_creation.rb b/examples/multiple_listeners/app/models/account/owner_creation.rb
index 6527b480..37cf668e 100644
--- a/examples/multiple_listeners/app/models/account/owner_creation.rb
+++ b/examples/multiple_listeners/app/models/account/owner_creation.rb
@@ -2,11 +2,11 @@
class Account
class OwnerCreation
- include BCDD::Context.mixin
- include BCDD::Result::RollbackOnFailure
+ include Solid::Output.mixin
+ include Solid::Result::RollbackOnFailure
def call(**input)
- BCDD::Result.event_logs(name: self.class.name) do
+ Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
diff --git a/examples/multiple_listeners/app/models/user/creation.rb b/examples/multiple_listeners/app/models/user/creation.rb
index 28f8a896..b83a240a 100644
--- a/examples/multiple_listeners/app/models/user/creation.rb
+++ b/examples/multiple_listeners/app/models/user/creation.rb
@@ -2,11 +2,11 @@
class User
class Creation
- include BCDD::Context.mixin
- include BCDD::Result::RollbackOnFailure
+ include Solid::Output.mixin
+ include Solid::Result::RollbackOnFailure
def call(**input)
- BCDD::Result.event_logs(name: self.class.name) do
+ Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
diff --git a/examples/multiple_listeners/app/models/user/token/creation.rb b/examples/multiple_listeners/app/models/user/token/creation.rb
index bd40ba2d..bbd32191 100644
--- a/examples/multiple_listeners/app/models/user/token/creation.rb
+++ b/examples/multiple_listeners/app/models/user/token/creation.rb
@@ -2,10 +2,10 @@
class User::Token
class Creation
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(**input)
- BCDD::Result.event_logs(name: self.class.name) do
+ Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
diff --git a/examples/multiple_listeners/config.rb b/examples/multiple_listeners/config.rb
index 111c9ab0..8ffd7a58 100644
--- a/examples/multiple_listeners/config.rb
+++ b/examples/multiple_listeners/config.rb
@@ -5,12 +5,12 @@
$LOAD_PATH.unshift(__dir__)
require_relative 'config/boot'
-require_relative 'config/initializers/bcdd'
+require_relative 'config/initializers/solid_result'
require 'db/setup'
-require 'lib/bcdd/result/rollback_on_failure'
-require 'lib/bcdd/result/event_logs_record'
+require 'lib/solid/result/rollback_on_failure'
+require 'lib/solid/result/event_logs_record'
require 'lib/runtime_breaker'
module EventLogsListener
diff --git a/examples/multiple_listeners/config/boot.rb b/examples/multiple_listeners/config/boot.rb
index 098c0622..772c52b3 100644
--- a/examples/multiple_listeners/config/boot.rb
+++ b/examples/multiple_listeners/config/boot.rb
@@ -10,7 +10,7 @@
gem 'sqlite3', '~> 1.7'
gem 'bcrypt', '~> 3.1.20'
gem 'activerecord', '~> 7.1', '>= 7.1.3', require: 'active_record'
- gem 'bcdd-result', path: '../../'
+ gem 'solid-result', path: '../../'
end
require 'active_support/all'
diff --git a/examples/service_objects/config/initializers/bcdd.rb b/examples/multiple_listeners/config/initializers/solid_result.rb
similarity index 84%
rename from examples/service_objects/config/initializers/bcdd.rb
rename to examples/multiple_listeners/config/initializers/solid_result.rb
index e03924b3..7e8e3da1 100644
--- a/examples/service_objects/config/initializers/bcdd.rb
+++ b/examples/multiple_listeners/config/initializers/solid_result.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-BCDD::Result.config.then do |config|
+Solid::Result.config.then do |config|
config.addon.enable!(:continue)
config.pattern_matching.disable!(:nil_as_valid_value_checking)
diff --git a/examples/multiple_listeners/db/setup.rb b/examples/multiple_listeners/db/setup.rb
index 51cd04b2..a03e3bd3 100644
--- a/examples/multiple_listeners/db/setup.rb
+++ b/examples/multiple_listeners/db/setup.rb
@@ -10,7 +10,7 @@
ActiveRecord::Schema.define do
suppress_messages do
- create_table :bcdd_result_event_logs do |t|
+ 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
diff --git a/examples/multiple_listeners/lib/event_logs_listener/stdout.rb b/examples/multiple_listeners/lib/event_logs_listener/stdout.rb
index 488836a6..68ced53a 100644
--- a/examples/multiple_listeners/lib/event_logs_listener/stdout.rb
+++ b/examples/multiple_listeners/lib/event_logs_listener/stdout.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: true
class EventLogsListener::Stdout
- include BCDD::Result::EventLogs::Listener
+ include Solid::Result::EventLogs::Listener
def initialize
@buffer = []
@@ -44,7 +44,7 @@ def before_interruption(exception:, event_logs:)
bc = ::ActiveSupport::BacktraceCleaner.new
bc.add_filter { |line| line.gsub(__dir__.sub('/lib', ''), '').sub(/\A\//, '')}
- bc.add_silencer { |line| /lib\/bcdd\/result/.match?(line) }
+ bc.add_silencer { |line| /lib\/solid\/result/.match?(line) }
bc.add_silencer { |line| line.include?(RUBY_VERSION) }
dir = "#{FileUtils.pwd[1..]}/"
diff --git a/examples/multiple_listeners/lib/bcdd/result/event_logs_record.rb b/examples/multiple_listeners/lib/solid/result/event_logs_record.rb
similarity index 66%
rename from examples/multiple_listeners/lib/bcdd/result/event_logs_record.rb
rename to examples/multiple_listeners/lib/solid/result/event_logs_record.rb
index f0fca0ec..ba88a1e2 100644
--- a/examples/multiple_listeners/lib/bcdd/result/event_logs_record.rb
+++ b/examples/multiple_listeners/lib/solid/result/event_logs_record.rb
@@ -1,16 +1,16 @@
# frozen_string_literal: true
-class BCDD::Result::EventLogsRecord < ActiveRecord::Base
- self.table_name = 'bcdd_result_event_logs'
+class Solid::Result::EventLogsRecord < ActiveRecord::Base
+ self.table_name = 'solid_result_event_logs'
class Listener
- include ::BCDD::Result::EventLogs::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'
- BCDD::Result::EventLogsRecord.create(
+ Solid::Result::EventLogsRecord.create(
root_name: root_name,
trace_id: metadata[:trace_id],
version: event_logs[:version],
@@ -21,7 +21,7 @@ def on_finish(event_logs:)
rescue ::StandardError => e
err = "#{e.message} (#{e.class}); Backtrace: #{e.backtrace.join(', ')}"
- ::Kernel.warn "Error on BCDD::Result::EventLogsRecord::Listener#on_finish: #{err}"
+ ::Kernel.warn "Error on Solid::Result::EventLogsRecord::Listener#on_finish: #{err}"
end
end
end
diff --git a/examples/single_listener/lib/bcdd/result/rollback_on_failure.rb b/examples/multiple_listeners/lib/solid/result/rollback_on_failure.rb
similarity index 85%
rename from examples/single_listener/lib/bcdd/result/rollback_on_failure.rb
rename to examples/multiple_listeners/lib/solid/result/rollback_on_failure.rb
index dbf40b7a..a2fed118 100644
--- a/examples/single_listener/lib/bcdd/result/rollback_on_failure.rb
+++ b/examples/multiple_listeners/lib/solid/result/rollback_on_failure.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module BCDD::Result::RollbackOnFailure
+module Solid::Result::RollbackOnFailure
def rollback_on_failure(model: ::ActiveRecord::Base)
result = nil
diff --git a/examples/service_objects/Rakefile b/examples/service_objects/Rakefile
index 7b80b3dc..1d975fb7 100644
--- a/examples/service_objects/Rakefile
+++ b/examples/service_objects/Rakefile
@@ -5,14 +5,14 @@ if RUBY_VERSION <= '3.1'
exit! 1
end
-task default: %i[bcdd_result_event_logs]
+task default: %i[solid_result_event_logs]
task :config do
require_relative 'config'
end
-desc 'creates an account and an owner user through BCDD::Result'
-task bcdd_result_event_logs: %i[config] do
+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",
diff --git a/examples/service_objects/app/services/application_service.rb b/examples/service_objects/app/services/application_service.rb
index f4fe46d3..df8e15b0 100644
--- a/examples/service_objects/app/services/application_service.rb
+++ b/examples/service_objects/app/services/application_service.rb
@@ -33,7 +33,7 @@ def input(&block)
end
def inherited(subclass)
- subclass.include ::BCDD::Context.mixin(config: { addon: { continue: true } })
+ subclass.include ::Solid::Output.mixin(config: { addon: { continue: true } })
end
def call(arg)
@@ -50,7 +50,7 @@ def initialize(input)
end
def call!
- ::BCDD::Result.event_logs(name: self.class.name) do
+ ::Solid::Result.event_logs(name: self.class.name) do
if input.invalid?
Failure(:invalid_input, input: input)
else
diff --git a/examples/service_objects/config.rb b/examples/service_objects/config.rb
index 14d48f46..e7a2f73b 100644
--- a/examples/service_objects/config.rb
+++ b/examples/service_objects/config.rb
@@ -5,7 +5,7 @@
$LOAD_PATH.unshift(__dir__)
require_relative 'config/boot'
-require_relative 'config/initializers/bcdd'
+require_relative 'config/initializers/solid_result'
require 'db/setup'
diff --git a/examples/service_objects/config/boot.rb b/examples/service_objects/config/boot.rb
index 00569ac0..5d8d626a 100644
--- a/examples/service_objects/config/boot.rb
+++ b/examples/service_objects/config/boot.rb
@@ -11,7 +11,7 @@
gem 'bcrypt', '~> 3.1.20'
gem 'activerecord', '~> 7.1', '>= 7.1.3', require: 'active_record'
gem 'type_validator'
- gem 'bcdd-result', path: '../../'
+ gem 'solid-result', path: '../../'
end
require 'active_support/all'
diff --git a/examples/multiple_listeners/config/initializers/bcdd.rb b/examples/service_objects/config/initializers/solid_result.rb
similarity index 84%
rename from examples/multiple_listeners/config/initializers/bcdd.rb
rename to examples/service_objects/config/initializers/solid_result.rb
index e03924b3..7e8e3da1 100644
--- a/examples/multiple_listeners/config/initializers/bcdd.rb
+++ b/examples/service_objects/config/initializers/solid_result.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-BCDD::Result.config.then do |config|
+Solid::Result.config.then do |config|
config.addon.enable!(:continue)
config.pattern_matching.disable!(:nil_as_valid_value_checking)
diff --git a/examples/single_listener/Rakefile b/examples/single_listener/Rakefile
index 3a3511f2..c5ec37b1 100644
--- a/examples/single_listener/Rakefile
+++ b/examples/single_listener/Rakefile
@@ -17,15 +17,15 @@ end
# rake BREAK_USER_TOKEN_CREATION=t
#
# rake BREAK_ACCOUNT_CREATION=t HIDE_GIVEN_AND_CONTINUE=t
-task default: %i[bcdd_result_event_logs]
+task default: %i[solid_result_event_logs]
task :config do
require_relative 'config'
end
-desc 'creates an account and an owner user through BCDD::Result'
-task bcdd_result_event_logs: %i[config] do
- BCDD::Result.configuration do |config|
+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']
diff --git a/examples/single_listener/app/models/account/owner_creation.rb b/examples/single_listener/app/models/account/owner_creation.rb
index 6527b480..37cf668e 100644
--- a/examples/single_listener/app/models/account/owner_creation.rb
+++ b/examples/single_listener/app/models/account/owner_creation.rb
@@ -2,11 +2,11 @@
class Account
class OwnerCreation
- include BCDD::Context.mixin
- include BCDD::Result::RollbackOnFailure
+ include Solid::Output.mixin
+ include Solid::Result::RollbackOnFailure
def call(**input)
- BCDD::Result.event_logs(name: self.class.name) do
+ Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
diff --git a/examples/single_listener/app/models/user/creation.rb b/examples/single_listener/app/models/user/creation.rb
index 28f8a896..b83a240a 100644
--- a/examples/single_listener/app/models/user/creation.rb
+++ b/examples/single_listener/app/models/user/creation.rb
@@ -2,11 +2,11 @@
class User
class Creation
- include BCDD::Context.mixin
- include BCDD::Result::RollbackOnFailure
+ include Solid::Output.mixin
+ include Solid::Result::RollbackOnFailure
def call(**input)
- BCDD::Result.event_logs(name: self.class.name) do
+ Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
diff --git a/examples/single_listener/app/models/user/token/creation.rb b/examples/single_listener/app/models/user/token/creation.rb
index bd40ba2d..bbd32191 100644
--- a/examples/single_listener/app/models/user/token/creation.rb
+++ b/examples/single_listener/app/models/user/token/creation.rb
@@ -2,10 +2,10 @@
class User::Token
class Creation
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(**input)
- BCDD::Result.event_logs(name: self.class.name) do
+ Solid::Result.event_logs(name: self.class.name) do
Given(input)
.and_then(:normalize_input)
.and_then(:validate_input)
diff --git a/examples/single_listener/config.rb b/examples/single_listener/config.rb
index d1ebdf7e..125405b5 100644
--- a/examples/single_listener/config.rb
+++ b/examples/single_listener/config.rb
@@ -5,11 +5,11 @@
$LOAD_PATH.unshift(__dir__)
require_relative 'config/boot'
-require_relative 'config/initializers/bcdd'
+require_relative 'config/initializers/solid_result'
require 'db/setup'
-require 'lib/bcdd/result/rollback_on_failure'
+require 'lib/solid/result/rollback_on_failure'
require 'lib/single_event_logs_listener'
require 'lib/runtime_breaker'
diff --git a/examples/single_listener/config/boot.rb b/examples/single_listener/config/boot.rb
index 098c0622..772c52b3 100644
--- a/examples/single_listener/config/boot.rb
+++ b/examples/single_listener/config/boot.rb
@@ -10,7 +10,7 @@
gem 'sqlite3', '~> 1.7'
gem 'bcrypt', '~> 3.1.20'
gem 'activerecord', '~> 7.1', '>= 7.1.3', require: 'active_record'
- gem 'bcdd-result', path: '../../'
+ gem 'solid-result', path: '../../'
end
require 'active_support/all'
diff --git a/examples/single_listener/config/initializers/bcdd.rb b/examples/single_listener/config/initializers/solid_result.rb
similarity index 84%
rename from examples/single_listener/config/initializers/bcdd.rb
rename to examples/single_listener/config/initializers/solid_result.rb
index e03924b3..7e8e3da1 100644
--- a/examples/single_listener/config/initializers/bcdd.rb
+++ b/examples/single_listener/config/initializers/solid_result.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-BCDD::Result.config.then do |config|
+Solid::Result.config.then do |config|
config.addon.enable!(:continue)
config.pattern_matching.disable!(:nil_as_valid_value_checking)
diff --git a/examples/single_listener/lib/single_event_logs_listener.rb b/examples/single_listener/lib/single_event_logs_listener.rb
index cc35526e..829b0939 100644
--- a/examples/single_listener/lib/single_event_logs_listener.rb
+++ b/examples/single_listener/lib/single_event_logs_listener.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: true
class SingleEventLogsListener
- include BCDD::Result::EventLogs::Listener
+ 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
@@ -101,7 +101,7 @@ def before_interruption(exception:, event_logs:)
bc = ::ActiveSupport::BacktraceCleaner.new
bc.add_filter { |line| line.gsub(__dir__.sub('/lib', ''), '').sub(/\A\//, '')}
- bc.add_silencer { |line| /lib\/bcdd\/result/.match?(line) }
+ bc.add_silencer { |line| /lib\/solid\/result/.match?(line) }
bc.add_silencer { |line| line.include?(RUBY_VERSION) }
dir = "#{FileUtils.pwd[1..]}/"
diff --git a/examples/multiple_listeners/lib/bcdd/result/rollback_on_failure.rb b/examples/single_listener/lib/solid/result/rollback_on_failure.rb
similarity index 85%
rename from examples/multiple_listeners/lib/bcdd/result/rollback_on_failure.rb
rename to examples/single_listener/lib/solid/result/rollback_on_failure.rb
index dbf40b7a..a2fed118 100644
--- a/examples/multiple_listeners/lib/bcdd/result/rollback_on_failure.rb
+++ b/examples/single_listener/lib/solid/result/rollback_on_failure.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module BCDD::Result::RollbackOnFailure
+module Solid::Result::RollbackOnFailure
def rollback_on_failure(model: ::ActiveRecord::Base)
result = nil
diff --git a/lib/bcdd-result.rb b/lib/solid-result.rb
similarity index 57%
rename from lib/bcdd-result.rb
rename to lib/solid-result.rb
index f24644a4..427d1717 100644
--- a/lib/bcdd-result.rb
+++ b/lib/solid-result.rb
@@ -1,3 +1,3 @@
# frozen_string_literal: true
-require 'bcdd/result'
+require 'solid/result'
diff --git a/lib/bcdd/failure.rb b/lib/solid/failure.rb
similarity index 95%
rename from lib/bcdd/failure.rb
rename to lib/solid/failure.rb
index be7a6752..2c156780 100644
--- a/lib/bcdd/failure.rb
+++ b/lib/solid/failure.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module BCDD
+module Solid
module Failure
def success?(_type = nil)
false
diff --git a/lib/bcdd/context.rb b/lib/solid/output.rb
similarity index 88%
rename from lib/bcdd/context.rb
rename to lib/solid/output.rb
index 93ca60bd..65ee2a1b 100644
--- a/lib/bcdd/context.rb
+++ b/lib/solid/output.rb
@@ -1,13 +1,13 @@
# frozen_string_literal: true
-class BCDD::Context < BCDD::Result
- require_relative 'context/failure'
- require_relative 'context/success'
- require_relative 'context/mixin'
- require_relative 'context/expectations'
- require_relative 'context/callable_and_then'
+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 = 'BCDD::Context::Success or BCDD::Context::Failure'
+ EXPECTED_OUTCOME = 'Solid::Output::Success or Solid::Output::Failure'
def self.Success(type, **value)
Success.new(type: type, value: value)
@@ -100,7 +100,7 @@ def call_and_then_callable!(source, value:, injected_value:, method_name:)
end
def ensure_result_object(result, origin:)
- raise_unexpected_outcome_error(result, origin) unless result.is_a?(BCDD::Context)
+ raise_unexpected_outcome_error(result, origin) unless result.is_a?(Solid::Output)
return result.tap { _1.memo.merge!(memo) } if result.source.equal?(source)
diff --git a/lib/bcdd/context/callable_and_then.rb b/lib/solid/output/callable_and_then.rb
similarity index 86%
rename from lib/bcdd/context/callable_and_then.rb
rename to lib/solid/output/callable_and_then.rb
index b5afe5b3..6ad9a978 100644
--- a/lib/bcdd/context/callable_and_then.rb
+++ b/lib/solid/output/callable_and_then.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: true
-module BCDD
- module Context::CallableAndThen
+module Solid
+ module Output::CallableAndThen
class Caller < Result::CallableAndThen::Caller
module KeyArgs
def self.parameters?(source)
@@ -28,10 +28,10 @@ def self.call_method!(source, method, value, _injected_value)
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?(Context)
+ 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: Context::EXPECTED_OUTCOME)
+ expected: Output::EXPECTED_OUTCOME)
end
private_class_method :call_proc!, :call_method!
diff --git a/lib/bcdd/context/expectations.rb b/lib/solid/output/expectations.rb
similarity index 82%
rename from lib/bcdd/context/expectations.rb
rename to lib/solid/output/expectations.rb
index 6d41e77d..4f5f6802 100644
--- a/lib/bcdd/context/expectations.rb
+++ b/lib/solid/output/expectations.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: true
-class BCDD::Context
- class Expectations < BCDD::Result::Expectations
+class Solid::Output
+ class Expectations < Solid::Result::Expectations
require_relative 'expectations/mixin'
def self.mixin_module
@@ -9,7 +9,7 @@ def self.mixin_module
end
def self.result_factory_without_expectations
- ::BCDD::Context
+ ::Solid::Output
end
private_class_method :mixin!, :mixin_module, :result_factory_without_expectations
diff --git a/lib/bcdd/context/expectations/mixin.rb b/lib/solid/output/expectations/mixin.rb
similarity index 55%
rename from lib/bcdd/context/expectations/mixin.rb
rename to lib/solid/output/expectations/mixin.rb
index 7f9c8fb1..0a44c067 100644
--- a/lib/bcdd/context/expectations/mixin.rb
+++ b/lib/solid/output/expectations/mixin.rb
@@ -1,15 +1,15 @@
# frozen_string_literal: true
-class BCDD::Context
+class Solid::Output
module Expectations::Mixin
- Factory = BCDD::Result::Expectations::Mixin::Factory
+ Factory = Solid::Result::Expectations::Mixin::Factory
- Methods = BCDD::Result::Expectations::Mixin::Methods
+ Methods = Solid::Result::Expectations::Mixin::Methods
module Addons
module Continue
private def Continue(**value)
- Success(::BCDD::Result::IgnoredTypes::CONTINUE, **value)
+ Success(::Solid::Result::IgnoredTypes::CONTINUE, **value)
end
end
@@ -17,14 +17,14 @@ module Given
private def Given(*values)
value = values.map(&:to_h).reduce({}) { |acc, val| acc.merge(val) }
- Success(::BCDD::Result::IgnoredTypes::GIVEN, **value)
+ Success(::Solid::Result::IgnoredTypes::GIVEN, **value)
end
end
OPTIONS = { continue: Continue, given: Given }.freeze
def self.options(config_flags)
- ::BCDD::Result::Config::Options.addon(map: config_flags, from: OPTIONS)
+ ::Solid::Result::Config::Options.addon(map: config_flags, from: OPTIONS)
end
end
end
diff --git a/lib/bcdd/context/failure.rb b/lib/solid/output/failure.rb
similarity index 56%
rename from lib/bcdd/context/failure.rb
rename to lib/solid/output/failure.rb
index 920a512e..c6d9a107 100644
--- a/lib/bcdd/context/failure.rb
+++ b/lib/solid/output/failure.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: true
-class BCDD::Context::Failure < BCDD::Context
- include ::BCDD::Failure
+class Solid::Output::Failure < Solid::Output
+ include ::Solid::Failure
def and_expose(_type, _keys, **_options)
self
diff --git a/lib/bcdd/context/mixin.rb b/lib/solid/output/mixin.rb
similarity index 76%
rename from lib/bcdd/context/mixin.rb
rename to lib/solid/output/mixin.rb
index 0113b91c..70a8aa9a 100644
--- a/lib/bcdd/context/mixin.rb
+++ b/lib/solid/output/mixin.rb
@@ -1,8 +1,8 @@
# frozen_string_literal: true
-class BCDD::Context
+class Solid::Output
module Mixin
- Factory = BCDD::Result::Mixin::Factory
+ Factory = Solid::Result::Mixin::Factory
module Methods
def Success(type, **value)
@@ -25,7 +25,7 @@ def Success(type, **value)
end
private def Continue(**value)
- _ResultAs(Success, ::BCDD::Result::IgnoredTypes::CONTINUE, value)
+ _ResultAs(Success, ::Solid::Result::IgnoredTypes::CONTINUE, value)
end
end
@@ -33,14 +33,14 @@ module Given
private def Given(*values)
value = values.map(&:to_h).reduce({}) { |acc, val| acc.merge(val) }
- _ResultAs(Success, ::BCDD::Result::IgnoredTypes::GIVEN, value)
+ _ResultAs(Success, ::Solid::Result::IgnoredTypes::GIVEN, value)
end
end
OPTIONS = { continue: Continue, given: Given }.freeze
def self.options(config_flags)
- ::BCDD::Result::Config::Options.addon(map: config_flags, from: OPTIONS)
+ ::Solid::Result::Config::Options.addon(map: config_flags, from: OPTIONS)
end
end
end
@@ -50,7 +50,7 @@ def self.mixin_module
end
def self.result_factory
- ::BCDD::Context
+ ::Solid::Output
end
private_class_method :mixin_module, :result_factory
diff --git a/lib/bcdd/context/success.rb b/lib/solid/output/success.rb
similarity index 91%
rename from lib/bcdd/context/success.rb
rename to lib/solid/output/success.rb
index 6f90bc4a..9b32c15b 100644
--- a/lib/bcdd/context/success.rb
+++ b/lib/solid/output/success.rb
@@ -1,12 +1,12 @@
# frozen_string_literal: true
-class BCDD::Context
- class Error < BCDD::Result::Error
+class Solid::Output
+ class Error < Solid::Result::Error
InvalidExposure = ::Class.new(self)
end
class Success < self
- include ::BCDD::Success
+ include ::Solid::Success
FetchValues = ->(memo_values, keys) do
fetched_values = memo_values.fetch_values(*keys)
diff --git a/lib/bcdd/result.rb b/lib/solid/result.rb
similarity index 90%
rename from lib/bcdd/result.rb
rename to lib/solid/result.rb
index e0aaaa6a..8d90abc6 100644
--- a/lib/bcdd/result.rb
+++ b/lib/solid/result.rb
@@ -2,7 +2,7 @@
require 'set'
-module BCDD
+module Solid
require_relative 'success'
require_relative 'failure'
@@ -22,8 +22,6 @@ class Result
require_relative 'result/config'
require_relative 'result/_self'
- require_relative 'context'
-
- Context = ::BCDD::Context
+ require_relative 'output'
end
end
diff --git a/lib/bcdd/result/_self.rb b/lib/solid/result/_self.rb
similarity index 98%
rename from lib/bcdd/result/_self.rb
rename to lib/solid/result/_self.rb
index 4c224041..ecdd7a42 100644
--- a/lib/bcdd/result/_self.rb
+++ b/lib/solid/result/_self.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
attr_accessor :unknown, :event_logs
attr_reader :source, :data, :type_checker, :terminal
@@ -189,7 +189,7 @@ def call_and_then_callable!(source, value:, injected_value:, method_name:)
end
def ensure_result_object(result, origin:)
- raise Error::UnexpectedOutcome.build(outcome: result, origin: origin) unless result.is_a?(::BCDD::Result)
+ raise Error::UnexpectedOutcome.build(outcome: result, origin: origin) unless result.is_a?(::Solid::Result)
return result if result.source.equal?(source)
diff --git a/lib/bcdd/result/callable_and_then.rb b/lib/solid/result/callable_and_then.rb
similarity index 91%
rename from lib/bcdd/result/callable_and_then.rb
rename to lib/solid/result/callable_and_then.rb
index 2a26691e..979b2b7f 100644
--- a/lib/bcdd/result/callable_and_then.rb
+++ b/lib/solid/result/callable_and_then.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
module CallableAndThen
require_relative 'callable_and_then/error'
require_relative 'callable_and_then/config'
diff --git a/lib/bcdd/result/callable_and_then/caller.rb b/lib/solid/result/callable_and_then/caller.rb
similarity index 95%
rename from lib/bcdd/result/callable_and_then/caller.rb
rename to lib/solid/result/callable_and_then/caller.rb
index beea6b65..85694448 100644
--- a/lib/bcdd/result/callable_and_then/caller.rb
+++ b/lib/solid/result/callable_and_then/caller.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class CallableAndThen::Caller
def self.call(source, value:, injected_value:, method_name:)
method = callable_method(source, method_name)
@@ -38,7 +38,7 @@ def self.callable_method(source, method_name)
end
def self.ensure_result_object(source, _value, result)
- return result if result.is_a?(::BCDD::Result)
+ return result if result.is_a?(::Solid::Result)
raise Error::UnexpectedOutcome.build(outcome: result, origin: source)
end
diff --git a/lib/bcdd/result/callable_and_then/config.rb b/lib/solid/result/callable_and_then/config.rb
similarity index 93%
rename from lib/bcdd/result/callable_and_then/config.rb
rename to lib/solid/result/callable_and_then/config.rb
index de1da51f..dafd8f00 100644
--- a/lib/bcdd/result/callable_and_then/config.rb
+++ b/lib/solid/result/callable_and_then/config.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class CallableAndThen::Config
attr_accessor :default_method_name_to_call
diff --git a/lib/bcdd/result/callable_and_then/error.rb b/lib/solid/result/callable_and_then/error.rb
similarity index 93%
rename from lib/bcdd/result/callable_and_then/error.rb
rename to lib/solid/result/callable_and_then/error.rb
index fc6de247..fe449496 100644
--- a/lib/bcdd/result/callable_and_then/error.rb
+++ b/lib/solid/result/callable_and_then/error.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class CallableAndThen::Error < Error
class InvalidArity < self
def self.build(source:, method:, arity:)
diff --git a/lib/bcdd/result/config.rb b/lib/solid/result/config.rb
similarity index 98%
rename from lib/bcdd/result/config.rb
rename to lib/solid/result/config.rb
index e077a1fa..e4c9613a 100644
--- a/lib/bcdd/result/config.rb
+++ b/lib/solid/result/config.rb
@@ -7,7 +7,7 @@
require_relative 'config/switchers/features'
require_relative 'config/switchers/pattern_matching'
-class BCDD::Result
+class Solid::Result
class Config
attr_reader :addon, :feature, :constant_alias, :pattern_matching
diff --git a/lib/bcdd/result/config/options.rb b/lib/solid/result/config/options.rb
similarity index 96%
rename from lib/bcdd/result/config/options.rb
rename to lib/solid/result/config/options.rb
index bd9704b0..a258d12a 100644
--- a/lib/bcdd/result/config/options.rb
+++ b/lib/solid/result/config/options.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Config
module Options
def self.with_defaults(all_flags, config)
diff --git a/lib/bcdd/result/config/switcher.rb b/lib/solid/result/config/switcher.rb
similarity index 98%
rename from lib/bcdd/result/config/switcher.rb
rename to lib/solid/result/config/switcher.rb
index 8db30c4b..6a1a4940 100644
--- a/lib/bcdd/result/config/switcher.rb
+++ b/lib/solid/result/config/switcher.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Config
class Switcher
attr_reader :_options, :_affects, :listener
diff --git a/lib/bcdd/result/config/switchers/addons.rb b/lib/solid/result/config/switchers/addons.rb
similarity index 70%
rename from lib/bcdd/result/config/switchers/addons.rb
rename to lib/solid/result/config/switchers/addons.rb
index 16c6c8c2..b45b94a7 100644
--- a/lib/bcdd/result/config/switchers/addons.rb
+++ b/lib/solid/result/config/switchers/addons.rb
@@ -1,13 +1,13 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Config
module Addons
AFFECTS = %w[
- BCDD::Result.mixin
- BCDD::Context.mixin
- BCDD::Result::Expectations.mixin
- BCDD::Context::Expectations.mixin
+ Solid::Result.mixin
+ Solid::Output.mixin
+ Solid::Result::Expectations.mixin
+ Solid::Output::Expectations.mixin
].freeze
OPTIONS = {
diff --git a/lib/bcdd/result/config/switchers/constant_aliases.rb b/lib/solid/result/config/switchers/constant_aliases.rb
similarity index 96%
rename from lib/bcdd/result/config/switchers/constant_aliases.rb
rename to lib/solid/result/config/switchers/constant_aliases.rb
index 5ca7c6b7..46ce0462 100644
--- a/lib/bcdd/result/config/switchers/constant_aliases.rb
+++ b/lib/solid/result/config/switchers/constant_aliases.rb
@@ -1,10 +1,10 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Config
module ConstantAliases
MAPPING = {
- 'Result' => { target: ::Object, name: :Result, value: ::BCDD::Result }
+ 'Result' => { target: ::Object, name: :Result, value: ::Solid::Result }
}.transform_values!(&:freeze).freeze
OPTIONS = MAPPING.to_h do |option_name, mapping|
diff --git a/lib/bcdd/result/config/switchers/features.rb b/lib/solid/result/config/switchers/features.rb
similarity index 65%
rename from lib/bcdd/result/config/switchers/features.rb
rename to lib/solid/result/config/switchers/features.rb
index 7d77ca09..e4dc2315 100644
--- a/lib/bcdd/result/config/switchers/features.rb
+++ b/lib/solid/result/config/switchers/features.rb
@@ -1,20 +1,20 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Config
module Features
OPTIONS = {
expectations: {
default: true,
- affects: %w[BCDD::Result::Expectations BCDD::Context::Expectations]
+ affects: %w[Solid::Result::Expectations Solid::Output::Expectations]
},
event_logs: {
default: true,
- affects: %w[BCDD::Result BCDD::Context BCDD::Result::Expectations BCDD::Context::Expectations]
+ affects: %w[Solid::Result Solid::Output Solid::Result::Expectations Solid::Output::Expectations]
},
and_then!: {
default: false,
- affects: %w[BCDD::Result BCDD::Context BCDD::Result::Expectations BCDD::Context::Expectations]
+ affects: %w[Solid::Result Solid::Output Solid::Result::Expectations Solid::Output::Expectations]
}
}.transform_values!(&:freeze).freeze
diff --git a/lib/bcdd/result/config/switchers/pattern_matching.rb b/lib/solid/result/config/switchers/pattern_matching.rb
similarity index 77%
rename from lib/bcdd/result/config/switchers/pattern_matching.rb
rename to lib/solid/result/config/switchers/pattern_matching.rb
index 1b7cb5d6..a5beeff2 100644
--- a/lib/bcdd/result/config/switchers/pattern_matching.rb
+++ b/lib/solid/result/config/switchers/pattern_matching.rb
@@ -1,12 +1,12 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Config
module PatternMatching
OPTIONS = {
nil_as_valid_value_checking: {
default: false,
- affects: %w[BCDD::Result::Expectations BCDD::Context::Expectations]
+ affects: %w[Solid::Result::Expectations Solid::Output::Expectations]
}
}.transform_values!(&:freeze).freeze
diff --git a/lib/bcdd/result/contract.rb b/lib/solid/result/contract.rb
similarity index 96%
rename from lib/bcdd/result/contract.rb
rename to lib/solid/result/contract.rb
index 2d9b1374..bdf7ada5 100644
--- a/lib/bcdd/result/contract.rb
+++ b/lib/solid/result/contract.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module BCDD::Result::Contract
+module Solid::Result::Contract
require_relative 'contract/error'
require_relative 'contract/type_checker'
require_relative 'contract/interface'
diff --git a/lib/bcdd/result/contract/disabled.rb b/lib/solid/result/contract/disabled.rb
similarity index 94%
rename from lib/bcdd/result/contract/disabled.rb
rename to lib/solid/result/contract/disabled.rb
index 2b69d939..30ad8904 100644
--- a/lib/bcdd/result/contract/disabled.rb
+++ b/lib/solid/result/contract/disabled.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
module Contract::Disabled
extend Contract::Interface
diff --git a/lib/bcdd/result/contract/error.rb b/lib/solid/result/contract/error.rb
similarity index 88%
rename from lib/bcdd/result/contract/error.rb
rename to lib/solid/result/contract/error.rb
index 34537115..2f13f193 100644
--- a/lib/bcdd/result/contract/error.rb
+++ b/lib/solid/result/contract/error.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result::Contract::Error < BCDD::Result::Error
+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(', ')}")
diff --git a/lib/bcdd/result/contract/evaluator.rb b/lib/solid/result/contract/evaluator.rb
similarity index 98%
rename from lib/bcdd/result/contract/evaluator.rb
rename to lib/solid/result/contract/evaluator.rb
index 5555ef96..f6878947 100644
--- a/lib/bcdd/result/contract/evaluator.rb
+++ b/lib/solid/result/contract/evaluator.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Contract::Evaluator
include Contract::Interface
diff --git a/lib/bcdd/result/contract/for_types.rb b/lib/solid/result/contract/for_types.rb
similarity index 96%
rename from lib/bcdd/result/contract/for_types.rb
rename to lib/solid/result/contract/for_types.rb
index d25b5a35..1c5bd8ad 100644
--- a/lib/bcdd/result/contract/for_types.rb
+++ b/lib/solid/result/contract/for_types.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Contract::ForTypes
include Contract::Interface
diff --git a/lib/bcdd/result/contract/for_types_and_values.rb b/lib/solid/result/contract/for_types_and_values.rb
similarity index 98%
rename from lib/bcdd/result/contract/for_types_and_values.rb
rename to lib/solid/result/contract/for_types_and_values.rb
index 9cef3fdf..35c26491 100644
--- a/lib/bcdd/result/contract/for_types_and_values.rb
+++ b/lib/solid/result/contract/for_types_and_values.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Contract::ForTypesAndValues
include Contract::Interface
diff --git a/lib/bcdd/result/contract/interface.rb b/lib/solid/result/contract/interface.rb
similarity index 94%
rename from lib/bcdd/result/contract/interface.rb
rename to lib/solid/result/contract/interface.rb
index 9075b13b..b9f74406 100644
--- a/lib/bcdd/result/contract/interface.rb
+++ b/lib/solid/result/contract/interface.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
module Contract::Interface
def allowed_types
raise Error::NotImplemented
diff --git a/lib/bcdd/result/contract/type_checker.rb b/lib/solid/result/contract/type_checker.rb
similarity index 96%
rename from lib/bcdd/result/contract/type_checker.rb
rename to lib/solid/result/contract/type_checker.rb
index 71dc7233..94b38b57 100644
--- a/lib/bcdd/result/contract/type_checker.rb
+++ b/lib/solid/result/contract/type_checker.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module BCDD::Result::Contract
+module Solid::Result::Contract
class TypeChecker
attr_reader :result_type, :expectations
diff --git a/lib/bcdd/result/data.rb b/lib/solid/result/data.rb
similarity index 96%
rename from lib/bcdd/result/data.rb
rename to lib/solid/result/data.rb
index 62a83963..41d192e8 100644
--- a/lib/bcdd/result/data.rb
+++ b/lib/solid/result/data.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Data
attr_reader :kind, :type, :value
diff --git a/lib/bcdd/result/error.rb b/lib/solid/result/error.rb
similarity index 88%
rename from lib/bcdd/result/error.rb
rename to lib/solid/result/error.rb
index ce1317db..5a386b20 100644
--- a/lib/bcdd/result/error.rb
+++ b/lib/solid/result/error.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result::Error < StandardError
+class Solid::Result::Error < StandardError
def self.build(**_kargs)
new
end
@@ -16,7 +16,7 @@ def initialize(_message = nil)
class UnexpectedOutcome < self
def self.build(outcome:, origin:, expected: nil)
- expected ||= 'BCDD::Result::Success or BCDD::Result::Failure'
+ expected ||= 'Solid::Result::Success or Solid::Result::Failure'
new("Unexpected outcome: #{outcome.inspect}. The #{origin} must return this object wrapped by #{expected}")
end
@@ -52,7 +52,7 @@ class CallableAndThenDisabled < self
def initialize(_message = nil)
super(
'You cannot use #and_then! as the feature is disabled. ' \
- 'Please use BCDD::Result.config.feature.enable!(:and_then!) to enable it.'
+ 'Please use Solid::Result.config.feature.enable!(:and_then!) to enable it.'
)
end
end
diff --git a/lib/bcdd/result/event_logs.rb b/lib/solid/result/event_logs.rb
similarity index 82%
rename from lib/bcdd/result/event_logs.rb
rename to lib/solid/result/event_logs.rb
index 3d2a5d7e..c8de7c33 100644
--- a/lib/bcdd/result/event_logs.rb
+++ b/lib/solid/result/event_logs.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
module EventLogs
require_relative 'event_logs/listener'
require_relative 'event_logs/listeners'
@@ -8,10 +8,10 @@ module EventLogs
require_relative 'event_logs/tree'
require_relative 'event_logs/tracking'
- THREAD_VAR_NAME = :bcdd_result_event_logs_tracking
+ THREAD_VAR_NAME = :solid_result_event_logs_tracking
EnsureResult = ->(result) do
- return result if result.is_a?(::BCDD::Result)
+ return result if result.is_a?(::Solid::Result)
raise Error::UnexpectedOutcome.build(outcome: result, origin: :event_logs)
end
diff --git a/lib/bcdd/result/event_logs/config.rb b/lib/solid/result/event_logs/config.rb
similarity index 94%
rename from lib/bcdd/result/event_logs/config.rb
rename to lib/solid/result/event_logs/config.rb
index bacb7760..445a7bdf 100644
--- a/lib/bcdd/result/event_logs/config.rb
+++ b/lib/solid/result/event_logs/config.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module BCDD::Result::EventLogs
+module Solid::Result::EventLogs
class Config
attr_reader :listener, :trace_id
diff --git a/lib/bcdd/result/event_logs/listener.rb b/lib/solid/result/event_logs/listener.rb
similarity index 96%
rename from lib/bcdd/result/event_logs/listener.rb
rename to lib/solid/result/event_logs/listener.rb
index b8cd2da0..83e201b2 100644
--- a/lib/bcdd/result/event_logs/listener.rb
+++ b/lib/solid/result/event_logs/listener.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module BCDD::Result::EventLogs
+module Solid::Result::EventLogs
module Listener
module ClassMethods
def around_event_logs?
diff --git a/lib/bcdd/result/event_logs/listeners.rb b/lib/solid/result/event_logs/listeners.rb
similarity index 98%
rename from lib/bcdd/result/event_logs/listeners.rb
rename to lib/solid/result/event_logs/listeners.rb
index 92587950..73a12ae0 100644
--- a/lib/bcdd/result/event_logs/listeners.rb
+++ b/lib/solid/result/event_logs/listeners.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module BCDD::Result::EventLogs
+module Solid::Result::EventLogs
class Listeners
class Chain
include Listener
diff --git a/lib/bcdd/result/event_logs/tracking.rb b/lib/solid/result/event_logs/tracking.rb
similarity index 80%
rename from lib/bcdd/result/event_logs/tracking.rb
rename to lib/solid/result/event_logs/tracking.rb
index b0af4276..ff6a6193 100644
--- a/lib/bcdd/result/event_logs/tracking.rb
+++ b/lib/solid/result/event_logs/tracking.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
module EventLogs
module Tracking
require_relative 'tracking/enabled'
@@ -19,7 +19,7 @@ module Tracking
}.freeze
def self.instance
- ::BCDD::Result::Config.instance.feature.enabled?(:event_logs) ? Tracking::Enabled.new : Tracking::Disabled
+ ::Solid::Result::Config.instance.feature.enabled?(:event_logs) ? Tracking::Enabled.new : Tracking::Disabled
end
end
end
diff --git a/lib/bcdd/result/event_logs/tracking/disabled.rb b/lib/solid/result/event_logs/tracking/disabled.rb
similarity index 87%
rename from lib/bcdd/result/event_logs/tracking/disabled.rb
rename to lib/solid/result/event_logs/tracking/disabled.rb
index 7f4ddc93..981275de 100644
--- a/lib/bcdd/result/event_logs/tracking/disabled.rb
+++ b/lib/solid/result/event_logs/tracking/disabled.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module BCDD::Result::EventLogs
+module Solid::Result::EventLogs
module Tracking::Disabled
def self.exec(_name, _desc)
EnsureResult[yield]
diff --git a/lib/bcdd/result/event_logs/tracking/enabled.rb b/lib/solid/result/event_logs/tracking/enabled.rb
similarity index 99%
rename from lib/bcdd/result/event_logs/tracking/enabled.rb
rename to lib/solid/result/event_logs/tracking/enabled.rb
index c092704f..a64f3eba 100644
--- a/lib/bcdd/result/event_logs/tracking/enabled.rb
+++ b/lib/solid/result/event_logs/tracking/enabled.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module BCDD::Result::EventLogs
+module Solid::Result::EventLogs
class Tracking::Enabled
attr_accessor :tree, :records, :root_started_at, :listener
diff --git a/lib/bcdd/result/event_logs/tree.rb b/lib/solid/result/event_logs/tree.rb
similarity index 99%
rename from lib/bcdd/result/event_logs/tree.rb
rename to lib/solid/result/event_logs/tree.rb
index d95f86af..eef8a4a9 100644
--- a/lib/bcdd/result/event_logs/tree.rb
+++ b/lib/solid/result/event_logs/tree.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
module EventLogs
class Tree
class Node
diff --git a/lib/bcdd/result/expectations.rb b/lib/solid/result/expectations.rb
similarity index 97%
rename from lib/bcdd/result/expectations.rb
rename to lib/solid/result/expectations.rb
index 31356597..f3495adc 100644
--- a/lib/bcdd/result/expectations.rb
+++ b/lib/solid/result/expectations.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Expectations
require_relative 'expectations/mixin'
@@ -25,7 +25,7 @@ def self.mixin_module
end
def self.result_factory_without_expectations
- ::BCDD::Result
+ ::Solid::Result
end
def self.new(...)
diff --git a/lib/bcdd/result/expectations/mixin.rb b/lib/solid/result/expectations/mixin.rb
similarity index 98%
rename from lib/bcdd/result/expectations/mixin.rb
rename to lib/solid/result/expectations/mixin.rb
index fa362446..e3f4dff8 100644
--- a/lib/bcdd/result/expectations/mixin.rb
+++ b/lib/solid/result/expectations/mixin.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
module Expectations::Mixin
module Factory
def self.module!
diff --git a/lib/bcdd/result/failure.rb b/lib/solid/result/failure.rb
similarity index 75%
rename from lib/bcdd/result/failure.rb
rename to lib/solid/result/failure.rb
index a049cf57..8d054a4d 100644
--- a/lib/bcdd/result/failure.rb
+++ b/lib/solid/result/failure.rb
@@ -1,8 +1,8 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Failure < self
- include ::BCDD::Failure
+ include ::Solid::Failure
end
def self.Failure(type, value = nil)
diff --git a/lib/bcdd/result/handler.rb b/lib/solid/result/handler.rb
similarity index 98%
rename from lib/bcdd/result/handler.rb
rename to lib/solid/result/handler.rb
index 9e336587..0fc6ec8a 100644
--- a/lib/bcdd/result/handler.rb
+++ b/lib/solid/result/handler.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Handler
require_relative 'handler/allowed_types'
diff --git a/lib/bcdd/result/handler/allowed_types.rb b/lib/solid/result/handler/allowed_types.rb
similarity index 97%
rename from lib/bcdd/result/handler/allowed_types.rb
rename to lib/solid/result/handler/allowed_types.rb
index 0740633f..39574bda 100644
--- a/lib/bcdd/result/handler/allowed_types.rb
+++ b/lib/solid/result/handler/allowed_types.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Handler
class AllowedTypes
attr_reader :unchecked, :type_checker
diff --git a/lib/bcdd/result/ignored_types.rb b/lib/solid/result/ignored_types.rb
similarity index 91%
rename from lib/bcdd/result/ignored_types.rb
rename to lib/solid/result/ignored_types.rb
index 56377b20..354015ac 100644
--- a/lib/bcdd/result/ignored_types.rb
+++ b/lib/solid/result/ignored_types.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
module IgnoredTypes
LIST = ::Set[
GIVEN = :_given_,
diff --git a/lib/bcdd/result/mixin.rb b/lib/solid/result/mixin.rb
similarity index 97%
rename from lib/bcdd/result/mixin.rb
rename to lib/solid/result/mixin.rb
index 52e56aa6..3bfe42d7 100644
--- a/lib/bcdd/result/mixin.rb
+++ b/lib/solid/result/mixin.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
module Mixin
module Factory
def self.module!
@@ -65,7 +65,7 @@ def self.mixin_module
end
def self.result_factory
- ::BCDD::Result
+ ::Solid::Result
end
private_class_method :mixin_module, :result_factory
diff --git a/lib/bcdd/result/success.rb b/lib/solid/result/success.rb
similarity index 75%
rename from lib/bcdd/result/success.rb
rename to lib/solid/result/success.rb
index 149f1f8c..eb2ed9b8 100644
--- a/lib/bcdd/result/success.rb
+++ b/lib/solid/result/success.rb
@@ -1,8 +1,8 @@
# frozen_string_literal: true
-class BCDD::Result
+class Solid::Result
class Success < self
- include ::BCDD::Success
+ include ::Solid::Success
end
def self.Success(type, value = nil)
diff --git a/lib/bcdd/result/version.rb b/lib/solid/result/version.rb
similarity index 61%
rename from lib/bcdd/result/version.rb
rename to lib/solid/result/version.rb
index 72b211ed..35b63975 100644
--- a/lib/bcdd/result/version.rb
+++ b/lib/solid/result/version.rb
@@ -1,7 +1,7 @@
# frozen_string_literal: true
-module BCDD
+module Solid
class Result
- VERSION = '1.1.0'
+ VERSION = '2.0.0'
end
end
diff --git a/lib/bcdd/success.rb b/lib/solid/success.rb
similarity index 95%
rename from lib/bcdd/success.rb
rename to lib/solid/success.rb
index 9fd8adde..8133ce91 100644
--- a/lib/bcdd/success.rb
+++ b/lib/solid/success.rb
@@ -1,6 +1,6 @@
# frozen_string_literal: true
-module BCDD
+module Solid
module Success
def success?(type = nil)
type.nil? || type_checker.allow_success?([type])
diff --git a/sig/bcdd/context.rbs b/sig/bcdd/context.rbs
deleted file mode 100644
index 5679e900..00000000
--- a/sig/bcdd/context.rbs
+++ /dev/null
@@ -1,175 +0,0 @@
-class BCDD::Context < BCDD::Result
- EXPECTED_OUTCOME: String
-
- SourceMethodArity: ^(Method) -> Integer
-
- attr_reader memo: Hash[Symbol, untyped]
-
- def initialize: (
- type: Symbol,
- value: untyped,
- ?source: untyped,
- ?expectations: BCDD::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]) -> BCDD::Context
-
- def call_and_then_callable!: (untyped, value: untyped, injected_value: untyped, method_name: (Symbol | nil)) -> BCDD::Context
-
- def ensure_result_object: (untyped, origin: Symbol) -> BCDD::Context
-
- def raise_unexpected_outcome_error: (BCDD::Context | untyped, Symbol) -> void
-end
-
-class BCDD::Context
- class Error < BCDD::Result::Error
- class InvalidExposure < BCDD::Context::Error
- end
- end
-end
-
-class BCDD::Context
- class Success < BCDD::Context
- include BCDD::Success
-
- FetchValues: Proc
-
- def and_expose: (Symbol, Array[Symbol], terminal: bool) -> BCDD::Context::Success
- end
-
- def self.Success: (Symbol, **untyped) -> BCDD::Context::Success
-end
-
-module BCDD::Context::CallableAndThen
- class Caller < BCDD::Result::CallableAndThen::Caller
- module KeyArgs
- def self.parameters?: (untyped) -> bool
-
- def self.invalid_arity: (untyped, Symbol) -> BCDD::Result::CallableAndThen::Error::InvalidArity
- end
-
- def self.call: (
- untyped source,
- value: untyped,
- injected_value: untyped,
- method_name: (Symbol | nil),
- ) -> BCDD::Context
-
- private
-
- def self.call_proc!: (
- untyped source,
- Hash[Symbol, untyped] value,
- nil injected_value
- ) -> BCDD::Context
-
- def self.call_method!: (
- untyped source,
- Method method,
- Hash[Symbol, untyped] value,
- nil injected_value
- ) -> BCDD::Context
-
- def self.callable_method: (
- untyped source,
- (Symbol | nil) method_name
- ) -> ::Method
-
- def self.ensure_result_object: (
- untyped source,
- untyped value,
- BCDD::Context result
- ) -> BCDD::Context
-
- def self.expected_result_object: () -> singleton(BCDD::Context)
-
- def self.expected_outcome: () -> String
- end
-end
-
-class BCDD::Context
- class Failure < BCDD::Context
- include BCDD::Failure
-
- def and_expose: (Symbol, Array[Symbol], **untyped) -> BCDD::Context::Failure
- end
-
- def self.Failure: (Symbol, **untyped) -> BCDD::Context::Failure
-end
-
-class BCDD::Context
- module Mixin
- Factory: singleton(BCDD::Result::Mixin::Factory)
-
- module Methods
- def Success: (Symbol, **untyped) -> BCDD::Context::Success
-
- def Failure: (Symbol, **untyped) -> BCDD::Context::Failure
-
- private
-
- def _ResultAs: (singleton(BCDD::Context), Symbol, untyped, ?terminal: bool) -> untyped
- end
-
- module Addons
- module Continue
- include BCDD::Context::Mixin::Methods
-
- private
-
- def Continue: (**untyped) -> BCDD::Context::Success
- end
-
- module Given
- include BCDD::Context::Mixin::Methods
-
- private
-
- def Given: (*untyped) -> BCDD::Context::Success
- end
-
- OPTIONS: Hash[Symbol, Module]
-
- def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
- end
- end
-
- def self.mixin_module: -> singleton(BCDD::Context::Mixin)
-
- def self.result_factory: -> singleton(BCDD::Context)
-end
-
-class BCDD::Context::Expectations < BCDD::Result::Expectations
- def self.mixin_module: -> singleton(BCDD::Context::Expectations::Mixin)
-
- def self.result_factory_without_expectations: -> singleton(BCDD::Result)
-
- def Success: (Symbol, **untyped) -> BCDD::Context::Success
- def Failure: (Symbol, **untyped) -> BCDD::Context::Failure
-end
-
-module BCDD::Context::Expectations::Mixin
- Methods: singleton(BCDD::Result::Expectations::Mixin::Methods)
- Factory: singleton(BCDD::Result::Expectations::Mixin::Factory)
-
- module Addons
- module Continue
- private def Continue: (**untyped) -> BCDD::Context::Success
- end
-
- module Given
- private def Given: (*untyped) -> BCDD::Context::Success
- end
-
- OPTIONS: Hash[Symbol, Module]
-
- def self.options: (Hash[Symbol, Hash[Symbol, bool]]) -> Hash[Symbol, Module]
- end
-end
diff --git a/sig/bcdd/result.rbs b/sig/bcdd/result.rbs
deleted file mode 100644
index a5f597cd..00000000
--- a/sig/bcdd/result.rbs
+++ /dev/null
@@ -1,85 +0,0 @@
-class BCDD::Result
- private attr_accessor unknown: bool
- private attr_writer event_logs: Hash[Symbol, untyped]
- private attr_reader type_checker: BCDD::Result::Contract::TypeChecker
-
- attr_reader data: BCDD::Result::Data
- attr_reader source: untyped
- attr_reader terminal: bool
- attr_reader event_logs: Hash[Symbol, untyped]
-
- def self.config: -> BCDD::Result::Config
- def self.configuration: (freeze: bool) { (BCDD::Result::Config) -> void } -> (bool | BCDD::Result::Config)
- def self.event_logs: (name: untyped, desc: untyped) { () -> untyped } -> BCDD::Result
-
- def initialize: (
- type: Symbol,
- value: untyped,
- ?source: untyped,
- ?expectations: BCDD::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 } -> BCDD::Result
- def on_success: (*Symbol) { (untyped, Symbol) -> void } -> BCDD::Result
- def on_failure: (*Symbol) { (untyped, Symbol) -> void } -> BCDD::Result
- def on_unknown: () { (untyped, Symbol) -> void } -> BCDD::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: () { (BCDD::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) -> BCDD::Result
- def call_and_then_source_method!: (untyped, untyped) -> BCDD::Result
- def call_and_then_block: (untyped) -> BCDD::Result
- def call_and_then_block!: (untyped) -> BCDD::Result
- def call_and_then_callable!: (untyped, value: untyped, injected_value: untyped, method_name: (Symbol | nil)) -> BCDD::Result
- def ensure_result_object: (untyped, origin: Symbol) -> BCDD::Result
-end
-
-class BCDD::Result
- class Success < BCDD::Result
- include BCDD::Success
- end
-
- def self.Success: (Symbol type, ?untyped value) -> BCDD::Result::Success
-end
-
-class BCDD::Result
- class Failure < BCDD::Result
- include BCDD::Failure
- end
-
- def self.Failure: (Symbol type, ?untyped value) -> BCDD::Result::Failure
-end
diff --git a/sig/bcdd/result/context.rbs b/sig/bcdd/result/context.rbs
deleted file mode 100644
index 334f4b45..00000000
--- a/sig/bcdd/result/context.rbs
+++ /dev/null
@@ -1,3 +0,0 @@
-class BCDD::Result
- Context: BCDD::Context
-end
diff --git a/sig/bcdd/result/error.rbs b/sig/bcdd/result/error.rbs
deleted file mode 100644
index d1200965..00000000
--- a/sig/bcdd/result/error.rbs
+++ /dev/null
@@ -1,34 +0,0 @@
-class BCDD::Result
- class Error < StandardError
- def self.build: (**untyped) -> BCDD::Result::Error
-
- class NotImplemented < BCDD::Result::Error
- end
-
- class MissingTypeArgument < BCDD::Result::Error
- end
-
- class UnexpectedOutcome < BCDD::Result::Error
- def self.build: (outcome: untyped, origin: Symbol, ?expected: String)
- -> BCDD::Result::Error::UnexpectedOutcome
- end
-
- class InvalidResultSource < BCDD::Result::Error
- def self.build: (given_result: BCDD::Result, expected_source: untyped)
- -> BCDD::Result::Error::InvalidResultSource
- end
-
- class InvalidSourceMethodArity < BCDD::Result::Error
- def self.build: (source: untyped, method: Method, max_arity: Integer)
- -> BCDD::Result::Error::InvalidSourceMethodArity
- end
-
- class UnhandledTypes < BCDD::Result::Error
- def self.build: (types: Set[Symbol])
- -> BCDD::Result::Error::UnhandledTypes
- end
-
- class CallableAndThenDisabled < BCDD::Result::Error
- end
- end
-end
diff --git a/sig/bcdd/result/mixin.rbs b/sig/bcdd/result/mixin.rbs
deleted file mode 100644
index 118d4742..00000000
--- a/sig/bcdd/result/mixin.rbs
+++ /dev/null
@@ -1,45 +0,0 @@
-class BCDD::Result
- module Mixin
- module Factory
- def self.module!: -> Module
- end
-
- module Methods
- def Success: (Symbol type, ?untyped value) -> BCDD::Result::Success
-
- def Failure: (Symbol type, ?untyped value) -> BCDD::Result::Failure
-
- private
-
- def _ResultAs: (singleton(BCDD::Result), Symbol, untyped, ?terminal: bool) -> untyped
- end
-
- module Addons
- module Continue
- include BCDD::Result::Mixin::Methods
-
- private
-
- def Continue: (untyped) -> BCDD::Result::Success
- end
-
- module Given
- include BCDD::Result::Mixin::Methods
-
- private
-
- def Given: (untyped) -> BCDD::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(BCDD::Result::Mixin)
-
- def self.result_factory: -> singleton(BCDD::Result)
-end
diff --git a/sig/bcdd/failure.rbs b/sig/solid/failure.rbs
similarity index 75%
rename from sig/bcdd/failure.rbs
rename to sig/solid/failure.rbs
index 7440e909..50b23854 100644
--- a/sig/bcdd/failure.rbs
+++ b/sig/solid/failure.rbs
@@ -1,4 +1,4 @@
-module BCDD
+module Solid
module Failure
def success?: (?Symbol type) -> bool
def failure?: (?Symbol type) -> bool
@@ -8,6 +8,6 @@ module BCDD
private
def kind: -> Symbol
- def type_checker: -> BCDD::Result::Contract::TypeChecker
+ def type_checker: -> Solid::Result::Contract::TypeChecker
end
end
diff --git a/sig/solid/output.rbs b/sig/solid/output.rbs
new file mode 100644
index 00000000..848536aa
--- /dev/null
+++ b/sig/solid/output.rbs
@@ -0,0 +1,175 @@
+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
diff --git a/sig/solid/result.rbs b/sig/solid/result.rbs
new file mode 100644
index 00000000..1dfda85c
--- /dev/null
+++ b/sig/solid/result.rbs
@@ -0,0 +1,85 @@
+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
diff --git a/sig/bcdd/result/callable_and_then.rbs b/sig/solid/result/callable_and_then.rbs
similarity index 78%
rename from sig/bcdd/result/callable_and_then.rbs
rename to sig/solid/result/callable_and_then.rbs
index b0c70182..2aa8ce7a 100644
--- a/sig/bcdd/result/callable_and_then.rbs
+++ b/sig/solid/result/callable_and_then.rbs
@@ -1,4 +1,4 @@
-module BCDD::Result::CallableAndThen
+module Solid::Result::CallableAndThen
class Config
attr_accessor default_method_name_to_call: Symbol
@@ -7,7 +7,7 @@ module BCDD::Result::CallableAndThen
def options: () -> Hash[Symbol, untyped]
end
- class Error < BCDD::Result::Error
+ class Error < Solid::Result::Error
end
class Error::InvalidArity < Error
@@ -24,7 +24,7 @@ module BCDD::Result::CallableAndThen
value: untyped,
injected_value: untyped,
method_name: (Symbol | nil)
- ) -> BCDD::Result
+ ) -> Solid::Result
private
@@ -32,14 +32,14 @@ module BCDD::Result::CallableAndThen
untyped source,
untyped value,
untyped injected_value
- ) -> BCDD::Result
+ ) -> Solid::Result
def self.call_method!: (
untyped source,
Method method,
untyped value,
untyped injected_value
- ) -> BCDD::Result
+ ) -> Solid::Result
def self.callable_method: (
untyped source,
@@ -49,10 +49,10 @@ module BCDD::Result::CallableAndThen
def self.ensure_result_object: (
untyped source,
untyped value,
- BCDD::Result result
- ) -> BCDD::Result
+ Solid::Result result
+ ) -> Solid::Result
- def self.expected_result_object: () -> singleton(BCDD::Result)
+ def self.expected_result_object: () -> singleton(Solid::Result)
def self.expected_outcome: () -> String
end
diff --git a/sig/bcdd/result/config.rbs b/sig/solid/result/config.rbs
similarity index 63%
rename from sig/bcdd/result/config.rbs
rename to sig/solid/result/config.rbs
index d567894a..96301361 100644
--- a/sig/bcdd/result/config.rbs
+++ b/sig/solid/result/config.rbs
@@ -1,26 +1,26 @@
-class BCDD::Result::Config
+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: BCDD::Result::Config::Switcher
- attr_reader feature: BCDD::Result::Config::Switcher
- attr_reader constant_alias: BCDD::Result::Config::Switcher
- attr_reader pattern_matching: BCDD::Result::Config::Switcher
+ 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: -> BCDD::Result::Config
+ def self.instance: -> Solid::Result::Config
def initialize: -> void
- def and_then!: () -> BCDD::Result::CallableAndThen::Config
- def event_logs: () -> BCDD::Result::EventLogs::Config
+ def and_then!: () -> Solid::Result::CallableAndThen::Config
+ def event_logs: () -> Solid::Result::EventLogs::Config
- def freeze: -> BCDD::Result::Config
- def options: -> Hash[Symbol, BCDD::Result::Config::Switcher]
+ def freeze: -> Solid::Result::Config
+ def options: -> Hash[Symbol, Solid::Result::Config::Switcher]
def to_h: -> Hash[Symbol, Hash[Symbol | String, bool]]
end
-module BCDD::Result::Config::Options
+module Solid::Result::Config::Options
def self.with_defaults: (
Hash[Symbol, Hash[Symbol, bool]],
Symbol
@@ -38,7 +38,7 @@ module BCDD::Result::Config::Options
) -> Hash[Symbol, Module]
end
-class BCDD::Result::Config::Switcher
+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
@@ -48,7 +48,7 @@ class BCDD::Result::Config::Switcher
?listener: Proc
) -> void
- def freeze: -> BCDD::Result::Config::Switcher
+ def freeze: -> Solid::Result::Config::Switcher
def to_h: -> Hash[Symbol | String, bool]
@@ -73,30 +73,30 @@ class BCDD::Result::Config::Switcher
def available_options_message: -> String
end
-module BCDD::Result::Config::Addons
+module Solid::Result::Config::Addons
AFFECTS: Array[String]
OPTIONS: Hash[String, Hash[Symbol, untyped]]
- def self.switcher: -> BCDD::Result::Config::Switcher
+ def self.switcher: -> Solid::Result::Config::Switcher
end
-module BCDD::Result::Config::ConstantAliases
+module Solid::Result::Config::ConstantAliases
MAPPING: Hash[String, Hash[Symbol, untyped]]
OPTIONS: Hash[String, Hash[Symbol, untyped]]
Listener: Proc
- def self.switcher: -> BCDD::Result::Config::Switcher
+ def self.switcher: -> Solid::Result::Config::Switcher
end
-module BCDD::Result::Config::Features
+module Solid::Result::Config::Features
OPTIONS: Hash[String, Hash[Symbol, untyped]]
Listener: Proc
- def self.switcher: -> BCDD::Result::Config::Switcher
+ def self.switcher: -> Solid::Result::Config::Switcher
end
-module BCDD::Result::Config::PatternMatching
+module Solid::Result::Config::PatternMatching
OPTIONS: Hash[String, Hash[Symbol, untyped]]
- def self.switcher: -> BCDD::Result::Config::Switcher
+ def self.switcher: -> Solid::Result::Config::Switcher
end
diff --git a/sig/bcdd/result/contract.rbs b/sig/solid/result/contract.rbs
similarity index 54%
rename from sig/bcdd/result/contract.rbs
rename to sig/solid/result/contract.rbs
index 6dcd69a4..37d345be 100644
--- a/sig/bcdd/result/contract.rbs
+++ b/sig/solid/result/contract.rbs
@@ -1,29 +1,29 @@
-module BCDD::Result::Contract
- NONE: BCDD::Result::Contract::Evaluator
+module Solid::Result::Contract
+ NONE: Solid::Result::Contract::Evaluator
def self.evaluate: (
- BCDD::Result::Data,
- BCDD::Result::Contract::Evaluator
- ) -> BCDD::Result::Contract::TypeChecker
+ Solid::Result::Data,
+ Solid::Result::Contract::Evaluator
+ ) -> Solid::Result::Contract::TypeChecker
ToEnsure: ^(Hash[Symbol, untyped] | Array[Symbol], Hash[Symbol, Hash[Symbol, bool]])
- -> BCDD::Result::Contract::Interface
+ -> 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]]
- ) -> BCDD::Result::Contract::Evaluator
+ ) -> Solid::Result::Contract::Evaluator
end
-module BCDD::Result::Contract
+module Solid::Result::Contract
class TypeChecker
attr_reader result_type: Symbol
- attr_reader expectations: BCDD::Result::Contract::Evaluator
+ attr_reader expectations: Solid::Result::Contract::Evaluator
def initialize: (
Symbol,
- expectations: BCDD::Result::Contract::Evaluator
+ expectations: Solid::Result::Contract::Evaluator
) -> void
def allow!: (Symbol) -> Symbol
@@ -35,27 +35,27 @@ module BCDD::Result::Contract
def validate: (
Array[Symbol],
- expected: BCDD::Result::Contract::Interface,
+ expected: Solid::Result::Contract::Interface,
allow_empty: bool
) -> bool
end
end
-class BCDD::Result::Contract::Error < BCDD::Result::Error
- class UnexpectedType < BCDD::Result::Contract::Error
+class Solid::Result::Contract::Error < Solid::Result::Error
+ class UnexpectedType < Solid::Result::Contract::Error
def self.build: (type: Symbol, allowed_types: Set[Symbol])
- -> BCDD::Result::Contract::Error::UnexpectedType
+ -> Solid::Result::Contract::Error::UnexpectedType
end
- class UnexpectedValue < BCDD::Result::Contract::Error
+ class UnexpectedValue < Solid::Result::Contract::Error
def self.build: (type: Symbol, value: untyped, ?cause: Exception)
- -> BCDD::Result::Contract::Error::UnexpectedValue
+ -> Solid::Result::Contract::Error::UnexpectedValue
end
end
-module BCDD::Result::Contract
+module Solid::Result::Contract
module Interface
- def ==: (BCDD::Result::Contract::Interface) -> bool
+ def ==: (Solid::Result::Contract::Interface) -> bool
def allowed_types: -> Set[Symbol]
@@ -63,13 +63,13 @@ module BCDD::Result::Contract
def type!: (Symbol) -> Symbol
- def type_and_value!: (BCDD::Result::Data) -> void
+ def type_and_value!: (Solid::Result::Data) -> void
def !=: (untyped) -> bool
end
end
-module BCDD::Result::Contract
+module Solid::Result::Contract
module Disabled
extend Interface
@@ -77,7 +77,7 @@ module BCDD::Result::Contract
end
end
-module BCDD::Result::Contract
+module Solid::Result::Contract
class ForTypes
include Interface
@@ -85,7 +85,7 @@ module BCDD::Result::Contract
end
end
-module BCDD::Result::Contract
+module Solid::Result::Contract
class ForTypesAndValues
include Interface
@@ -100,21 +100,21 @@ module BCDD::Result::Contract
end
end
-module BCDD::Result::Contract
+module Solid::Result::Contract
class Evaluator
include Interface
attr_reader allowed_types: Set[Symbol]
- attr_reader success: BCDD::Result::Contract::Interface
- attr_reader failure: BCDD::Result::Contract::Interface
+ attr_reader success: Solid::Result::Contract::Interface
+ attr_reader failure: Solid::Result::Contract::Interface
def initialize: (
- BCDD::Result::Contract::Interface,
- BCDD::Result::Contract::Interface
+ Solid::Result::Contract::Interface,
+ Solid::Result::Contract::Interface
) -> void
private
- def for: (BCDD::Result::Data) -> BCDD::Result::Contract::Interface
+ def for: (Solid::Result::Data) -> Solid::Result::Contract::Interface
end
end
diff --git a/sig/bcdd/result/data.rbs b/sig/solid/result/data.rbs
similarity index 94%
rename from sig/bcdd/result/data.rbs
rename to sig/solid/result/data.rbs
index a1c0c778..deb271c6 100644
--- a/sig/bcdd/result/data.rbs
+++ b/sig/solid/result/data.rbs
@@ -1,4 +1,4 @@
-class BCDD::Result
+class Solid::Result
class Data
attr_reader kind: Symbol
attr_reader type: Symbol
diff --git a/sig/solid/result/error.rbs b/sig/solid/result/error.rbs
new file mode 100644
index 00000000..96ac7fdb
--- /dev/null
+++ b/sig/solid/result/error.rbs
@@ -0,0 +1,34 @@
+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
diff --git a/sig/bcdd/result/event_logs.rbs b/sig/solid/result/event_logs.rbs
similarity index 93%
rename from sig/bcdd/result/event_logs.rbs
rename to sig/solid/result/event_logs.rbs
index 0adf9292..454c624b 100644
--- a/sig/bcdd/result/event_logs.rbs
+++ b/sig/solid/result/event_logs.rbs
@@ -1,4 +1,4 @@
-class BCDD::Result
+class Solid::Result
module EventLogs
module Listener
module ClassMethods
@@ -140,7 +140,7 @@ class BCDD::Result
def exec: (untyped, untyped) { () -> untyped } -> untyped
def err!: (::Exception, untyped) -> void
def reset!: () -> void
- def record: (BCDD::Result) -> void
+ def record: (Solid::Result) -> void
def record_and_then: ((untyped), untyped) { () -> untyped } -> untyped
def reset_and_then!: () -> void
@@ -153,8 +153,8 @@ class BCDD::Result
def root_start: (Array[untyped]) -> void
- def track: (BCDD::Result, time: Time) -> void
- def track_record: (BCDD::Result, Time) -> Hash[Symbol, untyped]
+ def track: (Solid::Result, time: Time) -> void
+ def track_record: (Solid::Result, Time) -> Hash[Symbol, untyped]
def now_in_milliseconds: () -> Integer
@@ -167,8 +167,8 @@ class BCDD::Result
def self.exec: (untyped, untyped) { () -> untyped } -> untyped
def self.err!: (::Exception) -> void
def self.reset!: () -> void
- def self.record: (BCDD::Result) -> void
- def self.record_and_then: ((untyped), untyped) { () -> BCDD::Result } -> BCDD::Result
+ def self.record: (Solid::Result) -> void
+ def self.record_and_then: ((untyped), untyped) { () -> Solid::Result } -> Solid::Result
def self.reset_and_then!: () -> void
private
@@ -182,7 +182,7 @@ class BCDD::Result
THREAD_VAR_NAME: Symbol
- EnsureResult: ^(untyped) -> BCDD::Result
+ EnsureResult: ^(untyped) -> Solid::Result
def self.tracking: () -> (Tracking::Enabled | singleton(Tracking::Disabled))
end
diff --git a/sig/bcdd/result/expectations.rbs b/sig/solid/result/expectations.rbs
similarity index 54%
rename from sig/bcdd/result/expectations.rbs
rename to sig/solid/result/expectations.rbs
index 0c1b399b..0d6b4b18 100644
--- a/sig/bcdd/result/expectations.rbs
+++ b/sig/solid/result/expectations.rbs
@@ -1,4 +1,4 @@
-class BCDD::Result::Expectations
+class Solid::Result::Expectations
def self.mixin: (
?config: Hash[Symbol, Hash[Symbol, bool]],
?success: Hash[Symbol, untyped] | Array[Symbol],
@@ -11,39 +11,39 @@ class BCDD::Result::Expectations
?failure: Hash[Symbol, untyped] | Array[Symbol]
) -> Module
- def self.mixin_module: -> singleton(BCDD::Result::Expectations::Mixin)
+ def self.mixin_module: -> singleton(Solid::Result::Expectations::Mixin)
- def self.result_factory_without_expectations: -> singleton(BCDD::Result)
+ def self.result_factory_without_expectations: -> singleton(Solid::Result)
def self.new: (
?source: untyped,
- ?contract: BCDD::Result::Contract::Evaluator,
+ ?contract: Solid::Result::Contract::Evaluator,
?terminal: bool,
**untyped
- ) -> (BCDD::Result::Expectations | untyped)
+ ) -> (Solid::Result::Expectations | untyped)
def initialize: (
?source: untyped,
- ?contract: BCDD::Result::Contract::Evaluator,
+ ?contract: Solid::Result::Contract::Evaluator,
?terminal: bool,
**untyped
) -> void
- def Success: (Symbol, ?untyped) -> BCDD::Result::Success
- def Failure: (Symbol, ?untyped) -> BCDD::Result::Failure
+ def Success: (Symbol, ?untyped) -> Solid::Result::Success
+ def Failure: (Symbol, ?untyped) -> Solid::Result::Failure
- def with: (source: untyped) -> BCDD::Result::Expectations
+ def with: (source: untyped) -> Solid::Result::Expectations
private
- def _ResultAs: (singleton(BCDD::Result), Symbol, untyped) -> untyped
+ def _ResultAs: (singleton(Solid::Result), Symbol, untyped) -> untyped
attr_reader source: untyped
- attr_reader contract: BCDD::Result::Contract::Evaluator
+ attr_reader contract: Solid::Result::Contract::Evaluator
attr_reader terminal: bool
end
-module BCDD::Result::Expectations::Mixin
+module Solid::Result::Expectations::Mixin
module Factory
def self.module!: -> Module
end
@@ -57,11 +57,11 @@ module BCDD::Result::Expectations::Mixin
module Addons
module Continue
- private def Continue: (untyped) -> BCDD::Result::Success
+ private def Continue: (untyped) -> Solid::Result::Success
end
module Given
- private def Given: (untyped) -> BCDD::Result::Success
+ private def Given: (untyped) -> Solid::Result::Success
end
OPTIONS: Hash[Symbol, Module]
diff --git a/sig/bcdd/result/handler.rbs b/sig/solid/result/handler.rbs
similarity index 70%
rename from sig/bcdd/result/handler.rbs
rename to sig/solid/result/handler.rbs
index 222ca2d8..5ed9ff58 100644
--- a/sig/bcdd/result/handler.rbs
+++ b/sig/solid/result/handler.rbs
@@ -1,10 +1,10 @@
-class BCDD::Result
+class Solid::Result
class Handler
UNDEFINED: Object
def initialize: (
- BCDD::Result,
- type_checker: BCDD::Result::Contract::TypeChecker
+ Solid::Result,
+ type_checker: Solid::Result::Contract::TypeChecker
) -> void
def []: (*Symbol) { (untyped, Symbol) -> void } -> untyped
@@ -16,8 +16,8 @@ class BCDD::Result
private
- attr_reader result: BCDD::Result
- attr_reader allowed_types: BCDD::Result::Handler::AllowedTypes
+ attr_reader result: Solid::Result
+ attr_reader allowed_types: Solid::Result::Handler::AllowedTypes
def outcome?: -> bool
def outcome=: (Proc) -> void
@@ -25,13 +25,13 @@ class BCDD::Result
end
end
-class BCDD::Result::Handler
+class Solid::Result::Handler
class AllowedTypes
attr_reader unchecked: Set[Symbol]
- attr_reader type_checker: BCDD::Result::Contract::TypeChecker
+ attr_reader type_checker: Solid::Result::Contract::TypeChecker
def initialize: (
- BCDD::Result::Contract::TypeChecker
+ Solid::Result::Contract::TypeChecker
) -> void
def allow?: (Array[Symbol]) -> bool
diff --git a/sig/bcdd/result/ignored_types.rbs b/sig/solid/result/ignored_types.rbs
similarity index 87%
rename from sig/bcdd/result/ignored_types.rbs
rename to sig/solid/result/ignored_types.rbs
index fb7525c4..25127e2f 100644
--- a/sig/bcdd/result/ignored_types.rbs
+++ b/sig/solid/result/ignored_types.rbs
@@ -1,4 +1,4 @@
-class BCDD::Result
+class Solid::Result
module IgnoredTypes
LIST: ::Set[::Symbol]
GIVEN: ::Symbol
diff --git a/sig/solid/result/mixin.rbs b/sig/solid/result/mixin.rbs
new file mode 100644
index 00000000..6a01e223
--- /dev/null
+++ b/sig/solid/result/mixin.rbs
@@ -0,0 +1,45 @@
+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
diff --git a/sig/bcdd/result/version.rbs b/sig/solid/result/version.rbs
similarity index 77%
rename from sig/bcdd/result/version.rbs
rename to sig/solid/result/version.rbs
index 5b325979..c4ae4d96 100644
--- a/sig/bcdd/result/version.rbs
+++ b/sig/solid/result/version.rbs
@@ -1,4 +1,4 @@
-module BCDD
+module Solid
class Result
VERSION: String
end
diff --git a/sig/bcdd/success.rbs b/sig/solid/success.rbs
similarity index 74%
rename from sig/bcdd/success.rbs
rename to sig/solid/success.rbs
index 83aa25f2..9bca3529 100644
--- a/sig/bcdd/success.rbs
+++ b/sig/solid/success.rbs
@@ -1,4 +1,4 @@
-module BCDD
+module Solid
module Success
def success?: (?Symbol type) -> bool
def failure?: (?Symbol type) -> bool
@@ -8,6 +8,6 @@ module BCDD
private
def kind: -> Symbol
- def type_checker: -> BCDD::Result::Contract::TypeChecker
+ def type_checker: -> Solid::Result::Contract::TypeChecker
end
end
diff --git a/bcdd-result.gemspec b/solid-result.gemspec
similarity index 78%
rename from bcdd-result.gemspec
rename to solid-result.gemspec
index cc5cfd5d..97298f70 100644
--- a/bcdd-result.gemspec
+++ b/solid-result.gemspec
@@ -1,10 +1,10 @@
# frozen_string_literal: true
-require_relative 'lib/bcdd/result/version'
+require_relative 'lib/solid/result/version'
Gem::Specification.new do |spec|
- spec.name = 'bcdd-result'
- spec.version = BCDD::Result::VERSION
+ spec.name = 'solid-result'
+ spec.version = Solid::Result::VERSION
spec.authors = ['Rodrigo Serradura']
spec.email = ['rodrigo.serradura@gmail.com']
@@ -14,15 +14,15 @@ Gem::Specification.new do |spec|
spec.description = summary
end
- spec.homepage = 'https://github.com/b-cdd/result'
+ 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/b-cdd/result'
- spec.metadata['changelog_uri'] = 'https://github.com/b-cdd/result/blob/main/CHANGELOG.md'
+ 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.
diff --git a/test/bcdd/context/and_then/without_source_test.rb b/test/bcdd/context/and_then/without_source_test.rb
deleted file mode 100644
index e0bfa936..00000000
--- a/test/bcdd/context/and_then/without_source_test.rb
+++ /dev/null
@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module BCDD
- class ContextAndThenWithoutSourceTest < Minitest::Test
- test '#and_then does not execute the block if the result is a failure' do
- result =
- Context::Success
- .new(type: :one, value: { number: 1 })
- .and_then { Context::Failure(:two, number: 2) }
- .and_then { Context::Success(:three, number: 3) }
- .and_then { Context::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 =
- Context::Success(:one, number: 1)
- .and_then { Context::Success(:two, number: 2) }
- .and_then { Context::Success(:three, number: 3) }
- .and_then { Context::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
- Context::Success(:one, number: 1)
- .and_then { Context::Success(:two, number: 2) }
- .and_then { raise 'boom' }
- end
- end
-
- test '#and_then raises an exception if the block does not return a result context (regular object)' do
- error = assert_raises(BCDD::Context::Error::UnexpectedOutcome) do
- Context::Success(:one, number: 1)
- .and_then { Context::Success(:two, number: 2) }
- .and_then { 3 }
- end
-
- assert_equal(
- 'Unexpected outcome: 3. The block must return this object wrapped by ' \
- 'BCDD::Context::Success or BCDD::Context::Failure',
- error.message
- )
- end
-
- test '#and_then raises an exception if the block does not return a result context (BCDD::Result)' do
- error = assert_raises(BCDD::Context::Error::UnexpectedOutcome) do
- Context::Success(:one, number: 1)
- .and_then { Context::Success(:two, number: 2) }
- .and_then { BCDD::Result::Success(:three, number: 3) }
- end
-
- assert_equal(
- 'Unexpected outcome: #3}>. ' \
- 'The block must return this object wrapped by BCDD::Context::Success or BCDD::Context::Failure',
- error.message
- )
- end
- end
-end
diff --git a/test/bcdd/context/callable_and_then/arity_test.rb b/test/bcdd/context/callable_and_then/arity_test.rb
deleted file mode 100644
index 286c8997..00000000
--- a/test/bcdd/context/callable_and_then/arity_test.rb
+++ /dev/null
@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module BCDD
- class Context::CallableAndThenArityTest < Minitest::Test
- # rubocop:disable Naming/MethodParameterName
- ProcWithoutKarg = proc { Context::Success(:ok, o: -1) }
- ProcWithOneKarg = proc { |n:| Context::Success(:ok, o: n) }
- ProcWithTwoKargs = proc { |n:, m:| Context::Success(:ok, o: [n, m]) }
- ProcWithArgAndKarg = proc { |foo, bar:| Context::Success(:ok, o: [foo, bar]) }
-
- LambdaWithoutKarg = -> { Context::Success(:ok, o: -1) }
- LambdaWithOneKarg = ->(n:) { Context::Success(:ok, o: n) }
- LambdaWithTwoKargs = ->(n:, m:) { Context::Success(:ok, o: [n, m]) }
- LambdaWithArgAndKarg = ->(foo, bar:) { Context::Success(:ok, o: [foo, bar]) }
-
- module ModWithoutKarg
- def self.call; Context::Success(:ok, o: -1); end
- end
-
- module ModWithOneKarg
- def self.call(n:); Context::Success(:ok, o: n); end
- end
-
- module ModWithTwoKargs
- def self.call(n:, m:); Context::Success(:ok, o: [n, m]); end
- end
-
- module ModWithArgAndKarg
- def self.call(foo, bar:); Context::Success(:ok, o: [foo, bar]); end
- end
- # rubocop:enable Naming/MethodParameterName
-
- def setup
- BCDD::Result.config.feature.enable!(:and_then!)
- end
-
- def teardown
- BCDD::Result.config.feature.disable!(:and_then!)
- end
-
- test 'zero kargs' do
- err1 = assert_raises(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- Context::Success(:ok, o: 0).and_then!(ProcWithoutKarg)
- end
-
- err2 = assert_raises(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- Context::Success(:ok, o: 0).and_then!(LambdaWithoutKarg)
- end
-
- err3 = assert_raises(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- Context::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 = Context::Success(:ok, n: 1).and_then!(ProcWithOneKarg)
- result2 = Context::Success(:ok, n: 2).and_then!(LambdaWithOneKarg)
- result3 = Context::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 = Context::Success(:ok, n: 1).and_then!(ProcWithTwoKargs, m: 2)
- result2 = Context::Success(:ok, n: 2).and_then!(LambdaWithTwoKargs, m: 3)
- result3 = Context::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(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- Context::Success(:ok, o: 0).and_then!(ProcWithArgAndKarg, bar: 1)
- end
-
- err2 = assert_raises(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- Context::Success(:ok, o: 0).and_then!(LambdaWithArgAndKarg, bar: 2)
- end
-
- err3 = assert_raises(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- Context::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
diff --git a/test/bcdd/context/callable_and_then/result_kind_error_test.rb b/test/bcdd/context/callable_and_then/result_kind_error_test.rb
deleted file mode 100644
index c1785d58..00000000
--- a/test/bcdd/context/callable_and_then/result_kind_error_test.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module BCDD
- class Context::CallableAndThenResultKindErrorTest < Minitest::Test
- module NormalizeEmail
- extend Context.mixin
-
- def self.call(input:)
- BCDD::Result.event_logs(name: 'NormalizeEmail') do
- Given(input: input).and_then(:normalize)
- end
- end
-
- def self.normalize(input:)
- input.is_a?(::String) or return ::BCDD::Result::Failure(:invalid_input, message: 'input must be a String')
-
- ::BCDD::Result::Success(:normalized_input, input: input.downcase.strip)
- end
- end
-
- module EmailNormalization
- extend Context.mixin
-
- def self.call(input)
- BCDD::Result.event_logs(name: 'EmailNormalization') do
- Given(input: input)
- .and_then!(NormalizeEmail)
- end
- end
- end
-
- test 'results from different sources' do
- BCDD::Result.config.feature.enable!(:and_then!)
-
- error = assert_raises(BCDD::Result::Error::UnexpectedOutcome) { EmailNormalization.call(nil) }
-
- expected_message = [
- 'Unexpected outcome: #"input must be a String"}>.',
- 'The method must return this object wrapped by BCDD::Context::Success or BCDD::Context::Failure'
- ].join(' ')
-
- assert_equal(expected_message, error.message)
- ensure
- BCDD::Result.config.feature.disable!(:and_then!)
- end
- end
-end
diff --git a/test/bcdd/context/event_logs/enabled/not_been_started_test.rb b/test/bcdd/context/event_logs/enabled/not_been_started_test.rb
deleted file mode 100644
index 8fad9328..00000000
--- a/test/bcdd/context/event_logs/enabled/not_been_started_test.rb
+++ /dev/null
@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module BCDD
- class Context::EventLogsNotBeenStartedTest < Minitest::Test
- include BCDDResultEventLogAssertions
-
- test 'event_logs is empty by default' do
- success = Context::Success(:ok, one: 1)
- failure = Context::Failure(:err, zero: 0)
-
- assert_event_logs(success, size: 0)
- assert_event_logs(failure, size: 0)
- end
- end
-end
diff --git a/test/bcdd/context/failure_test.rb b/test/bcdd/context/failure_test.rb
deleted file mode 100644
index d2f16047..00000000
--- a/test/bcdd/context/failure_test.rb
+++ /dev/null
@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module BCDD
- class ContextFailureTest < Minitest::Test
- test 'is a BCDD::Context' do
- assert Context::Failure < BCDD::Context
- end
-
- test 'is a BCDD::Failure' do
- assert Context::Failure < BCDD::Failure
- end
-
- test '#inspect' do
- result = Context::Failure(:err, number: 0)
-
- assert_equal(
- '#0}>',
- result.inspect
- )
- end
- end
-end
diff --git a/test/bcdd/result/callable_and_then/arity_test.rb b/test/bcdd/result/callable_and_then/arity_test.rb
deleted file mode 100644
index c8bcfdc6..00000000
--- a/test/bcdd/result/callable_and_then/arity_test.rb
+++ /dev/null
@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class BCDD::Result
- class CallableAndThenArityTest < Minitest::Test
- ProcWithoutArg = proc { BCDD::Result::Success(:ok, -1) }
- ProcWithOneArg = proc { |arg| BCDD::Result::Success(:ok, arg) }
- ProcWithTwoArgs = proc { |arg1, arg2| BCDD::Result::Success(:ok, [arg1, arg2]) }
- ProcWithThreeArgs = proc { |arg1, arg2, arg3| BCDD::Result::Success(:ok, [arg1, arg2, arg3]) }
-
- LambdaWithoutArg = -> { BCDD::Result::Success(:ok, -1) }
- LambdaWithOneArg = ->(arg) { BCDD::Result::Success(:ok, arg) }
- LambdaWithTwoArgs = ->(arg1, arg2) { BCDD::Result::Success(:ok, [arg1, arg2]) }
- LambdaWithThreeArgs = ->(arg1, arg2, arg3) { BCDD::Result::Success(:ok, [arg1, arg2, arg3]) }
-
- module ModWithoutArg
- def self.call; BCDD::Result::Success(:ok, -1); end
- end
-
- module ModWithOneArg
- def self.call(arg); BCDD::Result::Success(:ok, arg); end
- end
-
- module ModWithTwoArgs
- def self.call(arg1, arg2); BCDD::Result::Success(:ok, [arg1, arg2]); end
- end
-
- module ModWithThreeArgs
- def self.call(arg1, arg2, arg3); BCDD::Result::Success(:ok, [arg1, arg2, arg3]); end
- end
-
- def setup
- BCDD::Result.config.feature.enable!(:and_then!)
- end
-
- def teardown
- BCDD::Result.config.feature.disable!(:and_then!)
- end
-
- test 'arity zero' do
- err1 = assert_raises(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- BCDD::Result::Success(:ok, 0).and_then!(ProcWithoutArg)
- end
-
- err2 = assert_raises(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- BCDD::Result::Success(:ok, 0).and_then!(LambdaWithoutArg)
- end
-
- err3 = assert_raises(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- BCDD::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 = BCDD::Result::Success(:ok, 1).and_then!(ProcWithOneArg)
- result2 = BCDD::Result::Success(:ok, 2).and_then!(LambdaWithOneArg)
- result3 = BCDD::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 = BCDD::Result::Success(:ok, 1).and_then!(ProcWithTwoArgs, 2)
- result2 = BCDD::Result::Success(:ok, 2).and_then!(LambdaWithTwoArgs, 3)
- result3 = BCDD::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(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- BCDD::Result::Success(:ok, 0).and_then!(ProcWithThreeArgs, 1)
- end
-
- err2 = assert_raises(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- BCDD::Result::Success(:ok, 0).and_then!(LambdaWithThreeArgs, 1)
- end
-
- err3 = assert_raises(BCDD::Result::CallableAndThen::Error::InvalidArity) do
- BCDD::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
diff --git a/test/bcdd/result/config/feature/expectations_test.rb b/test/bcdd/result/config/feature/expectations_test.rb
deleted file mode 100644
index 31c43687..00000000
--- a/test/bcdd/result/config/feature/expectations_test.rb
+++ /dev/null
@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class BCDD::Result::Config
- class FeatureExpectationsTest < Minitest::Test
- test 'the side effects' do
- class1a = Class.new do
- include BCDD::Result::Expectations.mixin(success: { ok: ::Numeric })
-
- def call; Success(:ok, '1'); end
- end
-
- class1b = Class.new
- class1b.const_set(:Result, BCDD::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 BCDD::Context::Expectations.mixin(success: { ok: ->(v) { v[:one] == 1 } })
-
- def call; Success(:yes, one: 1); end
- end
-
- class1d = Class.new
- class1d.const_set(:Result, BCDD::Context::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(BCDD::Result::Contract::Error::UnexpectedValue) { class1a.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class1b.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { class1a::Result::Success(:yes, 1) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { class1b::Result::Success(:yes, 1) }
-
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class1c::Result::Success(:ok, one: 2) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class1d::Result::Success(:ok, one: 2) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { class1c.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { class1d.new.call }
-
- BCDD::Result.config.feature.disable!(:expectations)
-
- class2a = Class.new do
- include BCDD::Result::Expectations.mixin(success: { ok: ::Numeric })
-
- def call; Success(:ok, '1'); end
- end
-
- class2b = Class.new
- class2b.const_set(:Result, BCDD::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 BCDD::Context::Expectations.mixin(success: { ok: ->(v) { v[:one] == 1 } })
-
- def call; Success(:yes, one: 1); end
- end
-
- class2d = Class.new
- class2d.const_set(:Result, BCDD::Context::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
- BCDD::Result.config.feature.enable!(:expectations)
-
- class3a = Class.new do
- include BCDD::Result::Expectations.mixin(success: { ok: ::Numeric })
-
- def call; Success(:ok, '1'); end
- end
-
- class3b = Class.new
- class3b.const_set(:Result, BCDD::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 BCDD::Context::Expectations.mixin(success: { ok: ->(v) { v[:one] == 1 } })
-
- def call; Success(:yes, one: 1); end
- end
-
- class3d = Class.new
- class3d.const_set(:Result, BCDD::Context::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(BCDD::Result::Contract::Error::UnexpectedValue) { class3a.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class3b.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { class3a::Result::Success(:yes, 1) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { class3b::Result::Success(:yes, 1) }
-
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class3c::Result::Success(:ok, one: 2) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class3d::Result::Success(:ok, one: 2) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { class3c.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { class3d.new.call }
- end
- end
-end
diff --git a/test/bcdd/result/event_logs/enabled/not_been_started_test.rb b/test/bcdd/result/event_logs/enabled/not_been_started_test.rb
deleted file mode 100644
index 922892fb..00000000
--- a/test/bcdd/result/event_logs/enabled/not_been_started_test.rb
+++ /dev/null
@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class BCDD::Result::EventLogsNotBeenStartedTest < Minitest::Test
- include BCDDResultEventLogAssertions
-
- test 'event_logs is empty by default' do
- success = BCDD::Result::Success(:ok, 1)
- failure = BCDD::Result::Failure(:err, 0)
-
- assert_event_logs(success, size: 0)
- assert_event_logs(failure, size: 0)
- end
-end
diff --git a/test/bcdd/result/pattern_matching/deconstruct_keys_test.rb b/test/bcdd/result/pattern_matching/deconstruct_keys_test.rb
deleted file mode 100644
index 9572ee7f..00000000
--- a/test/bcdd/result/pattern_matching/deconstruct_keys_test.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class BCDD::Result::PatternMatchingDeconstructKeysTest < Minitest::Test
- Divide = ->(arg1, arg2) do
- arg1.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg1 must be numeric')
- arg2.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg2 must be numeric')
-
- return BCDD::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
-
- BCDD::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 BCDD::Failure(type: _, value: _)
- raise
- in BCDD::Success(type: :division_completed, value: value)
- assert_equal 5, value
- end
-
- case result
- in BCDD::Result::Failure(type: _, value: _)
- raise
- in BCDD::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 BCDD::Success(type: _, value: _)
- raise
- in BCDD::Failure(type: :division_by_zero, value: msg)
- assert_equal 'arg2 must not be zero', msg
- end
-
- case result
- in BCDD::Result::Success(type: _, value: _)
- raise
- in BCDD::Result::Failure(type: :division_by_zero, value: msg)
- assert_equal 'arg2 must not be zero', msg
- end
- end
-end
diff --git a/test/bcdd/result/pattern_matching/deconstruct_test.rb b/test/bcdd/result/pattern_matching/deconstruct_test.rb
deleted file mode 100644
index aca4f9ff..00000000
--- a/test/bcdd/result/pattern_matching/deconstruct_test.rb
+++ /dev/null
@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class BCDD::Result::PatternMatchingDeconstructTest < Minitest::Test
- Divide = ->(arg1, arg2) do
- arg1.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg1 must be numeric')
- arg2.is_a?(::Numeric) or return BCDD::Result::Failure(:invalid_arg, 'arg2 must be numeric')
-
- return BCDD::Result::Failure(:division_by_zero, 'arg2 must not be zero') if arg2.zero?
-
- BCDD::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 BCDD::Failure[_, _]
- raise
- in BCDD::Success[:division_completed, value]
- assert_equal 5, value
- end
-
- case result
- in BCDD::Result::Failure[_, _]
- raise
- in BCDD::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 BCDD::Success[_, _]
- raise
- in BCDD::Failure[:division_by_zero, msg]
- assert_equal 'arg2 must not be zero', msg
- end
-
- case result
- in BCDD::Result::Success[_, _]
- raise
- in BCDD::Result::Failure[:division_by_zero, msg]
- assert_equal 'arg2 must not be zero', msg
- end
- end
-end
diff --git a/test/bcdd/context/addons/continue/expectations_test.rb b/test/solid/output/addons/continue/expectations_test.rb
similarity index 86%
rename from test/bcdd/context/addons/continue/expectations_test.rb
rename to test/solid/output/addons/continue/expectations_test.rb
index a668ed4d..7634d6e1 100644
--- a/test/bcdd/context/addons/continue/expectations_test.rb
+++ b/test/solid/output/addons/continue/expectations_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::AddonsContinueExpectationsTest < Minitest::Test
+class Solid::Output::AddonsContinueExpectationsTest < Minitest::Test
class DivideType
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :ok,
failure: :err
@@ -35,7 +35,7 @@ def divide(number1:, number2:)
end
class DivideTypes
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :division_completed,
failure: %i[invalid_arg division_by_zero]
@@ -66,7 +66,7 @@ def divide(number1:, number2:)
end
module DivideTypeAndValue
- extend self, BCDD::Context::Expectations.mixin(
+ extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: {
division_completed: ->(value) {
@@ -134,17 +134,17 @@ def divide(number1:, number2:)
failure2 = DivideTypes.new.call('10', 0)
failure3 = DivideTypeAndValue.call('10', 0)
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { success1.success?(:division_completed) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { success2.success?(:ok) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { success3.success?(:ok) }
+ 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(BCDD::Result::Contract::Error::UnexpectedType) { failure1.failure?(:invalid_arg) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { failure2.failure?(:err) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { failure3.failure?(:err) }
+ 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 BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
@@ -157,7 +157,7 @@ def call
end
class InstanceSecondSuccessToTerminateTheStepChainAndThenBlock
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
@@ -170,7 +170,7 @@ def call
end
class InstanceThirdSuccessToTerminateTheStepChainAndThenBlock
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
@@ -183,7 +183,7 @@ def call
end
module SingletonFirstSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Context::Expectations.mixin(
+ extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
@@ -196,7 +196,7 @@ def call
end
module SingletonSecondSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Context::Expectations.mixin(
+ extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
@@ -209,7 +209,7 @@ def call
end
module SingletonThirdSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Context::Expectations.mixin(
+ extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
@@ -240,7 +240,7 @@ def call
end
class InstanceFirstSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
@@ -259,7 +259,7 @@ def third_success; Continue(third: true); end
end
class InstanceSecondSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
@@ -278,7 +278,7 @@ def third_success; Continue(third: true); end
end
class InstanceThirdSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
@@ -297,7 +297,7 @@ def third_success; Success(:third); end
end
module SingletonFirstSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Context::Expectations.mixin(
+ extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
@@ -316,7 +316,7 @@ def third_success; Continue(third: true); end
end
module SingletonSecondSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Context::Expectations.mixin(
+ extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
@@ -335,7 +335,7 @@ def third_success; Continue(third: true); end
end
module SingletonThirdSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Context::Expectations.mixin(
+ extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
diff --git a/test/bcdd/context/addons/continue/instance_test.rb b/test/solid/output/addons/continue/instance_test.rb
similarity index 89%
rename from test/bcdd/context/addons/continue/instance_test.rb
rename to test/solid/output/addons/continue/instance_test.rb
index bc3068a5..bc84f677 100644
--- a/test/bcdd/context/addons/continue/instance_test.rb
+++ b/test/solid/output/addons/continue/instance_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::AddonsContinueInstanceTest < Minitest::Test
+class Solid::Output::AddonsContinueInstanceTest < Minitest::Test
class Divide
- include BCDD::Context.mixin(config: { addon: { continue: true } })
+ include Solid::Output.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
validate_numbers(arg1, arg2)
@@ -57,7 +57,7 @@ def divide(number1:, number2:)
end
class FirstSuccessToTerminateTheStepChainAndThenBlock
- include BCDD::Context.mixin(config: { addon: { continue: true } })
+ include Solid::Output.mixin(config: { addon: { continue: true } })
def call
Success(:first)
@@ -67,7 +67,7 @@ def call
end
class SecondSuccessToTerminateTheStepChainAndThenBlock
- include BCDD::Context.mixin(config: { addon: { continue: true } })
+ include Solid::Output.mixin(config: { addon: { continue: true } })
def call
Continue(first: true)
@@ -77,7 +77,7 @@ def call
end
class ThirdSuccessToTerminateTheStepChainAndThenBlock
- include BCDD::Context.mixin(config: { addon: { continue: true } })
+ include Solid::Output.mixin(config: { addon: { continue: true } })
def call
Continue(first: true)
@@ -97,7 +97,7 @@ def call
end
class FirstSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Context.mixin(config: { addon: { continue: true } })
+ include Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
@@ -113,7 +113,7 @@ def third_success; Continue(third: true); end
end
class SecondSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Context.mixin(config: { addon: { continue: true } })
+ include Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
@@ -129,7 +129,7 @@ def third_success; Continue(third: true); end
end
class ThirdSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Context.mixin(config: { addon: { continue: true } })
+ include Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
diff --git a/test/bcdd/context/addons/continue/singleton_test.rb b/test/solid/output/addons/continue/singleton_test.rb
similarity index 89%
rename from test/bcdd/context/addons/continue/singleton_test.rb
rename to test/solid/output/addons/continue/singleton_test.rb
index 691fca7b..6db06fb5 100644
--- a/test/bcdd/context/addons/continue/singleton_test.rb
+++ b/test/solid/output/addons/continue/singleton_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::AddonsContinueSingletonTest < Minitest::Test
+class Solid::Output::AddonsContinueSingletonTest < Minitest::Test
module Divide
- extend self, BCDD::Context.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
validate_numbers(arg1, arg2)
@@ -57,7 +57,7 @@ def divide(number1:, number2:, extra_division:)
end
module FirstSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Context.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
Success(:first)
@@ -67,7 +67,7 @@ def call
end
module SecondSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Context.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
Continue(first: true)
@@ -77,7 +77,7 @@ def call
end
module ThirdSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Context.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
Continue(first: true)
@@ -97,7 +97,7 @@ def call
end
module FirstSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Context.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
@@ -113,7 +113,7 @@ def third_success; Continue(third: true); end
end
module SecondSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Context.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
@@ -129,7 +129,7 @@ def third_success; Continue(third: true); end
end
module ThirdSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Context.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call
first_success
diff --git a/test/bcdd/context/addons/given/expectations_test.rb b/test/solid/output/addons/given/expectations_test.rb
similarity index 93%
rename from test/bcdd/context/addons/given/expectations_test.rb
rename to test/solid/output/addons/given/expectations_test.rb
index 00e07db3..85611984 100644
--- a/test/bcdd/context/addons/given/expectations_test.rb
+++ b/test/solid/output/addons/given/expectations_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::AddonsGivenExpectationsTest < Minitest::Test
+class Solid::Output::AddonsGivenExpectationsTest < Minitest::Test
class DivideType
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :ok,
failure: :err
@@ -36,7 +36,7 @@ def divide(number1:, number2:)
end
class DivideTypes
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: :division_completed,
failure: %i[invalid_arg division_by_zero]
@@ -68,7 +68,7 @@ def divide(number1:, number2:)
end
module DivideTypeAndValue
- extend self, BCDD::Context::Expectations.mixin(
+ extend self, Solid::Output::Expectations.mixin(
config: { addon: { continue: true } },
success: {
division_completed: ->(value) {
diff --git a/test/bcdd/context/addons/given/instance_test.rb b/test/solid/output/addons/given/instance_test.rb
similarity index 92%
rename from test/bcdd/context/addons/given/instance_test.rb
rename to test/solid/output/addons/given/instance_test.rb
index 08afda19..c05ea1f0 100644
--- a/test/bcdd/context/addons/given/instance_test.rb
+++ b/test/solid/output/addons/given/instance_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::AddonsGivenInstanceTest < Minitest::Test
+class Solid::Output::AddonsGivenInstanceTest < Minitest::Test
class Divide
- include BCDD::Context.mixin(config: { addon: { continue: true } })
+ include Solid::Output.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Given(number1: arg1, number2: arg2)
diff --git a/test/bcdd/context/addons/given/singleton_test.rb b/test/solid/output/addons/given/singleton_test.rb
similarity index 92%
rename from test/bcdd/context/addons/given/singleton_test.rb
rename to test/solid/output/addons/given/singleton_test.rb
index 224fdc7a..2b6d0743 100644
--- a/test/bcdd/context/addons/given/singleton_test.rb
+++ b/test/solid/output/addons/given/singleton_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::AddonsGivenSingletonTest < Minitest::Test
+class Solid::Output::AddonsGivenSingletonTest < Minitest::Test
module Divide
- extend self, BCDD::Context.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Output.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Given(number1: arg1, number2: arg2)
diff --git a/test/bcdd/context/and_expose/all_values_test.rb b/test/solid/output/and_expose/all_values_test.rb
similarity index 91%
rename from test/bcdd/context/and_expose/all_values_test.rb
rename to test/solid/output/and_expose/all_values_test.rb
index 28314327..834e2b6c 100644
--- a/test/bcdd/context/and_expose/all_values_test.rb
+++ b/test/solid/output/and_expose/all_values_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-module BCDD
- class ContextAndExposeAllValuesTest < Minitest::Test
+module Solid
+ class OutputAndExposeAllValuesTest < Minitest::Test
class Divide
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
diff --git a/test/bcdd/context/and_expose/argument_error_test.rb b/test/solid/output/and_expose/argument_error_test.rb
similarity index 87%
rename from test/bcdd/context/and_expose/argument_error_test.rb
rename to test/solid/output/and_expose/argument_error_test.rb
index d3a00f23..aba21895 100644
--- a/test/bcdd/context/and_expose/argument_error_test.rb
+++ b/test/solid/output/and_expose/argument_error_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-module BCDD
- class ContextAndExposeArgumentErrorTest < Minitest::Test
+module Solid
+ class OutputAndExposeArgumentErrorTest < Minitest::Test
class NotAnArray
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call
Success(:ok, number: 1)
@@ -14,7 +14,7 @@ def call
end
class EmptyArray
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call
Success(:ok, number: 1)
@@ -23,7 +23,7 @@ def call
end
class AnyKeyAreNotSymbol
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call
Success(:ok, number: 1)
diff --git a/test/bcdd/context/and_expose/expectations_test.rb b/test/solid/output/and_expose/expectations_test.rb
similarity index 86%
rename from test/bcdd/context/and_expose/expectations_test.rb
rename to test/solid/output/and_expose/expectations_test.rb
index 4cbb07b1..2b80a8d7 100644
--- a/test/bcdd/context/and_expose/expectations_test.rb
+++ b/test/solid/output/and_expose/expectations_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-module BCDD
- class ContextExpectationsTest < Minitest::Test
+module Solid
+ class OutputExpectationsTest < Minitest::Test
class Divide1
- include BCDD::Context::Expectations.mixin(
+ 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) } }
@@ -32,7 +32,7 @@ def divide(number1:, number2:)
end
class Divide2
- include BCDD::Context::Expectations.mixin(
+ 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) } }
@@ -59,13 +59,13 @@ def divide(number1:, number2:)
end
test '#and_expose validates the exposed value' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide2.new.call(12, 2)
end
diff --git a/test/bcdd/context/and_expose/failure_test.rb b/test/solid/output/and_expose/failure_test.rb
similarity index 91%
rename from test/bcdd/context/and_expose/failure_test.rb
rename to test/solid/output/and_expose/failure_test.rb
index a6006ceb..50573eb3 100644
--- a/test/bcdd/context/and_expose/failure_test.rb
+++ b/test/solid/output/and_expose/failure_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-module BCDD
- class ContextAndExposeFailureTest < Minitest::Test
+module Solid
+ class OutputAndExposeFailureTest < Minitest::Test
class Divide
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
diff --git a/test/bcdd/context/and_expose/intermediate_values_test.rb b/test/solid/output/and_expose/intermediate_values_test.rb
similarity index 89%
rename from test/bcdd/context/and_expose/intermediate_values_test.rb
rename to test/solid/output/and_expose/intermediate_values_test.rb
index e6c6d868..8931a0e6 100644
--- a/test/bcdd/context/and_expose/intermediate_values_test.rb
+++ b/test/solid/output/and_expose/intermediate_values_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-module BCDD
- class ContextAndExposeIntermediateValuesTest < Minitest::Test
+module Solid
+ class OutputAndExposeIntermediateValuesTest < Minitest::Test
class Divide
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
diff --git a/test/bcdd/context/and_expose/invalid_keys_test.rb b/test/solid/output/and_expose/invalid_keys_test.rb
similarity index 86%
rename from test/bcdd/context/and_expose/invalid_keys_test.rb
rename to test/solid/output/and_expose/invalid_keys_test.rb
index 21f2231c..fbcdb90d 100644
--- a/test/bcdd/context/and_expose/invalid_keys_test.rb
+++ b/test/solid/output/and_expose/invalid_keys_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-module BCDD
- class ContextAndExposeInvalidKeysTest < Minitest::Test
+module Solid
+ class OutputAndExposeInvalidKeysTest < Minitest::Test
class Divide
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
@@ -28,7 +28,7 @@ def divide(number1:, number2:, extra_division:)
end
test '#and_expose receive an invalid key' do
- err = assert_raises(BCDD::Context::Error::InvalidExposure) { Divide.new.call(12, 2) }
+ 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')
diff --git a/test/bcdd/context/and_expose/one_value_test.rb b/test/solid/output/and_expose/one_value_test.rb
similarity index 90%
rename from test/bcdd/context/and_expose/one_value_test.rb
rename to test/solid/output/and_expose/one_value_test.rb
index 00f62f1a..32573473 100644
--- a/test/bcdd/context/and_expose/one_value_test.rb
+++ b/test/solid/output/and_expose/one_value_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-module BCDD
- class ContextAndExposeOneValueTest < Minitest::Test
+module Solid
+ class OutputAndExposeOneValueTest < Minitest::Test
class Divide
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(arg1, arg2)
validate_numbers(arg1, arg2)
diff --git a/test/bcdd/context/and_expose/termination_test.rb b/test/solid/output/and_expose/termination_test.rb
similarity index 91%
rename from test/bcdd/context/and_expose/termination_test.rb
rename to test/solid/output/and_expose/termination_test.rb
index 64078d1a..2eec8f51 100644
--- a/test/bcdd/context/and_expose/termination_test.rb
+++ b/test/solid/output/and_expose/termination_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-module BCDD
- class ContextTerminationTest < Minitest::Test
+module Solid
+ class OutputTerminationTest < Minitest::Test
module TerminationEnabledAndThenBlock
- extend self, Context.mixin
+ extend self, Output.mixin
def call
Success(:a, a: 1)
@@ -16,7 +16,7 @@ def call
end
module TerminationEnabledAndThenMethod
- extend self, Context.mixin
+ extend self, Output.mixin
def call
call_a
@@ -33,7 +33,7 @@ def call_c; Success(:c, c: 3); end
end
module TerminationDisabledAndThenBlock
- extend self, Context.mixin
+ extend self, Output.mixin
def call
Success(:a, a: 1)
@@ -44,7 +44,7 @@ def call
end
module TerminationDisabledAndThenMethod
- extend self, Context.mixin
+ extend self, Output.mixin
def call
call_a
diff --git a/test/bcdd/context/and_then/argument_error_test.rb b/test/solid/output/and_then/argument_error_test.rb
similarity index 83%
rename from test/bcdd/context/and_then/argument_error_test.rb
rename to test/solid/output/and_then/argument_error_test.rb
index 29173a9e..b86c22f0 100644
--- a/test/bcdd/context/and_then/argument_error_test.rb
+++ b/test/solid/output/and_then/argument_error_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-module BCDD
- class ContextAndThenArgumentErrorTest < Minitest::Test
+module Solid
+ class OutputAndThenArgumentErrorTest < Minitest::Test
module SomeModule
- extend BCDD::Context.mixin
+ extend Solid::Output.mixin
def self.call(arg1, arg2)
Success(:ok, number: arg1 + arg2)
diff --git a/test/bcdd/context/and_then/with_source_test.rb b/test/solid/output/and_then/with_source_test.rb
similarity index 82%
rename from test/bcdd/context/and_then/with_source_test.rb
rename to test/solid/output/and_then/with_source_test.rb
index bc2ad1a1..b186d5db 100644
--- a/test/bcdd/context/and_then/with_source_test.rb
+++ b/test/solid/output/and_then/with_source_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-module BCDD
- class ContextAndThenWithSourceTest < Minitest::Test
+module Solid
+ class OutputAndThenWithSourceTest < Minitest::Test
class Base
- include BCDD::Context.mixin
+ include Solid::Output.mixin
attr_reader :arg1, :arg2
@@ -61,7 +61,7 @@ def add(args)
end
end
- class SourceMethodArityWithContextData < Base
+ class SourceMethodArityWithOutputData < Base
def call
validate_numbers
.and_then { Success(:ok, number1: arg1, number2: arg2) }
@@ -140,7 +140,7 @@ def add
end
test '#and_then calling a source method with context data' do
- result = SourceMethodArityWithContextData.new(1, 2).call
+ result = SourceMethodArityWithOutputData.new(1, 2).call
assert_predicate(result, :success?)
assert_equal(:ok, result.type)
@@ -150,7 +150,7 @@ def add
test '#and_then calling a source method (arity 1 - positional arg)' do
invalid_source_method = SourceMethodArityWithArityOneArg.new(1, 2)
- error = assert_raises(BCDD::Result::Error::InvalidSourceMethodArity) { invalid_source_method.call }
+ 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
@@ -158,7 +158,7 @@ def add
test '#and_then calling a source method with wrong arity (> 1)' do
wrong_source_method_arity = InvalidSourceMethodArity.new(1, 2)
- error = assert_raises(BCDD::Result::Error::InvalidSourceMethodArity) { wrong_source_method_arity.call }
+ 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
@@ -166,13 +166,13 @@ def add
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(BCDD::Result::Error::InvalidResultSource) { wrong_result_source.call }
+ 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}>'
+ 'Given result: #3}>'
assert_equal(expected_message, error.message)
end
@@ -180,33 +180,33 @@ def add
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(BCDD::Result::Error::InvalidResultSource) { wrong_result_source.call }
+ 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}>'
+ '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(BCDD::Result::Error::UnexpectedOutcome) { UnexpectedBlockOutcome.new(1, 2).call }
+ 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 ' \
- 'BCDD::Context::Success or BCDD::Context::Failure'
+ '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(BCDD::Result::Error::UnexpectedOutcome) { UnexpectedMethodOutcome.new(1, 2).call }
+ 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 ' \
- 'BCDD::Context::Success or BCDD::Context::Failure'
+ 'Solid::Output::Success or Solid::Output::Failure'
assert_equal(expected_message, error.message)
end
diff --git a/test/solid/output/and_then/without_source_test.rb b/test/solid/output/and_then/without_source_test.rb
new file mode 100644
index 00000000..333a9dc9
--- /dev/null
+++ b/test/solid/output/and_then/without_source_test.rb
@@ -0,0 +1,68 @@
+# 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
diff --git a/test/bcdd/context/callable_and_then/accumulation_test.rb b/test/solid/output/callable_and_then/accumulation_test.rb
similarity index 88%
rename from test/bcdd/context/callable_and_then/accumulation_test.rb
rename to test/solid/output/callable_and_then/accumulation_test.rb
index 4c60bb0a..406c3897 100644
--- a/test/bcdd/context/callable_and_then/accumulation_test.rb
+++ b/test/solid/output/callable_and_then/accumulation_test.rb
@@ -2,28 +2,28 @@
require 'test_helper'
-module BCDD
- class Context::CallableAndThenResultFromDifferentSourcesTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::CallableAndThenResultFromDifferentSourcesTest < Minitest::Test
+ include SolidResultEventLogAssertions
# rubocop:disable Naming/MethodParameterName
class Root
- include Context.mixin
+ include Output.mixin
CallC = ->(b:, **) do
- BCDD::Result.event_logs(name: 'CallC') do
- Context::Success(:c, c: b + 1)
+ Solid::Result.event_logs(name: 'CallC') do
+ Output::Success(:c, c: b + 1)
end
end
CallE = ->(d:, **) do
- BCDD::Result.event_logs(name: 'CallE') do
- Context::Success(:e, e: d + 1)
+ Solid::Result.event_logs(name: 'CallE') do
+ Output::Success(:e, e: d + 1)
end
end
def call(a:)
- BCDD::Result.event_logs(name: 'Root') do
+ Solid::Result.event_logs(name: 'Root') do
Given(a: a)
.and_then(:call_b, b: 2)
.and_then!(CallC)
diff --git a/test/solid/output/callable_and_then/arity_test.rb b/test/solid/output/callable_and_then/arity_test.rb
new file mode 100644
index 00000000..f167b94d
--- /dev/null
+++ b/test/solid/output/callable_and_then/arity_test.rb
@@ -0,0 +1,99 @@
+# 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
diff --git a/test/solid/output/callable_and_then/result_kind_error_test.rb b/test/solid/output/callable_and_then/result_kind_error_test.rb
new file mode 100644
index 00000000..7cdf1697
--- /dev/null
+++ b/test/solid/output/callable_and_then/result_kind_error_test.rb
@@ -0,0 +1,49 @@
+# 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
diff --git a/test/bcdd/context/callable_and_then/results_from_different_sources_test.rb b/test/solid/output/callable_and_then/results_from_different_sources_test.rb
similarity index 90%
rename from test/bcdd/context/callable_and_then/results_from_different_sources_test.rb
rename to test/solid/output/callable_and_then/results_from_different_sources_test.rb
index c83d4992..1510a6d5 100644
--- a/test/bcdd/context/callable_and_then/results_from_different_sources_test.rb
+++ b/test/solid/output/callable_and_then/results_from_different_sources_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-module BCDD
- class Context::CallableAndThenResultFromDifferentSourcesTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::CallableAndThenResultFromDifferentSourcesTest < Minitest::Test
+ include SolidResultEventLogAssertions
module NormalizeEmail
- extend Context.mixin
+ extend Output.mixin
def self.call(input:)
- BCDD::Result.event_logs(name: 'NormalizeEmail') do
+ Solid::Result.event_logs(name: 'NormalizeEmail') do
Given(input: input).and_then(:normalize)
end
end
@@ -23,14 +23,14 @@ def self.normalize(input:)
end
class EmailValidation
- include Context.mixin
+ include Output.mixin
def initialize(expected_pattern: /\A[^@\s]+@[^@\s]+\z/)
@expected_pattern = expected_pattern
end
def call(input:)
- BCDD::Result.event_logs(name: 'EmailValidation') do
+ Solid::Result.event_logs(name: 'EmailValidation') do
Given(input: input).and_then(:validate)
end
end
@@ -41,10 +41,10 @@ def validate(input:)
end
module NormalizeAndValidateEmail
- extend Context.mixin
+ extend Output.mixin
def self.call(input)
- BCDD::Result.event_logs(name: 'NormalizeAndValidateEmail') do
+ Solid::Result.event_logs(name: 'NormalizeAndValidateEmail') do
Given(input: input)
.and_then!(NormalizeEmail)
.and_then!(EmailValidation.new)
@@ -53,11 +53,11 @@ def self.call(input)
end
def setup
- BCDD::Result.config.feature.enable!(:and_then!)
+ Solid::Result.config.feature.enable!(:and_then!)
end
def teardown
- BCDD::Result.config.feature.disable!(:and_then!)
+ Solid::Result.config.feature.disable!(:and_then!)
end
test 'results from different sources' do
diff --git a/test/bcdd/context/callable_and_then/unexpected_outcome_test.rb b/test/solid/output/callable_and_then/unexpected_outcome_test.rb
similarity index 52%
rename from test/bcdd/context/callable_and_then/unexpected_outcome_test.rb
rename to test/solid/output/callable_and_then/unexpected_outcome_test.rb
index cdaaf398..b32862ec 100644
--- a/test/bcdd/context/callable_and_then/unexpected_outcome_test.rb
+++ b/test/solid/output/callable_and_then/unexpected_outcome_test.rb
@@ -2,8 +2,8 @@
require 'test_helper'
-module BCDD
- class Context::CallableAndThenUnexpectedOutcomeTest < Minitest::Test
+module Solid
+ class Output::CallableAndThenUnexpectedOutcomeTest < Minitest::Test
ProcWithArg = proc { |arg:| arg }
module ModWithArg
@@ -11,23 +11,23 @@ def self.call(arg:); arg; end
end
def setup
- BCDD::Result.config.feature.enable!(:and_then!)
+ Solid::Result.config.feature.enable!(:and_then!)
end
def teardown
- BCDD::Result.config.feature.disable!(:and_then!)
+ Solid::Result.config.feature.disable!(:and_then!)
end
test 'unexpected outcome' do
- err1 = assert_raises(BCDD::Result::CallableAndThen::Error::UnexpectedOutcome) do
- Context::Success(:ok, arg: 0).and_then!(ProcWithArg)
+ err1 = assert_raises(Solid::Result::CallableAndThen::Error::UnexpectedOutcome) do
+ Output::Success(:ok, arg: 0).and_then!(ProcWithArg)
end
- err2 = assert_raises(BCDD::Result::CallableAndThen::Error::UnexpectedOutcome) do
- Context::Success(:ok, arg: 0).and_then!(ModWithArg)
+ err2 = assert_raises(Solid::Result::CallableAndThen::Error::UnexpectedOutcome) do
+ Output::Success(:ok, arg: 0).and_then!(ModWithArg)
end
- expected_kinds = 'BCDD::Context::Success or BCDD::Context::Failure'
+ expected_kinds = 'Solid::Output::Success or Solid::Output::Failure'
assert_match(
/Unexpected outcome: 0. The # must return this object wrapped by #{expected_kinds}/,
diff --git a/test/bcdd/context/event_logs/disabled/with_source/flat_test.rb b/test/solid/output/event_logs/disabled/with_source/flat_test.rb
similarity index 84%
rename from test/bcdd/context/event_logs/disabled/with_source/flat_test.rb
rename to test/solid/output/event_logs/disabled/with_source/flat_test.rb
index 83c79097..4d952d45 100644
--- a/test/bcdd/context/event_logs/disabled/with_source/flat_test.rb
+++ b/test/solid/output/event_logs/disabled/with_source/flat_test.rb
@@ -2,23 +2,23 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsDisabledWithSourceInstanceFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsDisabledWithSourceInstanceFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
class Division
- include Context.mixin
+ include Output.mixin
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
@@ -76,7 +76,7 @@ def divide(num1:, num2:)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
@@ -88,7 +88,7 @@ def divide(num1:, num2:)
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.new.call(4, 2)
diff --git a/test/bcdd/context/event_logs/disabled/with_source/nested_test.rb b/test/solid/output/event_logs/disabled/with_source/nested_test.rb
similarity index 85%
rename from test/bcdd/context/event_logs/disabled/with_source/nested_test.rb
rename to test/solid/output/event_logs/disabled/with_source/nested_test.rb
index 456af7e3..a26e3f8e 100644
--- a/test/bcdd/context/event_logs/disabled/with_source/nested_test.rb
+++ b/test/solid/output/event_logs/disabled/with_source/nested_test.rb
@@ -2,23 +2,23 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsDisabledWithSourceInstanceNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsDisabledWithSourceInstanceNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
module Division
- extend self, Context.mixin
+ extend self, Output.mixin
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
@@ -46,10 +46,10 @@ def divide(num1:, num2:)
end
class SumDivisionsByTwo
- include Context.mixin
+ include Output.mixin
def call(*numbers)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
@@ -98,7 +98,7 @@ def divide_by_two(num)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
@@ -110,7 +110,7 @@ def divide_by_two(num)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
diff --git a/test/bcdd/context/event_logs/disabled/with_source/recursion_test.rb b/test/solid/output/event_logs/disabled/with_source/recursion_test.rb
similarity index 79%
rename from test/bcdd/context/event_logs/disabled/with_source/recursion_test.rb
rename to test/solid/output/event_logs/disabled/with_source/recursion_test.rb
index ae975eb8..f64b3414 100644
--- a/test/bcdd/context/event_logs/disabled/with_source/recursion_test.rb
+++ b/test/solid/output/event_logs/disabled/with_source/recursion_test.rb
@@ -2,23 +2,23 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsDisabledWithSourceInstanceRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsDisabledWithSourceInstanceRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
class Fibonacci
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(input)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
require_valid_number(input).and_then do |output|
number = output.fetch(:number)
diff --git a/test/bcdd/context/event_logs/disabled/without_source/flat_test.rb b/test/solid/output/event_logs/disabled/without_source/flat_test.rb
similarity index 69%
rename from test/bcdd/context/event_logs/disabled/without_source/flat_test.rb
rename to test/solid/output/event_logs/disabled/without_source/flat_test.rb
index c9f36c34..dec3380a 100644
--- a/test/bcdd/context/event_logs/disabled/without_source/flat_test.rb
+++ b/test/solid/output/event_logs/disabled/without_source/flat_test.rb
@@ -2,23 +2,23 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsDisabledWithoutSourceInstanceFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsDisabledWithoutSourceInstanceFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
module Division
extend self
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
@@ -28,20 +28,20 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num1 must be numeric')
- num2.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num2 must be numeric')
+ 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')
- Context::Success(:ok, num1: num1, num2: num2)
+ Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
- return Context::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
+ return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
- Context::Success(:ok)
+ Output::Success(:ok)
end
def divide(num1:, num2:)
- Context::Success(:ok, number: num1 / num2)
+ Output::Success(:ok, number: num1 / num2)
end
end
@@ -76,7 +76,7 @@ def divide(num1:, num2:)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
@@ -88,7 +88,7 @@ def divide(num1:, num2:)
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.call(4, 2)
diff --git a/test/bcdd/context/event_logs/disabled/without_source/nested_test.rb b/test/solid/output/event_logs/disabled/without_source/nested_test.rb
similarity index 70%
rename from test/bcdd/context/event_logs/disabled/without_source/nested_test.rb
rename to test/solid/output/event_logs/disabled/without_source/nested_test.rb
index 38c211ca..d5ed8a84 100644
--- a/test/bcdd/context/event_logs/disabled/without_source/nested_test.rb
+++ b/test/solid/output/event_logs/disabled/without_source/nested_test.rb
@@ -2,21 +2,21 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsDisabledWithoutSourceInstanceNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsDisabledWithoutSourceInstanceNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
class Division
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
@@ -26,20 +26,20 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num1 must be numeric')
- num2.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num2 must be numeric')
+ 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')
- Context::Success(:ok, num1: num1, num2: num2)
+ Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
- return Context::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
+ return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
- Context::Success(:ok)
+ Output::Success(:ok)
end
def divide(num1:, num2:)
- Context::Success(:ok, number: num1 / num2)
+ Output::Success(:ok, number: num1 / num2)
end
end
@@ -47,13 +47,13 @@ module SumDivisionsByTwo
extend self
def call(*numbers)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
- Context::Failure(:errors, errors: divisions.select(&:failure?).map(&:value))
+ Output::Failure(:errors, errors: divisions.select(&:failure?).map(&:value))
else
- Context::Success(:sum, number: divisions.sum { _1.value[:number] })
+ Output::Success(:sum, number: divisions.sum { _1.value[:number] })
end
end
end
@@ -96,7 +96,7 @@ def divide_by_two(num)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
@@ -108,7 +108,7 @@ def divide_by_two(num)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
diff --git a/test/bcdd/context/event_logs/disabled/without_source/recursion_test.rb b/test/solid/output/event_logs/disabled/without_source/recursion_test.rb
similarity index 60%
rename from test/bcdd/context/event_logs/disabled/without_source/recursion_test.rb
rename to test/solid/output/event_logs/disabled/without_source/recursion_test.rb
index ad05fa21..f1d69dd5 100644
--- a/test/bcdd/context/event_logs/disabled/without_source/recursion_test.rb
+++ b/test/solid/output/event_logs/disabled/without_source/recursion_test.rb
@@ -2,29 +2,29 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsDisabledWithoutSourceInstanceRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsDisabledWithoutSourceInstanceRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
module Fibonacci
extend self
def call(input)
- BCDD::Result.event_logs do
+ 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]
- Context::Success(:fibonacci, number: fibonacci)
+ Output::Success(:fibonacci, number: fibonacci)
end
end
end
@@ -32,11 +32,11 @@ def call(input)
private
def require_valid_number(input)
- input.is_a?(Numeric) or return Context::Failure(:invalid_input, message: 'input must be numeric')
+ input.is_a?(Numeric) or return Output::Failure(:invalid_input, message: 'input must be numeric')
- input.negative? and return Context::Failure(:negative_number, message: 'number cannot be negative')
+ input.negative? and return Output::Failure(:negative_number, message: 'number cannot be negative')
- Context::Success(:positive_number, number: input)
+ Output::Success(:positive_number, number: input)
end
end
diff --git a/test/solid/output/event_logs/enabled/not_been_started_test.rb b/test/solid/output/event_logs/enabled/not_been_started_test.rb
new file mode 100644
index 00000000..2a09fab8
--- /dev/null
+++ b/test/solid/output/event_logs/enabled/not_been_started_test.rb
@@ -0,0 +1,17 @@
+# 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
diff --git a/test/bcdd/context/event_logs/enabled/with_source/instance/flat_test.rb b/test/solid/output/event_logs/enabled/with_source/instance/flat_test.rb
similarity index 88%
rename from test/bcdd/context/event_logs/enabled/with_source/instance/flat_test.rb
rename to test/solid/output/event_logs/enabled/with_source/instance/flat_test.rb
index 7ad181ef..944ec12c 100644
--- a/test/bcdd/context/event_logs/enabled/with_source/instance/flat_test.rb
+++ b/test/solid/output/event_logs/enabled/with_source/instance/flat_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithSourceInstanceFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithSourceInstanceFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Division
- include Context.mixin
+ include Output.mixin
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
@@ -68,7 +68,7 @@ def divide(num1:, num2:)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
@@ -80,7 +80,7 @@ def divide(num1:, num2:)
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.new.call(4, 2)
diff --git a/test/bcdd/context/event_logs/enabled/with_source/instance/nested_test.rb b/test/solid/output/event_logs/enabled/with_source/instance/nested_test.rb
similarity index 88%
rename from test/bcdd/context/event_logs/enabled/with_source/instance/nested_test.rb
rename to test/solid/output/event_logs/enabled/with_source/instance/nested_test.rb
index 3b32d2c3..6843bc32 100644
--- a/test/bcdd/context/event_logs/enabled/with_source/instance/nested_test.rb
+++ b/test/solid/output/event_logs/enabled/with_source/instance/nested_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithSourceInstanceNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithSourceInstanceNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Division
- include Context.mixin
+ include Output.mixin
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
@@ -38,10 +38,10 @@ def divide(num1:, num2:)
end
class SumDivisionsByTwo
- include Context.mixin
+ include Output.mixin
def call(*numbers)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
@@ -90,7 +90,7 @@ def divide_by_two(num)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
@@ -102,7 +102,7 @@ def divide_by_two(num)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
diff --git a/test/bcdd/context/event_logs/enabled/with_source/instance/recursion_test.rb b/test/solid/output/event_logs/enabled/with_source/instance/recursion_test.rb
similarity index 85%
rename from test/bcdd/context/event_logs/enabled/with_source/instance/recursion_test.rb
rename to test/solid/output/event_logs/enabled/with_source/instance/recursion_test.rb
index 76f504db..26735ba2 100644
--- a/test/bcdd/context/event_logs/enabled/with_source/instance/recursion_test.rb
+++ b/test/solid/output/event_logs/enabled/with_source/instance/recursion_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithSourceInstanceRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithSourceInstanceRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Fibonacci
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(input)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
require_valid_number(input).and_then do |output|
number = output.fetch(:number)
diff --git a/test/bcdd/context/event_logs/enabled/with_source/singleton/flat_test.rb b/test/solid/output/event_logs/enabled/with_source/singleton/flat_test.rb
similarity index 87%
rename from test/bcdd/context/event_logs/enabled/with_source/singleton/flat_test.rb
rename to test/solid/output/event_logs/enabled/with_source/singleton/flat_test.rb
index a1fccb77..7e8a4d93 100644
--- a/test/bcdd/context/event_logs/enabled/with_source/singleton/flat_test.rb
+++ b/test/solid/output/event_logs/enabled/with_source/singleton/flat_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithSourceSingletonFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithSourceSingletonFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
module Division
- extend self, Context.mixin
+ extend self, Output.mixin
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
@@ -68,7 +68,7 @@ def divide(num1:, num2:)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
@@ -80,7 +80,7 @@ def divide(num1:, num2:)
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.call(4, 2)
diff --git a/test/bcdd/context/event_logs/enabled/with_source/singleton/nested_test.rb b/test/solid/output/event_logs/enabled/with_source/singleton/nested_test.rb
similarity index 95%
rename from test/bcdd/context/event_logs/enabled/with_source/singleton/nested_test.rb
rename to test/solid/output/event_logs/enabled/with_source/singleton/nested_test.rb
index 903c1f5d..538a8b3a 100644
--- a/test/bcdd/context/event_logs/enabled/with_source/singleton/nested_test.rb
+++ b/test/solid/output/event_logs/enabled/with_source/singleton/nested_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithSourceSingletonNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithSourceSingletonNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
module Division
- extend self, Context.mixin(config: { addon: { continue: true } })
+ extend self, Output.mixin(config: { addon: { continue: true } })
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero, useless_arg: true)
.and_then(:divide)
@@ -36,10 +36,10 @@ def divide(num1:, num2:, **)
end
module SumDivisionsByTwo
- extend self, Context.mixin
+ extend self, Output.mixin
def call(*numbers)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
@@ -88,7 +88,7 @@ def divide_by_two(num)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
@@ -100,7 +100,7 @@ def divide_by_two(num)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
diff --git a/test/bcdd/context/event_logs/enabled/with_source/singleton/recursion_test.rb b/test/solid/output/event_logs/enabled/with_source/singleton/recursion_test.rb
similarity index 84%
rename from test/bcdd/context/event_logs/enabled/with_source/singleton/recursion_test.rb
rename to test/solid/output/event_logs/enabled/with_source/singleton/recursion_test.rb
index 9e5ac665..db687bae 100644
--- a/test/bcdd/context/event_logs/enabled/with_source/singleton/recursion_test.rb
+++ b/test/solid/output/event_logs/enabled/with_source/singleton/recursion_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithSourceSingletonRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithSourceSingletonRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
module Fibonacci
- extend self, BCDD::Context.mixin
+ extend self, Solid::Output.mixin
def call(input)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
require_valid_number(input).and_then do |output|
number = output.fetch(:number)
diff --git a/test/bcdd/context/event_logs/enabled/without_source/instance/flat_test.rb b/test/solid/output/event_logs/enabled/without_source/instance/flat_test.rb
similarity index 73%
rename from test/bcdd/context/event_logs/enabled/without_source/instance/flat_test.rb
rename to test/solid/output/event_logs/enabled/without_source/instance/flat_test.rb
index afea315f..18b2f4de 100644
--- a/test/bcdd/context/event_logs/enabled/without_source/instance/flat_test.rb
+++ b/test/solid/output/event_logs/enabled/without_source/instance/flat_test.rb
@@ -2,13 +2,13 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithoutSourceInstanceFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithoutSourceInstanceFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Division
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
@@ -18,20 +18,20 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num1 must be numeric')
- num2.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num2 must be numeric')
+ 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')
- Context::Success(:ok, num1: num1, num2: num2)
+ Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
- return Context::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
+ return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
- Context::Success(:ok)
+ Output::Success(:ok)
end
def divide(num1:, num2:)
- Context::Success(:ok, number: num1 / num2)
+ Output::Success(:ok, number: num1 / num2)
end
end
@@ -66,7 +66,7 @@ def divide(num1:, num2:)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
@@ -78,7 +78,7 @@ def divide(num1:, num2:)
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.new.call(4, 2)
diff --git a/test/bcdd/context/event_logs/enabled/without_source/instance/nested_test.rb b/test/solid/output/event_logs/enabled/without_source/instance/nested_test.rb
similarity index 72%
rename from test/bcdd/context/event_logs/enabled/without_source/instance/nested_test.rb
rename to test/solid/output/event_logs/enabled/without_source/instance/nested_test.rb
index 2cb37c50..901f6d4d 100644
--- a/test/bcdd/context/event_logs/enabled/without_source/instance/nested_test.rb
+++ b/test/solid/output/event_logs/enabled/without_source/instance/nested_test.rb
@@ -2,13 +2,13 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithoutSourceInstanceNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithoutSourceInstanceNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Division
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
@@ -18,32 +18,32 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num1 must be numeric')
- num2.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num2 must be numeric')
+ 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')
- Context::Success(:ok, num1: num1, num2: num2)
+ Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
- return Context::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
+ return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
- Context::Success(:ok)
+ Output::Success(:ok)
end
def divide(num1:, num2:)
- Context::Success(:ok, number: num1 / num2)
+ Output::Success(:ok, number: num1 / num2)
end
end
class SumDivisionsByTwo
def call(*numbers)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
- Context::Failure(:errors, errors: divisions.select(&:failure?).map(&:value))
+ Output::Failure(:errors, errors: divisions.select(&:failure?).map(&:value))
else
- Context::Success(:sum, number: divisions.sum { _1.value[:number] })
+ Output::Success(:sum, number: divisions.sum { _1.value[:number] })
end
end
end
@@ -86,7 +86,7 @@ def divide_by_two(num)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
@@ -98,7 +98,7 @@ def divide_by_two(num)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
diff --git a/test/bcdd/context/event_logs/enabled/without_source/instance/recursion_test.rb b/test/solid/output/event_logs/enabled/without_source/instance/recursion_test.rb
similarity index 64%
rename from test/bcdd/context/event_logs/enabled/without_source/instance/recursion_test.rb
rename to test/solid/output/event_logs/enabled/without_source/instance/recursion_test.rb
index c6559835..bb622fcf 100644
--- a/test/bcdd/context/event_logs/enabled/without_source/instance/recursion_test.rb
+++ b/test/solid/output/event_logs/enabled/without_source/instance/recursion_test.rb
@@ -2,19 +2,19 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithoutSourceInstanceRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithoutSourceInstanceRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Fibonacci
def call(input)
- BCDD::Result.event_logs do
+ 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]
- Context::Success(:fibonacci, number: fibonacci)
+ Output::Success(:fibonacci, number: fibonacci)
end
end
end
@@ -22,11 +22,11 @@ def call(input)
private
def require_valid_number(input)
- input.is_a?(Numeric) or return Context::Failure(:invalid_input, message: 'input must be numeric')
+ input.is_a?(Numeric) or return Output::Failure(:invalid_input, message: 'input must be numeric')
- input.negative? and return Context::Failure(:negative_number, message: 'number cannot be negative')
+ input.negative? and return Output::Failure(:negative_number, message: 'number cannot be negative')
- Context::Success(:positive_number, number: input)
+ Output::Success(:positive_number, number: input)
end
end
diff --git a/test/bcdd/context/event_logs/enabled/without_source/singleton/flat_test.rb b/test/solid/output/event_logs/enabled/without_source/singleton/flat_test.rb
similarity index 72%
rename from test/bcdd/context/event_logs/enabled/without_source/singleton/flat_test.rb
rename to test/solid/output/event_logs/enabled/without_source/singleton/flat_test.rb
index faf94d27..6d048a72 100644
--- a/test/bcdd/context/event_logs/enabled/without_source/singleton/flat_test.rb
+++ b/test/solid/output/event_logs/enabled/without_source/singleton/flat_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithoutSourceSingletonFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithoutSourceSingletonFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
module Division
extend self
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
@@ -20,20 +20,20 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num1 must be numeric')
- num2.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num2 must be numeric')
+ 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')
- Context::Success(:ok, num1: num1, num2: num2)
+ Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
- return Context::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
+ return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
- Context::Success(:ok)
+ Output::Success(:ok)
end
def divide(num1:, num2:)
- Context::Success(:ok, number: num1 / num2)
+ Output::Success(:ok, number: num1 / num2)
end
end
@@ -68,7 +68,7 @@ def divide(num1:, num2:)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
@@ -80,7 +80,7 @@ def divide(num1:, num2:)
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = Division.call(4, 2)
diff --git a/test/bcdd/context/event_logs/enabled/without_source/singleton/nested_test.rb b/test/solid/output/event_logs/enabled/without_source/singleton/nested_test.rb
similarity index 72%
rename from test/bcdd/context/event_logs/enabled/without_source/singleton/nested_test.rb
rename to test/solid/output/event_logs/enabled/without_source/singleton/nested_test.rb
index 22b9409c..d5cec479 100644
--- a/test/bcdd/context/event_logs/enabled/without_source/singleton/nested_test.rb
+++ b/test/solid/output/event_logs/enabled/without_source/singleton/nested_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithoutSourceSingletonNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithoutSourceSingletonNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
module Division
extend self
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |output| validate_nonzero(**output) }
.and_then { |output| divide(**output) }
@@ -20,20 +20,20 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num1 must be numeric')
- num2.is_a?(Numeric) or return Context::Failure(:invalid_arg, message: 'num2 must be numeric')
+ 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')
- Context::Success(:ok, num1: num1, num2: num2)
+ Output::Success(:ok, num1: num1, num2: num2)
end
def validate_nonzero(num2:, **)
- return Context::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
+ return Output::Failure(:division_by_zero, message: 'num2 cannot be zero') if num2.zero?
- Context::Success(:ok)
+ Output::Success(:ok)
end
def divide(num1:, num2:)
- Context::Success(:ok, number: num1 / num2)
+ Output::Success(:ok, number: num1 / num2)
end
end
@@ -41,13 +41,13 @@ module SumDivisionsByTwo
extend self
def call(*numbers)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
- Context::Failure(:errors, errors: divisions.select(&:failure?).map(&:value))
+ Output::Failure(:errors, errors: divisions.select(&:failure?).map(&:value))
else
- Context::Success(:sum, number: divisions.sum { _1.value[:number] })
+ Output::Success(:sum, number: divisions.sum { _1.value[:number] })
end
end
end
@@ -90,7 +90,7 @@ def divide_by_two(num)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
@@ -102,7 +102,7 @@ def divide_by_two(num)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
diff --git a/test/bcdd/context/event_logs/enabled/without_source/singleton/recursion_test.rb b/test/solid/output/event_logs/enabled/without_source/singleton/recursion_test.rb
similarity index 64%
rename from test/bcdd/context/event_logs/enabled/without_source/singleton/recursion_test.rb
rename to test/solid/output/event_logs/enabled/without_source/singleton/recursion_test.rb
index d9b61669..b93aca4f 100644
--- a/test/bcdd/context/event_logs/enabled/without_source/singleton/recursion_test.rb
+++ b/test/solid/output/event_logs/enabled/without_source/singleton/recursion_test.rb
@@ -2,21 +2,21 @@
require 'test_helper'
-module BCDD
- class Context::EventLogsEnabledWithoutSourceSingletonRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+module Solid
+ class Output::EventLogsEnabledWithoutSourceSingletonRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
module Fibonacci
extend self
def call(input)
- BCDD::Result.event_logs do
+ 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]
- Context::Success(:fibonacci, number: fibonacci)
+ Output::Success(:fibonacci, number: fibonacci)
end
end
end
@@ -24,11 +24,11 @@ def call(input)
private
def require_valid_number(input)
- input.is_a?(Numeric) or return Context::Failure(:invalid_input, message: 'input must be numeric')
+ input.is_a?(Numeric) or return Output::Failure(:invalid_input, message: 'input must be numeric')
- input.negative? and return Context::Failure(:negative_number, message: 'number cannot be negative')
+ input.negative? and return Output::Failure(:negative_number, message: 'number cannot be negative')
- Context::Success(:positive_number, number: input)
+ Output::Success(:positive_number, number: input)
end
end
diff --git a/test/bcdd/context/expectations/mixin_constants_test.rb b/test/solid/output/expectations/mixin_constants_test.rb
similarity index 63%
rename from test/bcdd/context/expectations/mixin_constants_test.rb
rename to test/solid/output/expectations/mixin_constants_test.rb
index a66055ee..6e42338f 100644
--- a/test/bcdd/context/expectations/mixin_constants_test.rb
+++ b/test/solid/output/expectations/mixin_constants_test.rb
@@ -2,24 +2,24 @@
require 'test_helper'
-class BCDD::Context::Expectations::MixinConstantsTest < Minitest::Test
+class Solid::Output::Expectations::MixinConstantsTest < Minitest::Test
class IncludingInClass
- include BCDD::Context::Expectations.mixin
+ include Solid::Output::Expectations.mixin
end
module IncludingInModule
- include BCDD::Context::Expectations.mixin
+ include Solid::Output::Expectations.mixin
end
class ExtendingInClass
- extend BCDD::Context::Expectations.mixin
+ extend Solid::Output::Expectations.mixin
end
module ExtendingInModule
- extend BCDD::Context::Expectations.mixin
+ extend Solid::Output::Expectations.mixin
end
- test 'BCDD::Context::Expectations.mixin sets a constant in all classes/modules' do
+ 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)
diff --git a/test/bcdd/context/expectations/with_source/failure/type/invalid_type_test.rb b/test/solid/output/expectations/with_source/failure/type/invalid_type_test.rb
similarity index 84%
rename from test/bcdd/context/expectations/with_source/failure/type/invalid_type_test.rb
rename to test/solid/output/expectations/with_source/failure/type/invalid_type_test.rb
index 45c7e92e..81eee752 100644
--- a/test/bcdd/context/expectations/with_source/failure/type/invalid_type_test.rb
+++ b/test/solid/output/expectations/with_source/failure/type/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceFailureInvalidTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceFailureInvalidTypeTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
failure: :err
)
@@ -35,7 +35,7 @@ def divide(number1:, number2:)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call('10', 2)
end
diff --git a/test/bcdd/context/expectations/with_source/failure/type_and_value/invalid_type_test.rb b/test/solid/output/expectations/with_source/failure/type_and_value/invalid_type_test.rb
similarity index 86%
rename from test/bcdd/context/expectations/with_source/failure/type_and_value/invalid_type_test.rb
rename to test/solid/output/expectations/with_source/failure/type_and_value/invalid_type_test.rb
index ccc687a5..015b800f 100644
--- a/test/bcdd/context/expectations/with_source/failure/type_and_value/invalid_type_test.rb
+++ b/test/solid/output/expectations/with_source/failure/type_and_value/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceFailureInvalidTypeAndValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceFailureInvalidTypeAndValueTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ 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) }
@@ -38,7 +38,7 @@ def divide(number1:, number2:)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/context/expectations/with_source/failure/type_and_value/invalid_value_test.rb b/test/solid/output/expectations/with_source/failure/type_and_value/invalid_value_test.rb
similarity index 82%
rename from test/bcdd/context/expectations/with_source/failure/type_and_value/invalid_value_test.rb
rename to test/solid/output/expectations/with_source/failure/type_and_value/invalid_value_test.rb
index 37312bd0..10846dd1 100644
--- a/test/bcdd/context/expectations/with_source/failure/type_and_value/invalid_value_test.rb
+++ b/test/solid/output/expectations/with_source/failure/type_and_value/invalid_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ 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) }
@@ -22,7 +22,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/context/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb b/test/solid/output/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb
similarity index 84%
rename from test/bcdd/context/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb
rename to test/solid/output/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb
index fcd0901b..9ab50e0b 100644
--- a/test/bcdd/context/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb
+++ b/test/solid/output/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
failure: {
invalid_arg: ->(value) {
case value
@@ -30,7 +30,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 0)
end
diff --git a/test/bcdd/context/expectations/with_source/failure/type_and_value_test.rb b/test/solid/output/expectations/with_source/failure/type_and_value_test.rb
similarity index 86%
rename from test/bcdd/context/expectations/with_source/failure/type_and_value_test.rb
rename to test/solid/output/expectations/with_source/failure/type_and_value_test.rb
index e3aacd26..d77c2459 100644
--- a/test/bcdd/context/expectations/with_source/failure/type_and_value_test.rb
+++ b/test/solid/output/expectations/with_source/failure/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceFailureTypeAndValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceFailureTypeAndValueTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
failure: {
invalid_arg: ->(value) {
case value
@@ -86,7 +86,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -99,11 +99,11 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
@@ -121,13 +121,13 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -145,19 +145,19 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/with_source/failure/type_test.rb b/test/solid/output/expectations/with_source/failure/type_test.rb
similarity index 84%
rename from test/bcdd/context/expectations/with_source/failure/type_test.rb
rename to test/solid/output/expectations/with_source/failure/type_test.rb
index d86bf121..f8996313 100644
--- a/test/bcdd/context/expectations/with_source/failure/type_test.rb
+++ b/test/solid/output/expectations/with_source/failure/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceFailureTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceFailureTypeTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
failure: :err
)
@@ -75,7 +75,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -88,11 +88,11 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
@@ -110,13 +110,13 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -134,7 +134,7 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err = assert_raises(BCDD::Result::Error::UnhandledTypes) 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
diff --git a/test/bcdd/context/expectations/with_source/failure/types/invalid_type_test.rb b/test/solid/output/expectations/with_source/failure/types/invalid_type_test.rb
similarity index 84%
rename from test/bcdd/context/expectations/with_source/failure/types/invalid_type_test.rb
rename to test/solid/output/expectations/with_source/failure/types/invalid_type_test.rb
index 4904af0c..aa13c08e 100644
--- a/test/bcdd/context/expectations/with_source/failure/types/invalid_type_test.rb
+++ b/test/solid/output/expectations/with_source/failure/types/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceFailureInvalidTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceFailureInvalidTypesTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
failure: %i[err1 err2]
)
@@ -35,7 +35,7 @@ def divide(number1:, number2:)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/context/expectations/with_source/failure/types_test.rb b/test/solid/output/expectations/with_source/failure/types_test.rb
similarity index 83%
rename from test/bcdd/context/expectations/with_source/failure/types_test.rb
rename to test/solid/output/expectations/with_source/failure/types_test.rb
index 85a5e2f5..8e2a0322 100644
--- a/test/bcdd/context/expectations/with_source/failure/types_test.rb
+++ b/test/solid/output/expectations/with_source/failure/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceFailureTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceFailureTypesTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
failure: %i[invalid_arg division_by_zero]
)
@@ -75,7 +75,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -88,15 +88,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -119,19 +119,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -154,25 +154,25 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/with_source/success/type/invalid_type_test.rb b/test/solid/output/expectations/with_source/success/type/invalid_type_test.rb
similarity index 78%
rename from test/bcdd/context/expectations/with_source/success/type/invalid_type_test.rb
rename to test/solid/output/expectations/with_source/success/type/invalid_type_test.rb
index b50e6792..c43b36c7 100644
--- a/test/bcdd/context/expectations/with_source/success/type/invalid_type_test.rb
+++ b/test/solid/output/expectations/with_source/success/type/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessInvalidTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessInvalidTypeTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: :ok
)
@@ -19,7 +19,7 @@ def call(arg1, arg2)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/context/expectations/with_source/success/type_and_value/invalid_type_test.rb b/test/solid/output/expectations/with_source/success/type_and_value/invalid_type_test.rb
similarity index 81%
rename from test/bcdd/context/expectations/with_source/success/type_and_value/invalid_type_test.rb
rename to test/solid/output/expectations/with_source/success/type_and_value/invalid_type_test.rb
index b654070e..b965675c 100644
--- a/test/bcdd/context/expectations/with_source/success/type_and_value/invalid_type_test.rb
+++ b/test/solid/output/expectations/with_source/success/type_and_value/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: {
division_completed: ->(value) {
case value
@@ -25,7 +25,7 @@ def call(arg1, arg2)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/context/expectations/with_source/success/type_and_value/invalid_value_test.rb b/test/solid/output/expectations/with_source/success/type_and_value/invalid_value_test.rb
similarity index 81%
rename from test/bcdd/context/expectations/with_source/success/type_and_value/invalid_value_test.rb
rename to test/solid/output/expectations/with_source/success/type_and_value/invalid_value_test.rb
index a8d68a51..ef536151 100644
--- a/test/bcdd/context/expectations/with_source/success/type_and_value/invalid_value_test.rb
+++ b/test/solid/output/expectations/with_source/success/type_and_value/invalid_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: {
division_completed: ->(value) {
value.is_a?(::Hash) && value[:number].is_a?(::Numeric)
@@ -23,7 +23,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/context/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb b/test/solid/output/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb
similarity index 82%
rename from test/bcdd/context/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb
rename to test/solid/output/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb
index b7eab9a0..bd04c756 100644
--- a/test/bcdd/context/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb
+++ b/test/solid/output/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: {
division_completed: ->(value) {
case value
@@ -25,7 +25,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/context/expectations/with_source/success/type_and_value_test.rb b/test/solid/output/expectations/with_source/success/type_and_value_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/with_source/success/type_and_value_test.rb
rename to test/solid/output/expectations/with_source/success/type_and_value_test.rb
index befa5936..d6ad1005 100644
--- a/test/bcdd/context/expectations/with_source/success/type_and_value_test.rb
+++ b/test/solid/output/expectations/with_source/success/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessTypeAndValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessTypeAndValueTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: {
numbers: ->(value) {
case value
@@ -85,7 +85,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -98,11 +98,11 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
@@ -120,13 +120,13 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -144,19 +144,19 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/with_source/success/type_test.rb b/test/solid/output/expectations/with_source/success/type_test.rb
similarity index 86%
rename from test/bcdd/context/expectations/with_source/success/type_test.rb
rename to test/solid/output/expectations/with_source/success/type_test.rb
index e55d9c1f..d3600be5 100644
--- a/test/bcdd/context/expectations/with_source/success/type_test.rb
+++ b/test/solid/output/expectations/with_source/success/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessTypeTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: :ok
)
@@ -74,7 +74,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:numbers)
end
@@ -87,11 +87,11 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -109,7 +109,7 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -122,7 +122,7 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err = assert_raises(BCDD::Result::Error::UnhandledTypes) 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
diff --git a/test/bcdd/context/expectations/with_source/success/types/invalid_type_test.rb b/test/solid/output/expectations/with_source/success/types/invalid_type_test.rb
similarity index 84%
rename from test/bcdd/context/expectations/with_source/success/types/invalid_type_test.rb
rename to test/solid/output/expectations/with_source/success/types/invalid_type_test.rb
index e71aa749..473d6700 100644
--- a/test/bcdd/context/expectations/with_source/success/types/invalid_type_test.rb
+++ b/test/solid/output/expectations/with_source/success/types/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessInvalidTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessInvalidTypesTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: %i[ok1 ok2 ok3]
)
@@ -35,7 +35,7 @@ def divide(number1:, number2:)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/context/expectations/with_source/success/types_test.rb b/test/solid/output/expectations/with_source/success/types_test.rb
similarity index 83%
rename from test/bcdd/context/expectations/with_source/success/types_test.rb
rename to test/solid/output/expectations/with_source/success/types_test.rb
index 485e3020..0295267e 100644
--- a/test/bcdd/context/expectations/with_source/success/types_test.rb
+++ b/test/solid/output/expectations/with_source/success/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessTypesTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: %i[numbers division_completed]
)
@@ -74,7 +74,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -87,15 +87,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -118,19 +118,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -153,25 +153,25 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb b/test/solid/output/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb
rename to test/solid/output/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb
index 2f164318..bec0107c 100644
--- a/test/bcdd/context/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb
+++ b/test/solid/output/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: {
numbers: ->(value) {
case value
@@ -125,7 +125,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -136,7 +136,7 @@ def divide(number1:, number2:)
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -149,15 +149,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -180,19 +180,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -215,37 +215,37 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb b/test/solid/output/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb
rename to test/solid/output/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb
index ef9c00e8..bc4830be 100644
--- a/test/bcdd/context/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb
+++ b/test/solid/output/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: %i[numbers division_completed],
failure: {
invalid_arg: ->(value) {
@@ -125,7 +125,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -136,7 +136,7 @@ def divide(number1:, number2:)
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -149,15 +149,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -180,19 +180,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -215,37 +215,37 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/with_source/success_and_failure/type_and_value_test.rb b/test/solid/output/expectations/with_source/success_and_failure/type_and_value_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/with_source/success_and_failure/type_and_value_test.rb
rename to test/solid/output/expectations/with_source/success_and_failure/type_and_value_test.rb
index 2f0a22bc..cba7092e 100644
--- a/test/bcdd/context/expectations/with_source/success_and_failure/type_and_value_test.rb
+++ b/test/solid/output/expectations/with_source/success_and_failure/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: {
numbers: ->(value) {
case value
@@ -136,7 +136,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -147,7 +147,7 @@ def divide(number1:, number2:)
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -160,15 +160,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -191,19 +191,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -226,37 +226,37 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/with_source/success_and_failure/type_test.rb b/test/solid/output/expectations/with_source/success_and_failure/type_test.rb
similarity index 83%
rename from test/bcdd/context/expectations/with_source/success_and_failure/type_test.rb
rename to test/solid/output/expectations/with_source/success_and_failure/type_test.rb
index b74056dc..568fe334 100644
--- a/test/bcdd/context/expectations/with_source/success_and_failure/type_test.rb
+++ b/test/solid/output/expectations/with_source/success_and_failure/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessAndFailureTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessAndFailureTypeTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: :ok,
failure: :err
)
@@ -114,7 +114,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:division_completed)
end
@@ -125,7 +125,7 @@ def divide(number1:, number2:)
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:division_by_zero)
end
@@ -138,15 +138,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -169,19 +169,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -204,37 +204,37 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/with_source/success_and_failure/types_test.rb b/test/solid/output/expectations/with_source/success_and_failure/types_test.rb
similarity index 84%
rename from test/bcdd/context/expectations/with_source/success_and_failure/types_test.rb
rename to test/solid/output/expectations/with_source/success_and_failure/types_test.rb
index a488bd33..0c17b919 100644
--- a/test/bcdd/context/expectations/with_source/success_and_failure/types_test.rb
+++ b/test/solid/output/expectations/with_source/success_and_failure/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithSourceSuccessAndFailureTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithSourceSuccessAndFailureTypesTest < Minitest::Test
class Divide
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
@@ -114,7 +114,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -125,7 +125,7 @@ def divide(number1:, number2:)
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -138,15 +138,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -169,19 +169,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -204,37 +204,37 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/without_source/failure/type/invalid_type_test.rb b/test/solid/output/expectations/without_source/failure/type/invalid_type_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/without_source/failure/type/invalid_type_test.rb
rename to test/solid/output/expectations/without_source/failure/type/invalid_type_test.rb
index 8b3479e4..0b064648 100644
--- a/test/bcdd/context/expectations/without_source/failure/type/invalid_type_test.rb
+++ b/test/solid/output/expectations/without_source/failure/type/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceFailureInvalidTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceFailureInvalidTypeTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
failure: :err
)
@@ -35,7 +35,7 @@ def divide(number1:, number2:)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call('10', 2)
end
diff --git a/test/bcdd/context/expectations/without_source/failure/type_and_value/invalid_type_test.rb b/test/solid/output/expectations/without_source/failure/type_and_value/invalid_type_test.rb
similarity index 87%
rename from test/bcdd/context/expectations/without_source/failure/type_and_value/invalid_type_test.rb
rename to test/solid/output/expectations/without_source/failure/type_and_value/invalid_type_test.rb
index 89c205e6..004a52fc 100644
--- a/test/bcdd/context/expectations/without_source/failure/type_and_value/invalid_type_test.rb
+++ b/test/solid/output/expectations/without_source/failure/type_and_value/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceFailureInvalidTypeAndValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceFailureInvalidTypeAndValueTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
failure: {
err1: ->(value) {
case value
@@ -46,7 +46,7 @@ def divide(number1:, number2:)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/context/expectations/without_source/failure/type_and_value/invalid_value_test.rb b/test/solid/output/expectations/without_source/failure/type_and_value/invalid_value_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/without_source/failure/type_and_value/invalid_value_test.rb
rename to test/solid/output/expectations/without_source/failure/type_and_value/invalid_value_test.rb
index b5322160..c33a448d 100644
--- a/test/bcdd/context/expectations/without_source/failure/type_and_value/invalid_value_test.rb
+++ b/test/solid/output/expectations/without_source/failure/type_and_value/invalid_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
failure: {
invalid_arg: ->(value) {
case value
@@ -30,7 +30,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/context/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb b/test/solid/output/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb
rename to test/solid/output/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb
index 76b281ac..129232f5 100644
--- a/test/bcdd/context/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb
+++ b/test/solid/output/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
failure: {
invalid_arg: ->(value) {
case value
@@ -30,7 +30,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 0)
end
diff --git a/test/bcdd/context/expectations/without_source/failure/type_and_value_test.rb b/test/solid/output/expectations/without_source/failure/type_and_value_test.rb
similarity index 86%
rename from test/bcdd/context/expectations/without_source/failure/type_and_value_test.rb
rename to test/solid/output/expectations/without_source/failure/type_and_value_test.rb
index e03efdd9..018e9043 100644
--- a/test/bcdd/context/expectations/without_source/failure/type_and_value_test.rb
+++ b/test/solid/output/expectations/without_source/failure/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceFailureTypeAndValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceFailureTypeAndValueTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
failure: {
invalid_arg: ->(value) {
case value
@@ -86,7 +86,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -99,11 +99,11 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
@@ -121,13 +121,13 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -145,19 +145,19 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/without_source/failure/type_test.rb b/test/solid/output/expectations/without_source/failure/type_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/without_source/failure/type_test.rb
rename to test/solid/output/expectations/without_source/failure/type_test.rb
index 8ab20bcd..46c80068 100644
--- a/test/bcdd/context/expectations/without_source/failure/type_test.rb
+++ b/test/solid/output/expectations/without_source/failure/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceFailureTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceFailureTypeTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
failure: :err
)
@@ -75,7 +75,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -88,11 +88,11 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
@@ -110,13 +110,13 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -134,7 +134,7 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err = assert_raises(BCDD::Result::Error::UnhandledTypes) 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
diff --git a/test/bcdd/context/expectations/without_source/failure/types/invalid_type_test.rb b/test/solid/output/expectations/without_source/failure/types/invalid_type_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/without_source/failure/types/invalid_type_test.rb
rename to test/solid/output/expectations/without_source/failure/types/invalid_type_test.rb
index 0d230c4d..b6096942 100644
--- a/test/bcdd/context/expectations/without_source/failure/types/invalid_type_test.rb
+++ b/test/solid/output/expectations/without_source/failure/types/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceFailureInvalidTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceFailureInvalidTypesTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
failure: %i[err1 err2]
)
@@ -35,7 +35,7 @@ def divide(number1:, number2:)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/context/expectations/without_source/failure/types_test.rb b/test/solid/output/expectations/without_source/failure/types_test.rb
similarity index 84%
rename from test/bcdd/context/expectations/without_source/failure/types_test.rb
rename to test/solid/output/expectations/without_source/failure/types_test.rb
index 4b8e573e..05421f1c 100644
--- a/test/bcdd/context/expectations/without_source/failure/types_test.rb
+++ b/test/solid/output/expectations/without_source/failure/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceFailureTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceFailureTypesTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
failure: %i[invalid_arg division_by_zero]
)
@@ -75,7 +75,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -88,15 +88,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -119,19 +119,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -154,25 +154,25 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/without_source/success/type/invalid_type_test.rb b/test/solid/output/expectations/without_source/success/type/invalid_type_test.rb
similarity index 79%
rename from test/bcdd/context/expectations/without_source/success/type/invalid_type_test.rb
rename to test/solid/output/expectations/without_source/success/type/invalid_type_test.rb
index d73ed1ed..33f47327 100644
--- a/test/bcdd/context/expectations/without_source/success/type/invalid_type_test.rb
+++ b/test/solid/output/expectations/without_source/success/type/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessInvalidTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessInvalidTypeTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: :ok
)
@@ -19,7 +19,7 @@ def call(arg1, arg2)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/context/expectations/without_source/success/type_and_value/invalid_type_test.rb b/test/solid/output/expectations/without_source/success/type_and_value/invalid_type_test.rb
similarity index 82%
rename from test/bcdd/context/expectations/without_source/success/type_and_value/invalid_type_test.rb
rename to test/solid/output/expectations/without_source/success/type_and_value/invalid_type_test.rb
index 6fe184e7..f53d93f7 100644
--- a/test/bcdd/context/expectations/without_source/success/type_and_value/invalid_type_test.rb
+++ b/test/solid/output/expectations/without_source/success/type_and_value/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: {
division_completed: ->(value) {
case value
@@ -25,7 +25,7 @@ def call(arg1, arg2)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/context/expectations/without_source/success/type_and_value/invalid_value_test.rb b/test/solid/output/expectations/without_source/success/type_and_value/invalid_value_test.rb
similarity index 83%
rename from test/bcdd/context/expectations/without_source/success/type_and_value/invalid_value_test.rb
rename to test/solid/output/expectations/without_source/success/type_and_value/invalid_value_test.rb
index d425a943..9ec72da0 100644
--- a/test/bcdd/context/expectations/without_source/success/type_and_value/invalid_value_test.rb
+++ b/test/solid/output/expectations/without_source/success/type_and_value/invalid_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: {
division_completed: ->(value) {
case value
@@ -25,7 +25,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/context/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb b/test/solid/output/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb
similarity index 83%
rename from test/bcdd/context/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb
rename to test/solid/output/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb
index 85d33aa7..b1be3138 100644
--- a/test/bcdd/context/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb
+++ b/test/solid/output/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: {
division_completed: ->(value) do
case value
@@ -25,7 +25,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/context/expectations/without_source/success/type_and_value_test.rb b/test/solid/output/expectations/without_source/success/type_and_value_test.rb
similarity index 86%
rename from test/bcdd/context/expectations/without_source/success/type_and_value_test.rb
rename to test/solid/output/expectations/without_source/success/type_and_value_test.rb
index 5c5fa088..1899e386 100644
--- a/test/bcdd/context/expectations/without_source/success/type_and_value_test.rb
+++ b/test/solid/output/expectations/without_source/success/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessTypeAndValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessTypeAndValueTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: {
numbers: ->(value) {
case value
@@ -85,7 +85,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -98,11 +98,11 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
@@ -120,13 +120,13 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -144,19 +144,19 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/without_source/success/type_test.rb b/test/solid/output/expectations/without_source/success/type_test.rb
similarity index 86%
rename from test/bcdd/context/expectations/without_source/success/type_test.rb
rename to test/solid/output/expectations/without_source/success/type_test.rb
index 33fd1870..0a69fbfa 100644
--- a/test/bcdd/context/expectations/without_source/success/type_test.rb
+++ b/test/solid/output/expectations/without_source/success/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessTypeTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: :ok
)
@@ -74,7 +74,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:numbers)
end
@@ -87,11 +87,11 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -109,7 +109,7 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -122,7 +122,7 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err = assert_raises(BCDD::Result::Error::UnhandledTypes) 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
diff --git a/test/bcdd/context/expectations/without_source/success/types/invalid_type_test.rb b/test/solid/output/expectations/without_source/success/types/invalid_type_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/without_source/success/types/invalid_type_test.rb
rename to test/solid/output/expectations/without_source/success/types/invalid_type_test.rb
index 954c3ff0..bd596863 100644
--- a/test/bcdd/context/expectations/without_source/success/types/invalid_type_test.rb
+++ b/test/solid/output/expectations/without_source/success/types/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessInvalidTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessInvalidTypesTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: %i[ok1 ok2 ok3]
)
@@ -35,7 +35,7 @@ def divide(number1:, number2:)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/context/expectations/without_source/success/types_test.rb b/test/solid/output/expectations/without_source/success/types_test.rb
similarity index 83%
rename from test/bcdd/context/expectations/without_source/success/types_test.rb
rename to test/solid/output/expectations/without_source/success/types_test.rb
index e48d597e..6119ace5 100644
--- a/test/bcdd/context/expectations/without_source/success/types_test.rb
+++ b/test/solid/output/expectations/without_source/success/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessTypesTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: %i[numbers division_completed]
)
@@ -74,7 +74,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -87,15 +87,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -118,19 +118,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -153,25 +153,25 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb b/test/solid/output/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb
rename to test/solid/output/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb
index 63d750fb..de2414a0 100644
--- a/test/bcdd/context/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb
+++ b/test/solid/output/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: {
numbers: ->(value) {
case value
@@ -125,7 +125,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -136,7 +136,7 @@ def divide(number1:, number2:)
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -149,15 +149,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -180,19 +180,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -215,37 +215,37 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb b/test/solid/output/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb
rename to test/solid/output/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb
index b8a3b1e7..673d61c0 100644
--- a/test/bcdd/context/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb
+++ b/test/solid/output/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: %i[numbers division_completed],
failure: {
invalid_arg: ->(value) {
@@ -125,7 +125,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -136,7 +136,7 @@ def divide(number1:, number2:)
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -149,15 +149,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -180,19 +180,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -215,37 +215,37 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/without_source/success_and_failure/type_and_value_test.rb b/test/solid/output/expectations/without_source/success_and_failure/type_and_value_test.rb
similarity index 86%
rename from test/bcdd/context/expectations/without_source/success_and_failure/type_and_value_test.rb
rename to test/solid/output/expectations/without_source/success_and_failure/type_and_value_test.rb
index 8a039355..a530615c 100644
--- a/test/bcdd/context/expectations/without_source/success_and_failure/type_and_value_test.rb
+++ b/test/solid/output/expectations/without_source/success_and_failure/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: {
numbers: ->(value) {
case value
@@ -136,7 +136,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -147,7 +147,7 @@ def divide(number1:, number2:)
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -160,15 +160,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -191,19 +191,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -226,37 +226,37 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/without_source/success_and_failure/type_test.rb b/test/solid/output/expectations/without_source/success_and_failure/type_test.rb
similarity index 83%
rename from test/bcdd/context/expectations/without_source/success_and_failure/type_test.rb
rename to test/solid/output/expectations/without_source/success_and_failure/type_test.rb
index df759daf..23f2c0f9 100644
--- a/test/bcdd/context/expectations/without_source/success_and_failure/type_test.rb
+++ b/test/solid/output/expectations/without_source/success_and_failure/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessAndFailureTypeTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessAndFailureTypeTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: :ok,
failure: :err
)
@@ -114,7 +114,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:division_completed)
end
@@ -125,7 +125,7 @@ def divide(number1:, number2:)
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:division_by_zero)
end
@@ -138,15 +138,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -169,19 +169,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -204,37 +204,37 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/context/expectations/without_source/success_and_failure/types_test.rb b/test/solid/output/expectations/without_source/success_and_failure/types_test.rb
similarity index 85%
rename from test/bcdd/context/expectations/without_source/success_and_failure/types_test.rb
rename to test/solid/output/expectations/without_source/success_and_failure/types_test.rb
index 60c2ce71..6184a1de 100644
--- a/test/bcdd/context/expectations/without_source/success_and_failure/types_test.rb
+++ b/test/solid/output/expectations/without_source/success_and_failure/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Context::ExpectationsWithoutSourceSuccessAndFailureTypesTest < Minitest::Test
+class Solid::Output::ExpectationsWithoutSourceSuccessAndFailureTypesTest < Minitest::Test
class Divide
- Result = BCDD::Context::Expectations.new(
+ Result = Solid::Output::Expectations.new(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
@@ -114,7 +114,7 @@ def divide(number1:, number2:)
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -125,7 +125,7 @@ def divide(number1:, number2:)
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -138,15 +138,15 @@ def divide(number1:, number2:)
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -169,19 +169,19 @@ def divide(number1:, number2:)
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -204,37 +204,37 @@ def divide(number1:, number2:)
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/solid/output/failure_test.rb b/test/solid/output/failure_test.rb
new file mode 100644
index 00000000..33c7de9f
--- /dev/null
+++ b/test/solid/output/failure_test.rb
@@ -0,0 +1,24 @@
+# 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
diff --git a/test/bcdd/context/mixin_constants_test.rb b/test/solid/output/mixin_constants_test.rb
similarity index 65%
rename from test/bcdd/context/mixin_constants_test.rb
rename to test/solid/output/mixin_constants_test.rb
index 1276a58a..056fd50d 100644
--- a/test/bcdd/context/mixin_constants_test.rb
+++ b/test/solid/output/mixin_constants_test.rb
@@ -2,24 +2,24 @@
require 'test_helper'
-class BCDD::Context::MixinConstantsTest < Minitest::Test
+class Solid::Output::MixinConstantsTest < Minitest::Test
class IncludingInClass
- include BCDD::Context.mixin
+ include Solid::Output.mixin
end
module IncludingInModule
- include BCDD::Context.mixin
+ include Solid::Output.mixin
end
class ExtendingInClass
- extend BCDD::Context.mixin
+ extend Solid::Output.mixin
end
module ExtendingInModule
- extend BCDD::Context.mixin
+ extend Solid::Output.mixin
end
- test 'BCDD::Context.mixin sets a constant in all classes/modules' do
+ test 'Solid::Output.mixin sets a constant in all classes/modules' do
assert IncludingInClass.const_defined?(:ResultMixin, false)
assert IncludingInModule.const_defined?(:ResultMixin, false)
diff --git a/test/bcdd/context/pattern_matching/deconstruct_keys_test.rb b/test/solid/output/pattern_matching/deconstruct_keys_test.rb
similarity index 52%
rename from test/bcdd/context/pattern_matching/deconstruct_keys_test.rb
rename to test/solid/output/pattern_matching/deconstruct_keys_test.rb
index f9b5209b..44ebd347 100644
--- a/test/bcdd/context/pattern_matching/deconstruct_keys_test.rb
+++ b/test/solid/output/pattern_matching/deconstruct_keys_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Context::PatternMatchingDeconstructKeysTest < Minitest::Test
+class Solid::Output::PatternMatchingDeconstructKeysTest < Minitest::Test
Divide = ->(arg1, arg2) do
- arg1.is_a?(::Numeric) or return BCDD::Context::Failure(:invalid_arg, err: 'arg1 must be numeric')
- arg2.is_a?(::Numeric) or return BCDD::Context::Failure(:invalid_arg, err: 'arg2 must be numeric')
+ 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 BCDD::Context::Failure(:division_by_zero, err: 'arg2 must not be zero') if arg2.zero?
+ return Solid::Output::Failure(:division_by_zero, err: 'arg2 must not be zero') if arg2.zero?
- BCDD::Context::Success(:division_completed, num: arg1 / arg2)
+ Solid::Output::Success(:division_completed, num: arg1 / arg2)
end
test '#deconstruct_keys success' do
@@ -18,30 +18,30 @@ class BCDD::Context::PatternMatchingDeconstructKeysTest < Minitest::Test
assert_equal({ num: 5 }, result.deconstruct_keys([]))
case result
- in BCDD::Failure(type: _, value: _)
+ in Solid::Failure(type: _, value: _)
raise
- in BCDD::Success(type: :division_completed, value: { num: num })
+ in Solid::Success(type: :division_completed, value: { num: num })
assert_equal 5, num
end
case result
- in BCDD::Failure
+ in Solid::Failure
raise
- in BCDD::Success(num: num)
+ in Solid::Success(num: num)
assert_equal 5, num
end
case result
- in BCDD::Context::Failure(type: _, value: _)
+ in Solid::Output::Failure(type: _, value: _)
raise
- in BCDD::Context::Success(type: :division_completed, value: { num: num })
+ in Solid::Output::Success(type: :division_completed, value: { num: num })
assert_equal 5, num
end
case result
- in BCDD::Context::Failure
+ in Solid::Output::Failure
raise
- in BCDD::Context::Success(num: num)
+ in Solid::Output::Success(num: num)
assert_equal 5, num
end
end
@@ -52,30 +52,30 @@ class BCDD::Context::PatternMatchingDeconstructKeysTest < Minitest::Test
assert_equal({ err: 'arg2 must not be zero' }, result.deconstruct_keys([]))
case result
- in BCDD::Success(type: _, value: _)
+ in Solid::Success(type: _, value: _)
raise
- in BCDD::Failure(type: :division_by_zero, value: {err: msg})
+ in Solid::Failure(type: :division_by_zero, value: {err: msg})
assert_equal 'arg2 must not be zero', msg
end
case result
- in BCDD::Success
+ in Solid::Success
raise
- in BCDD::Failure(err: msg)
+ in Solid::Failure(err: msg)
assert_equal 'arg2 must not be zero', msg
end
case result
- in BCDD::Context::Success(type: _, value: _)
+ in Solid::Output::Success(type: _, value: _)
raise
- in BCDD::Context::Failure(type: :division_by_zero, value: {err: msg})
+ in Solid::Output::Failure(type: :division_by_zero, value: {err: msg})
assert_equal 'arg2 must not be zero', msg
end
case result
- in BCDD::Context::Success
+ in Solid::Output::Success
raise
- in BCDD::Context::Failure(err: msg)
+ in Solid::Output::Failure(err: msg)
assert_equal 'arg2 must not be zero', msg
end
end
diff --git a/test/bcdd/context/pattern_matching/deconstruct_test.rb b/test/solid/output/pattern_matching/deconstruct_test.rb
similarity index 54%
rename from test/bcdd/context/pattern_matching/deconstruct_test.rb
rename to test/solid/output/pattern_matching/deconstruct_test.rb
index 7aa2e579..d4a3cf0c 100644
--- a/test/bcdd/context/pattern_matching/deconstruct_test.rb
+++ b/test/solid/output/pattern_matching/deconstruct_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Context::PatternMatchingDeconstructTest < Minitest::Test
+class Solid::Output::PatternMatchingDeconstructTest < Minitest::Test
Divide = ->(arg1, arg2) do
- arg1.is_a?(::Numeric) or return BCDD::Context::Failure(:invalid_arg, err: 'arg1 must be numeric')
- arg2.is_a?(::Numeric) or return BCDD::Context::Failure(:invalid_arg, err: 'arg2 must be numeric')
+ 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 BCDD::Context::Failure(:division_by_zero, err: 'arg2 must not be zero') if arg2.zero?
+ return Solid::Output::Failure(:division_by_zero, err: 'arg2 must not be zero') if arg2.zero?
- BCDD::Context::Success(:division_completed, num: arg1 / arg2)
+ Solid::Output::Success(:division_completed, num: arg1 / arg2)
end
test '#deconstruct success' do
@@ -18,16 +18,16 @@ class BCDD::Context::PatternMatchingDeconstructTest < Minitest::Test
assert_equal [:division_completed, { num: 5 }], result.deconstruct
case result
- in BCDD::Failure[_, _]
+ in Solid::Failure[_, _]
raise
- in BCDD::Success[:division_completed, {num: value}]
+ in Solid::Success[:division_completed, {num: value}]
assert_equal 5, value
end
case result
- in BCDD::Context::Failure[_, _]
+ in Solid::Output::Failure[_, _]
raise
- in BCDD::Context::Success[:division_completed, {num: value}]
+ in Solid::Output::Success[:division_completed, {num: value}]
assert_equal 5, value
end
end
@@ -38,16 +38,16 @@ class BCDD::Context::PatternMatchingDeconstructTest < Minitest::Test
assert_equal [:division_by_zero, { err: 'arg2 must not be zero' }], result.deconstruct
case result
- in BCDD::Success[_, _]
+ in Solid::Success[_, _]
raise
- in BCDD::Failure[:division_by_zero, {err: msg}]
+ in Solid::Failure[:division_by_zero, {err: msg}]
assert_equal 'arg2 must not be zero', msg
end
case result
- in BCDD::Context::Success[_, _]
+ in Solid::Output::Success[_, _]
raise
- in BCDD::Context::Failure[:division_by_zero, {err: msg}]
+ in Solid::Output::Failure[:division_by_zero, {err: msg}]
assert_equal 'arg2 must not be zero', msg
end
end
diff --git a/test/bcdd/context/success_test.rb b/test/solid/output/success_test.rb
similarity index 70%
rename from test/bcdd/context/success_test.rb
rename to test/solid/output/success_test.rb
index 6e5e660b..f1c98442 100644
--- a/test/bcdd/context/success_test.rb
+++ b/test/solid/output/success_test.rb
@@ -2,28 +2,28 @@
require 'test_helper'
-module BCDD
- class ContextSuccessTest < Minitest::Test
- test 'is a BCDD::Context' do
- assert Context::Success < BCDD::Context
+module Solid
+ class OutputSuccessTest < Minitest::Test
+ test 'is a Solid::Output' do
+ assert Output::Success < Solid::Output
end
- test 'is a BCDD::Success' do
- assert Context::Success < BCDD::Success
+ test 'is a Solid::Success' do
+ assert Output::Success < Solid::Success
end
test '#inspect' do
- result = Context::Success(:ok, number: 1)
+ result = Output::Success(:ok, number: 1)
assert_equal(
- '#1}>',
+ '#1}>',
result.inspect
)
end
test '#[]' do
- result1 = Context::Success(:ok)
- result2 = Context::Success(:ok, a: 1, b: 2)
+ result1 = Output::Success(:ok)
+ result2 = Output::Success(:ok, a: 1, b: 2)
assert_nil result1[:a]
assert_nil result1[:b]
@@ -34,8 +34,8 @@ class ContextSuccessTest < Minitest::Test
# rubocop:disable Style/SingleArgumentDig
test '#dig' do
- result1 = Context::Success(:ok)
- result2 = Context::Success(:ok, a: { b: 1 })
+ result1 = Output::Success(:ok)
+ result2 = Output::Success(:ok, a: { b: 1 })
assert_nil result1.dig(:a, :b)
assert_nil result2.dig(:a, :c)
@@ -46,8 +46,8 @@ class ContextSuccessTest < Minitest::Test
# rubocop:enable Style/SingleArgumentDig
test '#fetch' do
- result1 = Context::Success(:ok)
- result2 = Context::Success(:ok, a: 1, b: 2)
+ result1 = Output::Success(:ok)
+ result2 = Output::Success(:ok, a: 1, b: 2)
assert_raises(KeyError) { result1.fetch(:a) }
assert_raises(KeyError) { result1.fetch(:b) }
@@ -75,24 +75,24 @@ class ContextSuccessTest < Minitest::Test
end
test '#slice' do
- result1 = Context::Success(:ok)
- result2 = Context::Success(:ok, a: 1, b: 2)
+ 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 = Context::Success(:ok)
- result2 = Context::Success(:ok, a: 1, b: 2)
+ 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 = Context::Success(:ok)
- result2 = Context::Success(:ok, a: 1, b: 2)
+ result1 = Output::Success(:ok)
+ result2 = Output::Success(:ok, a: 1, b: 2)
assert_raises(KeyError) do
result1.fetch_values(:a, :b)
diff --git a/test/bcdd/context_test.rb b/test/solid/output_test.rb
similarity index 60%
rename from test/bcdd/context_test.rb
rename to test/solid/output_test.rb
index df84c12c..f287e92f 100644
--- a/test/bcdd/context_test.rb
+++ b/test/solid/output_test.rb
@@ -2,54 +2,54 @@
require 'test_helper'
-module BCDD
- class ContextTest < Minitest::Test
- test 'is a BCDD::Result' do
- assert Context < BCDD::Result
+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) { Context.new(type: :ok, value: nil) }
+ err = assert_raises(ArgumentError) { Output.new(type: :ok, value: nil) }
assert_equal 'value must be a Hash', err.message
end
test '::Success()' do
- result = Context::Success(:ok)
+ result = Output::Success(:ok)
assert_equal(:ok, result.type)
assert_equal({}, result.value)
# ---
- result = Context::Success(:yes, number: 1)
+ result = Output::Success(:yes, number: 1)
assert_equal(:yes, result.type)
assert_equal({ number: 1 }, result.value)
# ---
- err = assert_raises(ArgumentError) { Context::Success(:ok, nil) }
+ 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 = Context::Failure(:no)
+ result = Output::Failure(:no)
assert_equal(:no, result.type)
assert_equal({}, result.value)
# ---
- result = Context::Failure(:err, number: 0)
+ result = Output::Failure(:err, number: 0)
assert_equal(:err, result.type)
assert_equal({ number: 0 }, result.value)
# ---
- err = assert_raises(ArgumentError) { Context::Failure(:ok, nil) }
+ err = assert_raises(ArgumentError) { Output::Failure(:ok, nil) }
assert_equal 'wrong number of arguments (given 2, expected 1)', err.message
end
diff --git a/test/bcdd/result/addons/continue/expectations_test.rb b/test/solid/result/addons/continue/expectations_test.rb
similarity index 86%
rename from test/bcdd/result/addons/continue/expectations_test.rb
rename to test/solid/result/addons/continue/expectations_test.rb
index e85d6677..0f653263 100644
--- a/test/bcdd/result/addons/continue/expectations_test.rb
+++ b/test/solid/result/addons/continue/expectations_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::AddonsContinueExpectationsTest < Minitest::Test
+class Solid::Result::AddonsContinueExpectationsTest < Minitest::Test
class DivideType
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :ok,
failure: :err
@@ -37,7 +37,7 @@ def divide((number1, number2))
end
class DivideTypes
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :division_completed,
failure: %i[invalid_arg division_by_zero]
@@ -70,7 +70,7 @@ def divide((number1, number2))
end
module DivideTypeAndValue
- extend self, BCDD::Result::Expectations.mixin(
+ extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: { division_completed: Numeric },
failure: { invalid_arg: String, division_by_zero: String }
@@ -121,17 +121,17 @@ def divide((number1, number2))
failure2 = DivideTypes.new.call('10', 0)
failure3 = DivideTypeAndValue.call('10', 0)
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { success1.success?(:division_completed) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { success2.success?(:ok) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { success3.success?(:ok) }
+ 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(BCDD::Result::Contract::Error::UnexpectedType) { failure1.failure?(:invalid_arg) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { failure2.failure?(:err) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedType) { failure3.failure?(:err) }
+ 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 BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
@@ -144,7 +144,7 @@ def call
end
class InstanceSecondSuccessToTerminateTheStepChainAndThenBlock
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
@@ -157,7 +157,7 @@ def call
end
class InstanceThirdSuccessToTerminateTheStepChainAndThenBlock
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
@@ -170,7 +170,7 @@ def call
end
module SingletonFirstSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Result::Expectations.mixin(
+ extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
@@ -183,7 +183,7 @@ def call
end
module SingletonSecondSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Result::Expectations.mixin(
+ extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
@@ -196,7 +196,7 @@ def call
end
module SingletonThirdSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Result::Expectations.mixin(
+ extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
@@ -227,7 +227,7 @@ def call
end
class InstanceFirstSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
@@ -246,7 +246,7 @@ def third_success; Continue(:third); end
end
class InstanceSecondSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
@@ -265,7 +265,7 @@ def third_success; Continue(:third); end
end
class InstanceThirdSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
@@ -284,7 +284,7 @@ def third_success; Success(:third); end
end
module SingletonFirstSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Result::Expectations.mixin(
+ extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :first
)
@@ -303,7 +303,7 @@ def third_success; Continue(:third); end
end
module SingletonSecondSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Result::Expectations.mixin(
+ extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :second
)
@@ -322,7 +322,7 @@ def third_success; Continue(:third); end
end
module SingletonThirdSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Result::Expectations.mixin(
+ extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :third
)
diff --git a/test/bcdd/result/addons/continue/instance_test.rb b/test/solid/result/addons/continue/instance_test.rb
similarity index 87%
rename from test/bcdd/result/addons/continue/instance_test.rb
rename to test/solid/result/addons/continue/instance_test.rb
index cedcedc9..2de9e358 100644
--- a/test/bcdd/result/addons/continue/instance_test.rb
+++ b/test/solid/result/addons/continue/instance_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::AddonsContinueInstanceTest < Minitest::Test
+class Solid::Result::AddonsContinueInstanceTest < Minitest::Test
class Divide
- include BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
validate_numbers(arg1, arg2)
@@ -57,7 +57,7 @@ def divide((number1, number2))
end
class FirstSuccessToTerminateTheStepChainAndThenBlock
- include BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call
Success(:first)
@@ -67,7 +67,7 @@ def call
end
class SecondSuccessToTerminateTheStepChainAndThenBlock
- include BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call
Continue(:first)
@@ -77,7 +77,7 @@ def call
end
class ThirdSuccessToTerminateTheStepChainAndThenBlock
- include BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call
Continue(:first)
@@ -97,7 +97,7 @@ def call
end
class FirstSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
@@ -113,7 +113,7 @@ def third_success; Continue(:third); end
end
class SecondSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
@@ -129,7 +129,7 @@ def third_success; Continue(:third); end
end
class ThirdSuccessToTerminateTheStepChainAndThenMethod
- include BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
diff --git a/test/bcdd/result/addons/continue/singleton_test.rb b/test/solid/result/addons/continue/singleton_test.rb
similarity index 86%
rename from test/bcdd/result/addons/continue/singleton_test.rb
rename to test/solid/result/addons/continue/singleton_test.rb
index 950a485a..2dff826e 100644
--- a/test/bcdd/result/addons/continue/singleton_test.rb
+++ b/test/solid/result/addons/continue/singleton_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::AddonsContinueSingletonTest < Minitest::Test
+class Solid::Result::AddonsContinueSingletonTest < Minitest::Test
module Divide
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
validate_numbers(arg1, arg2)
@@ -57,7 +57,7 @@ def divide((number1, number2))
end
module FirstSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
Success(:first)
@@ -67,7 +67,7 @@ def call
end
module SecondSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
Continue(:first)
@@ -77,7 +77,7 @@ def call
end
module ThirdSuccessToTerminateTheStepChainAndThenBlock
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
Continue(:first)
@@ -97,7 +97,7 @@ def call
end
module FirstSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
@@ -113,7 +113,7 @@ def third_success; Continue(:third); end
end
module SecondSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
@@ -129,7 +129,7 @@ def third_success; Continue(:third); end
end
module ThirdSuccessToTerminateTheStepChainAndThenMethod
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call
first_success
diff --git a/test/bcdd/result/addons/given/expectations_test.rb b/test/solid/result/addons/given/expectations_test.rb
similarity index 93%
rename from test/bcdd/result/addons/given/expectations_test.rb
rename to test/solid/result/addons/given/expectations_test.rb
index de4452c0..cd7f0df6 100644
--- a/test/bcdd/result/addons/given/expectations_test.rb
+++ b/test/solid/result/addons/given/expectations_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::AddonsGivenExpectationsTest < Minitest::Test
+class Solid::Result::AddonsGivenExpectationsTest < Minitest::Test
class DivideType
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :ok,
failure: :err
@@ -40,7 +40,7 @@ def divide((number1, number2))
end
class DivideTypes
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: :division_completed,
failure: %i[invalid_arg division_by_zero]
@@ -74,7 +74,7 @@ def divide((number1, number2))
end
module DivideTypeAndValue
- extend self, BCDD::Result::Expectations.mixin(
+ extend self, Solid::Result::Expectations.mixin(
config: { addon: { continue: true } },
success: { division_completed: Numeric },
failure: { invalid_arg: String, division_by_zero: String }
diff --git a/test/bcdd/result/addons/given/instance_test.rb b/test/solid/result/addons/given/instance_test.rb
similarity index 91%
rename from test/bcdd/result/addons/given/instance_test.rb
rename to test/solid/result/addons/given/instance_test.rb
index 738c5f7a..09950587 100644
--- a/test/bcdd/result/addons/given/instance_test.rb
+++ b/test/solid/result/addons/given/instance_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::AddonsGivenInstanceTest < Minitest::Test
+class Solid::Result::AddonsGivenInstanceTest < Minitest::Test
class Divide
- include BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Given([arg1, arg2])
diff --git a/test/bcdd/result/addons/given/singleton_test.rb b/test/solid/result/addons/given/singleton_test.rb
similarity index 91%
rename from test/bcdd/result/addons/given/singleton_test.rb
rename to test/solid/result/addons/given/singleton_test.rb
index 397d5859..cd4a6c29 100644
--- a/test/bcdd/result/addons/given/singleton_test.rb
+++ b/test/solid/result/addons/given/singleton_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::AddonsGivenSingletonTest < Minitest::Test
+class Solid::Result::AddonsGivenSingletonTest < Minitest::Test
module Divide
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
Given([arg1, arg2])
diff --git a/test/bcdd/result/and_then/argument_error_test.rb b/test/solid/result/and_then/argument_error_test.rb
similarity index 91%
rename from test/bcdd/result/and_then/argument_error_test.rb
rename to test/solid/result/and_then/argument_error_test.rb
index 80c07697..07b0c748 100644
--- a/test/bcdd/result/and_then/argument_error_test.rb
+++ b/test/solid/result/and_then/argument_error_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class AndThenArgumentErrorTest < Minitest::Test
module SomeModule
- extend BCDD::Result.mixin
+ extend Solid::Result.mixin
def self.call(arg1, arg2)
Success(:ok, arg1 + arg2)
diff --git a/test/bcdd/result/and_then/with_source_test.rb b/test/solid/result/and_then/with_source_test.rb
similarity index 85%
rename from test/bcdd/result/and_then/with_source_test.rb
rename to test/solid/result/and_then/with_source_test.rb
index dc4b91ef..898a1f72 100644
--- a/test/bcdd/result/and_then/with_source_test.rb
+++ b/test/solid/result/and_then/with_source_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class AndThenWithSourceTest < Minitest::Test
class Base
- include BCDD::Result.mixin
+ include Solid::Result.mixin
attr_reader :arg1, :arg2
@@ -140,7 +140,7 @@ def add
test '#and_then calling a source method with wrong arity (> 2)' do
wrong_source_method_arity = InvalidSourceMethodArity.new(1, 2)
- error = assert_raises(BCDD::Result::Error::InvalidSourceMethodArity) { wrong_source_method_arity.call }
+ error = assert_raises(Solid::Result::Error::InvalidSourceMethodArity) { wrong_source_method_arity.call }
expected_message = "#{InvalidSourceMethodArity}#add has unsupported arity (3). Expected 0..2"
@@ -150,13 +150,13 @@ def add
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(BCDD::Result::Error::InvalidResultSource) { wrong_result_source.call }
+ 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: #'
+ 'Given result: #'
assert_equal(expected_message, error.message)
end
@@ -164,33 +164,33 @@ def add
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(BCDD::Result::Error::InvalidResultSource) { wrong_result_source.call }
+ 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: #'
+ '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(BCDD::Result::Error::UnexpectedOutcome) { UnexpectedBlockOutcome.new(1, 2).call }
+ 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 ' \
- 'BCDD::Result::Success or BCDD::Result::Failure'
+ '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(BCDD::Result::Error::UnexpectedOutcome) { UnexpectedMethodOutcome.new(1, 2).call }
+ 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 ' \
- 'BCDD::Result::Success or BCDD::Result::Failure'
+ 'Solid::Result::Success or Solid::Result::Failure'
assert_equal(expected_message, error.message)
end
diff --git a/test/bcdd/result/and_then/without_source_test.rb b/test/solid/result/and_then/without_source_test.rb
similarity index 91%
rename from test/bcdd/result/and_then/without_source_test.rb
rename to test/solid/result/and_then/without_source_test.rb
index f37a955b..309ecde8 100644
--- a/test/bcdd/result/and_then/without_source_test.rb
+++ b/test/solid/result/and_then/without_source_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class AndThenWithoutSourceTest < Minitest::Test
test '#and_then does not execute the block if the result is a failure' do
result =
@@ -40,7 +40,7 @@ class AndThenWithoutSourceTest < Minitest::Test
end
test '#and_then raises an exception if the block does not return a result' do
- error = assert_raises(BCDD::Result::Error::UnexpectedOutcome) do
+ error = assert_raises(Solid::Result::Error::UnexpectedOutcome) do
Success
.new(type: :one, value: 1)
.and_then { Success.new(type: :two, value: 2) }
@@ -49,7 +49,7 @@ class AndThenWithoutSourceTest < Minitest::Test
assert_equal(
'Unexpected outcome: 3. The block must return this object wrapped by ' \
- 'BCDD::Result::Success or BCDD::Result::Failure',
+ 'Solid::Result::Success or Solid::Result::Failure',
error.message
)
end
diff --git a/test/solid/result/callable_and_then/arity_test.rb b/test/solid/result/callable_and_then/arity_test.rb
new file mode 100644
index 00000000..01a4345e
--- /dev/null
+++ b/test/solid/result/callable_and_then/arity_test.rb
@@ -0,0 +1,107 @@
+# 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
diff --git a/test/bcdd/result/callable_and_then/results_from_different_sources_test.rb b/test/solid/result/callable_and_then/results_from_different_sources_test.rb
similarity index 90%
rename from test/bcdd/result/callable_and_then/results_from_different_sources_test.rb
rename to test/solid/result/callable_and_then/results_from_different_sources_test.rb
index a94b3869..6f3600b4 100644
--- a/test/bcdd/result/callable_and_then/results_from_different_sources_test.rb
+++ b/test/solid/result/callable_and_then/results_from_different_sources_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class CallableAndThenResultFromDifferentSourcesTest < Minitest::Test
- include BCDDResultEventLogAssertions
+ include SolidResultEventLogAssertions
module NormalizeEmail
- extend BCDD::Result.mixin
+ extend Solid::Result.mixin
def self.call(input)
- BCDD::Result.event_logs(name: 'NormalizeEmail') do
+ Solid::Result.event_logs(name: 'NormalizeEmail') do
Given(input).and_then(:normalize)
end
end
@@ -23,14 +23,14 @@ def self.normalize(input)
end
class EmailValidation
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def initialize(expected_pattern: /\A[^@\s]+@[^@\s]+\z/)
@expected_pattern = expected_pattern
end
def call(input)
- BCDD::Result.event_logs(name: 'EmailValidation') do
+ Solid::Result.event_logs(name: 'EmailValidation') do
Given(input).and_then(:validate)
end
end
@@ -41,10 +41,10 @@ def validate(input)
end
module NormalizeAndValidateEmail
- extend BCDD::Result.mixin
+ extend Solid::Result.mixin
def self.call(email)
- BCDD::Result.event_logs(name: 'NormalizeAndValidateEmail') do
+ Solid::Result.event_logs(name: 'NormalizeAndValidateEmail') do
Given(email)
.and_then!(NormalizeEmail)
.and_then!(EmailValidation.new)
@@ -53,11 +53,11 @@ def self.call(email)
end
def setup
- BCDD::Result.config.feature.enable!(:and_then!)
+ Solid::Result.config.feature.enable!(:and_then!)
end
def teardown
- BCDD::Result.config.feature.disable!(:and_then!)
+ Solid::Result.config.feature.disable!(:and_then!)
end
test 'results from different sources' do
diff --git a/test/bcdd/result/callable_and_then/returning_context_test.rb b/test/solid/result/callable_and_then/returning_an_output_test.rb
similarity index 65%
rename from test/bcdd/result/callable_and_then/returning_context_test.rb
rename to test/solid/result/callable_and_then/returning_an_output_test.rb
index 68d0f698..375f8559 100644
--- a/test/bcdd/result/callable_and_then/returning_context_test.rb
+++ b/test/solid/result/callable_and_then/returning_an_output_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-class BCDD::Result
- class CallableAndThenReturninContextTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result
+ class CallableAndThenReturninAnOutputTest < Minitest::Test
+ include SolidResultEventLogAssertions
module NormalizeEmail
- extend ::BCDD::Context.mixin
+ extend ::Solid::Output.mixin
def self.call(arg)
- BCDD::Result.event_logs(name: 'NormalizeEmail') do
+ 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')
@@ -21,10 +21,10 @@ def self.call(arg)
end
module EmailNormalization
- extend BCDD::Result.mixin
+ extend Solid::Result.mixin
def self.call(input)
- BCDD::Result.event_logs(name: 'EmailNormalization') do
+ Solid::Result.event_logs(name: 'EmailNormalization') do
Given(input: input)
.and_then!(NormalizeEmail)
end
@@ -32,7 +32,7 @@ def self.call(input)
end
test 'results from different sources' do
- BCDD::Result.config.feature.enable!(:and_then!)
+ Solid::Result.config.feature.enable!(:and_then!)
result1 = EmailNormalization.call(nil)
@@ -40,7 +40,7 @@ def self.call(input)
assert(result1.failure?(:invalid_input))
assert_equal({ message: 'input must be a String' }, result1.value)
- assert_kind_of(::BCDD::Context, result1)
+ assert_kind_of(::Solid::Output, result1)
result2 = EmailNormalization.call(' foo@BAR.com')
@@ -48,9 +48,9 @@ def self.call(input)
assert(result2.success?(:normalized_input))
assert_equal({ input: 'foo@bar.com' }, result2.value)
- assert_kind_of(::BCDD::Context, result2)
+ assert_kind_of(::Solid::Output, result2)
ensure
- BCDD::Result.config.feature.disable!(:and_then!)
+ Solid::Result.config.feature.disable!(:and_then!)
end
end
end
diff --git a/test/bcdd/result/callable_and_then/unexpected_outcome_test.rb b/test/solid/result/callable_and_then/unexpected_outcome_test.rb
similarity index 56%
rename from test/bcdd/result/callable_and_then/unexpected_outcome_test.rb
rename to test/solid/result/callable_and_then/unexpected_outcome_test.rb
index e2df08e4..4283c62e 100644
--- a/test/bcdd/result/callable_and_then/unexpected_outcome_test.rb
+++ b/test/solid/result/callable_and_then/unexpected_outcome_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class CallableAndThenUnexpectedOutcomeTest < Minitest::Test
ProcWithArg = proc { |arg| arg }
@@ -11,23 +11,23 @@ def self.call(arg); arg; end
end
def setup
- BCDD::Result.config.feature.enable!(:and_then!)
+ Solid::Result.config.feature.enable!(:and_then!)
end
def teardown
- BCDD::Result.config.feature.disable!(:and_then!)
+ Solid::Result.config.feature.disable!(:and_then!)
end
test 'unexpected outcome' do
- err1 = assert_raises(BCDD::Result::CallableAndThen::Error::UnexpectedOutcome) do
- BCDD::Result::Success(:ok, 0).and_then!(ProcWithArg)
+ err1 = assert_raises(Solid::Result::CallableAndThen::Error::UnexpectedOutcome) do
+ Solid::Result::Success(:ok, 0).and_then!(ProcWithArg)
end
- err2 = assert_raises(BCDD::Result::CallableAndThen::Error::UnexpectedOutcome) do
- BCDD::Result::Success(:ok, 0).and_then!(ModWithArg)
+ err2 = assert_raises(Solid::Result::CallableAndThen::Error::UnexpectedOutcome) do
+ Solid::Result::Success(:ok, 0).and_then!(ModWithArg)
end
- expected_kinds = 'BCDD::Result::Success or BCDD::Result::Failure'
+ expected_kinds = 'Solid::Result::Success or Solid::Result::Failure'
assert_match(
/Unexpected outcome: 0. The # must return this object wrapped by #{expected_kinds}/,
diff --git a/test/bcdd/result/config/addon/continue_test.rb b/test/solid/result/config/addon/continue_test.rb
similarity index 81%
rename from test/bcdd/result/config/addon/continue_test.rb
rename to test/solid/result/config/addon/continue_test.rb
index 704a462b..1cb64bad 100644
--- a/test/bcdd/result/config/addon/continue_test.rb
+++ b/test/solid/result/config/addon/continue_test.rb
@@ -2,13 +2,13 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class AddonContinueTest < Minitest::Test
test 'the side effects' do
- BCDD::Result.config.addon.disable!(:continue)
+ Solid::Result.config.addon.disable!(:continue)
class1a = Class.new do
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call
Continue("this method won't exist as the default config is disabled")
@@ -16,7 +16,7 @@ def call
end
class2a = Class.new do
- include BCDD::Result::Expectations.mixin
+ include Solid::Result::Expectations.mixin
def call
Continue("this method won't exist as the default config is disabled")
@@ -24,7 +24,7 @@ def call
end
class3a = Class.new do
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call
Continue(msg: "this method won't exist as the default config is disabled")
@@ -32,7 +32,7 @@ def call
end
class4a = Class.new do
- include BCDD::Context::Expectations.mixin
+ include Solid::Output::Expectations.mixin
def call
Continue(msg: "this method won't exist as the default config is disabled")
@@ -49,10 +49,10 @@ def call
assert_match(/undefined method.+Continue/, error3a.message)
assert_match(/undefined method.+Continue/, error4a.message)
- BCDD::Result.config.addon.enable!(:continue)
+ Solid::Result.config.addon.enable!(:continue)
class1b = Class.new do
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call
Continue('this method will exist as the config is enabled by default')
@@ -60,7 +60,7 @@ def call
end
class2b = Class.new do
- include BCDD::Result::Expectations.mixin
+ include Solid::Result::Expectations.mixin
def call
Continue('this method will exist as the config is enabled by default')
@@ -68,7 +68,7 @@ def call
end
class3b = Class.new do
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call
Continue(msg: 'this method will exist as the config is enabled by default')
@@ -76,7 +76,7 @@ def call
end
class4b = Class.new do
- include BCDD::Context::Expectations.mixin
+ include Solid::Output::Expectations.mixin
def call
Continue(msg: 'this method will exist as the config is enabled by default')
@@ -88,10 +88,10 @@ def call
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
- BCDD::Result.config.addon.disable!(:continue)
+ Solid::Result.config.addon.disable!(:continue)
class1c = Class.new do
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call
Continue("this method won't exist as the default config is disabled")
@@ -99,7 +99,7 @@ def call
end
class2c = Class.new do
- include BCDD::Result::Expectations.mixin
+ include Solid::Result::Expectations.mixin
def call
Continue("this method won't exist as the default config is disabled")
@@ -107,7 +107,7 @@ def call
end
class3c = Class.new do
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call
Continue(msg: "this method won't exist as the default config is disabled")
@@ -115,7 +115,7 @@ def call
end
class4c = Class.new do
- include BCDD::Context::Expectations.mixin
+ include Solid::Output::Expectations.mixin
def call
Continue(msg: "this method won't exist as the default config is disabled")
@@ -134,10 +134,10 @@ def call
end
test 'the overwriting of the default config' do
- BCDD::Result.config.addon.enable!(:continue)
+ Solid::Result.config.addon.enable!(:continue)
class1 = Class.new do
- include BCDD::Result.mixin(config: { addon: { continue: false } })
+ include Solid::Result.mixin(config: { addon: { continue: false } })
def call
Continue("this method won't exist as the default config was overwritten")
@@ -145,7 +145,7 @@ def call
end
class2 = Class.new do
- include BCDD::Result::Expectations.mixin(config: { addon: { continue: false } })
+ include Solid::Result::Expectations.mixin(config: { addon: { continue: false } })
def call
Continue("this method won't exist as the default config was overwritten")
@@ -153,7 +153,7 @@ def call
end
class3 = Class.new do
- include BCDD::Context.mixin(config: { addon: { continue: false } })
+ include Solid::Output.mixin(config: { addon: { continue: false } })
def call
Continue(msg: "this method won't exist as the default config was overwritten")
@@ -161,7 +161,7 @@ def call
end
class4 = Class.new do
- include BCDD::Context::Expectations.mixin(config: { addon: { continue: false } })
+ include Solid::Output::Expectations.mixin(config: { addon: { continue: false } })
def call
Continue(msg: "this method won't exist as the default config was overwritten")
@@ -178,7 +178,7 @@ def call
assert_match(/undefined method.+Continue/, error3.message)
assert_match(/undefined method.+Continue/, error4.message)
ensure
- BCDD::Result.config.addon.disable!(:continue)
+ Solid::Result.config.addon.disable!(:continue)
end
end
end
diff --git a/test/bcdd/result/config/addon/given_test.rb b/test/solid/result/config/addon/given_test.rb
similarity index 83%
rename from test/bcdd/result/config/addon/given_test.rb
rename to test/solid/result/config/addon/given_test.rb
index e69ddd0f..0b297a62 100644
--- a/test/bcdd/result/config/addon/given_test.rb
+++ b/test/solid/result/config/addon/given_test.rb
@@ -2,13 +2,13 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class AddonGivenTest < Minitest::Test
test 'the side effects' do
- BCDD::Result.config.addon.disable!(:given)
+ Solid::Result.config.addon.disable!(:given)
class1a = Class.new do
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call
Given("this method won't exist as the default config is disabled")
@@ -16,7 +16,7 @@ def call
end
class2a = Class.new do
- include BCDD::Result::Expectations.mixin
+ include Solid::Result::Expectations.mixin
def call
Given("this method won't exist as the default config is disabled")
@@ -24,7 +24,7 @@ def call
end
class3a = Class.new do
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call
Given(msg: "this method won't exist as the default config is disabled")
@@ -32,7 +32,7 @@ def call
end
class4a = Class.new do
- include BCDD::Context::Expectations.mixin
+ include Solid::Output::Expectations.mixin
def call
Given(msg: "this method won't exist as the default config is disabled")
@@ -49,10 +49,10 @@ def call
assert_match(/undefined method.+Given/, error3a.message)
assert_match(/undefined method.+Given/, error4a.message)
- BCDD::Result.config.addon.enable!(:given)
+ Solid::Result.config.addon.enable!(:given)
class1b = Class.new do
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call
Given('this method will exist as the config is enabled by default')
@@ -60,7 +60,7 @@ def call
end
class2b = Class.new do
- include BCDD::Result::Expectations.mixin
+ include Solid::Result::Expectations.mixin
def call
Given('this method will exist as the config is enabled by default')
@@ -68,7 +68,7 @@ def call
end
class3b = Class.new do
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call
part1 = { part1: 'this method will exist' }
@@ -80,7 +80,7 @@ def call
end
class4b = Class.new do
- include BCDD::Context::Expectations.mixin
+ include Solid::Output::Expectations.mixin
def call
part1 = { part1: 'this method will exist' }
@@ -108,10 +108,10 @@ def call
end
test 'the overwriting of the default config' do
- BCDD::Result.config.addon.enable!(:given)
+ Solid::Result.config.addon.enable!(:given)
class1 = Class.new do
- include BCDD::Result.mixin(config: { addon: { given: false } })
+ include Solid::Result.mixin(config: { addon: { given: false } })
def call
Given("this method won't exist as the default config was overwritten")
@@ -119,7 +119,7 @@ def call
end
class2 = Class.new do
- include BCDD::Result::Expectations.mixin(config: { addon: { given: false } })
+ include Solid::Result::Expectations.mixin(config: { addon: { given: false } })
def call
Given("this method won't exist as the default config was overwritten")
@@ -127,7 +127,7 @@ def call
end
class3 = Class.new do
- include BCDD::Context.mixin(config: { addon: { given: false } })
+ include Solid::Output.mixin(config: { addon: { given: false } })
def call
Given(msg: "this method won't exist as the default config was overwritten")
@@ -135,7 +135,7 @@ def call
end
class4 = Class.new do
- include BCDD::Context::Expectations.mixin(config: { addon: { given: false } })
+ include Solid::Output::Expectations.mixin(config: { addon: { given: false } })
def call
Given(msg: "this method won't exist as the default config was overwritten")
diff --git a/test/bcdd/result/config/addon_test.rb b/test/solid/result/config/addon_test.rb
similarity index 64%
rename from test/bcdd/result/config/addon_test.rb
rename to test/solid/result/config/addon_test.rb
index b6e809ca..14c4559e 100644
--- a/test/bcdd/result/config/addon_test.rb
+++ b/test/solid/result/config/addon_test.rb
@@ -2,17 +2,17 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class AddonTest < Minitest::Test
AFFECTS = [
- 'BCDD::Result.mixin',
- 'BCDD::Context.mixin',
- 'BCDD::Result::Expectations.mixin',
- 'BCDD::Context::Expectations.mixin'
+ 'Solid::Result.mixin',
+ 'Solid::Output.mixin',
+ 'Solid::Result::Expectations.mixin',
+ 'Solid::Output::Expectations.mixin'
].freeze
test 'the switcher' do
- config = BCDD::Result.config.addon
+ config = Solid::Result.config.addon
assert_instance_of(Switcher, config)
diff --git a/test/bcdd/result/config/constant_alias/result_test.rb b/test/solid/result/config/constant_alias/result_test.rb
similarity index 57%
rename from test/bcdd/result/config/constant_alias/result_test.rb
rename to test/solid/result/config/constant_alias/result_test.rb
index cebf02a8..86b6c628 100644
--- a/test/bcdd/result/config/constant_alias/result_test.rb
+++ b/test/solid/result/config/constant_alias/result_test.rb
@@ -2,16 +2,16 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class ConstantAliasResultTest < Minitest::Test
test 'the side effects (Result)' do
assert_raises(NameError) { ::Result }
- BCDD::Result.config.constant_alias.enable!('Result')
+ Solid::Result.config.constant_alias.enable!('Result')
- assert_same(BCDD::Result, ::Result)
+ assert_same(Solid::Result, ::Result)
ensure
- BCDD::Result.config.constant_alias.disable!('Result')
+ Solid::Result.config.constant_alias.disable!('Result')
assert_raises(NameError) { ::Result }
end
diff --git a/test/bcdd/result/config/constant_alias_test.rb b/test/solid/result/config/constant_alias_test.rb
similarity index 80%
rename from test/bcdd/result/config/constant_alias_test.rb
rename to test/solid/result/config/constant_alias_test.rb
index e2378d94..b9efe4d8 100644
--- a/test/bcdd/result/config/constant_alias_test.rb
+++ b/test/solid/result/config/constant_alias_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class ConstantAliasTest < Minitest::Test
test 'the switcher' do
- config = BCDD::Result.config.constant_alias
+ config = Solid::Result.config.constant_alias
assert_instance_of(Switcher, config)
diff --git a/test/bcdd/result/config/feature/and_then_bang_test.rb b/test/solid/result/config/feature/and_then_bang_test.rb
similarity index 66%
rename from test/bcdd/result/config/feature/and_then_bang_test.rb
rename to test/solid/result/config/feature/and_then_bang_test.rb
index 32ba4752..4b2d501e 100644
--- a/test/bcdd/result/config/feature/and_then_bang_test.rb
+++ b/test/solid/result/config/feature/and_then_bang_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class FeatureAndThenBangTest < Minitest::Test
class AddR
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call(arg1, arg2)
Success(:ok, arg1 + arg2)
@@ -27,7 +27,7 @@ def self.perform(value)
end
class AddC
- include BCDD::Context.mixin
+ include Solid::Output.mixin
def call(number1:, number2:)
Success(:ok, number: number1 + number2)
@@ -49,7 +49,7 @@ def self.perform(number:)
end
test 'the side effects' do
- BCDD::Result.config.feature.enable!(:and_then!)
+ Solid::Result.config.feature.enable!(:and_then!)
result1 =
AddR1[1]
@@ -66,22 +66,22 @@ def self.perform(number:)
assert(result1.success?(:ok) && result1.value == 8)
assert(result2.success?(:ok) && result2.value == { number: 9 })
- BCDD::Result.config.feature.disable!(:and_then!)
+ Solid::Result.config.feature.disable!(:and_then!)
expected_error =
'You cannot use #and_then! as the feature is disabled. ' \
- 'Please use BCDD::Result.config.feature.enable!(:and_then!) to enable it.'
+ 'Please use Solid::Result.config.feature.enable!(:and_then!) to enable it.'
- assert_raises(BCDD::Result::Error::CallableAndThenDisabled, expected_error) { AddR1.call(1).and_then!(AddR2) }
- assert_raises(BCDD::Result::Error::CallableAndThenDisabled, expected_error) { AddC1[number: 2].and_then!(AddC2) }
+ 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
- BCDD::Result.config.feature.disable!(:and_then!)
+ Solid::Result.config.feature.disable!(:and_then!)
end
test 'the default method name' do
- BCDD::Result.config.feature.enable!(:and_then!)
+ Solid::Result.config.feature.enable!(:and_then!)
- BCDD::Result.config.and_then!.default_method_name_to_call = :perform
+ Solid::Result.config.and_then!.default_method_name_to_call = :perform
result1 = AddR1[1].and_then!(AddR3)
@@ -91,9 +91,9 @@ def self.perform(number:)
assert(result2.success?(:ok) && result2.value == { number: 6 })
ensure
- BCDD::Result.config.feature.disable!(:and_then!)
+ Solid::Result.config.feature.disable!(:and_then!)
- BCDD::Result.config.and_then!.default_method_name_to_call = :call
+ Solid::Result.config.and_then!.default_method_name_to_call = :call
end
end
end
diff --git a/test/bcdd/result/config/feature/event_logs_listener_test.rb b/test/solid/result/config/feature/event_logs_listener_test.rb
similarity index 79%
rename from test/bcdd/result/config/feature/event_logs_listener_test.rb
rename to test/solid/result/config/feature/event_logs_listener_test.rb
index 44e3145a..086b15af 100644
--- a/test/bcdd/result/config/feature/event_logs_listener_test.rb
+++ b/test/solid/result/config/feature/event_logs_listener_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class FeatureEventLogsListenerTest < Minitest::Test
- include BCDDResultEventLogAssertions
+ include SolidResultEventLogAssertions
class Division
- include BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
- BCDD::Result.event_logs(name: 'Division') do
+ Solid::Result.event_logs(name: 'Division') do
Given([arg1, arg2])
.and_then(:require_numbers)
.and_then(:check_for_zeros)
@@ -39,7 +39,7 @@ def divide((num1, num2))
end
module InspectListener
- extend BCDD::Result::EventLogs::Listener
+ extend Solid::Result::EventLogs::Listener
class << self
attr_reader :memo
@@ -79,9 +79,9 @@ def before_interruption(exception:, event_logs:)
end
test 'valid listener config (without event_logs interruption)' do
- original_listener = BCDD::Result.config.event_logs.listener
+ original_listener = Solid::Result.config.event_logs.listener
- BCDD::Result.config.event_logs.listener = InspectListener
+ Solid::Result.config.event_logs.listener = InspectListener
result = Division.new.call(10, 2)
@@ -105,13 +105,13 @@ def before_interruption(exception:, event_logs:)
assert_equal(result.event_logs, InspectListener.memo[:on_finish].first)
ensure
- BCDD::Result.config.event_logs.listener = original_listener
+ Solid::Result.config.event_logs.listener = original_listener
end
test 'valid listener config (with event_logs interruption)' do
- original_listener = BCDD::Result.config.event_logs.listener
+ original_listener = Solid::Result.config.event_logs.listener
- BCDD::Result.config.event_logs.listener = InspectListener
+ Solid::Result.config.event_logs.listener = InspectListener
assert_raises(ZeroDivisionError, 'divided by 0') { Division.new.call(10, 0) }
@@ -144,17 +144,17 @@ def before_interruption(exception:, event_logs:)
assert_equal(on_record, before_interruption[:event_logs][:records])
ensure
- BCDD::Result.config.event_logs.listener = original_listener
+ Solid::Result.config.event_logs.listener = original_listener
end
test 'invalid listener config' do
- err = assert_raises(ArgumentError) { BCDD::Result.config.event_logs.listener = 1 }
+ err = assert_raises(ArgumentError) { Solid::Result.config.event_logs.listener = 1 }
- assert_equal('1 must be a BCDD::Result::EventLogs::Listener', err.message)
+ assert_equal('1 must be a Solid::Result::EventLogs::Listener', err.message)
end
class BrokenListener
- include BCDD::Result::EventLogs::Listener
+ include Solid::Result::EventLogs::Listener
def initialize
raise 'broken'
@@ -162,11 +162,11 @@ def initialize
end
test 'broken listener' do
- original_listener = BCDD::Result.config.event_logs.listener
+ original_listener = Solid::Result.config.event_logs.listener
- BCDD::Result.config.event_logs.listener = BrokenListener
+ Solid::Result.config.event_logs.listener = BrokenListener
- stderr1 = /Fallback to BCDD::Result::EventLogs::Listener::Null because registered listener raised an exception:/
+ stderr1 = /Fallback to Solid::Result::EventLogs::Listener::Null because registered listener raised an exception:/
assert_output(nil, stderr1) { Division.new.call(1, 2) }
@@ -174,7 +174,7 @@ def initialize
assert_output(nil, stderr2) { Division.new.call(2, 2) }
ensure
- BCDD::Result.config.event_logs.listener = original_listener
+ Solid::Result.config.event_logs.listener = original_listener
end
end
end
diff --git a/test/bcdd/result/config/feature/event_logs_trace_id_test.rb b/test/solid/result/config/feature/event_logs_trace_id_test.rb
similarity index 56%
rename from test/bcdd/result/config/feature/event_logs_trace_id_test.rb
rename to test/solid/result/config/feature/event_logs_trace_id_test.rb
index 363880ed..5562c1f2 100644
--- a/test/bcdd/result/config/feature/event_logs_trace_id_test.rb
+++ b/test/solid/result/config/feature/event_logs_trace_id_test.rb
@@ -2,33 +2,33 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class FeatureEventLogsTraceIdTest < Minitest::Test
- include BCDDResultEventLogAssertions
+ include SolidResultEventLogAssertions
test 'valid trace_id config' do
- original_trace_id = BCDD::Result.config.event_logs.trace_id
+ original_trace_id = Solid::Result.config.event_logs.trace_id
random_number = rand
- BCDD::Result.config.event_logs.trace_id = -> { random_number }
+ Solid::Result.config.event_logs.trace_id = -> { random_number }
result = nil
- BCDD::Result.event_logs do
- result = BCDD::Result::Success(:ok, 1)
+ 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
- BCDD::Result.config.event_logs.trace_id = original_trace_id
+ Solid::Result.config.event_logs.trace_id = original_trace_id
end
test 'invalid trace_id config' do
err = assert_raises(ArgumentError) do
- BCDD::Result.config.event_logs.trace_id = 'invalid'
+ Solid::Result.config.event_logs.trace_id = 'invalid'
end
assert_equal('must be a lambda with arity 0', err.message)
diff --git a/test/solid/result/config/feature/expectations_test.rb b/test/solid/result/config/feature/expectations_test.rb
new file mode 100644
index 00000000..7f9ce2d7
--- /dev/null
+++ b/test/solid/result/config/feature/expectations_test.rb
@@ -0,0 +1,103 @@
+# 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
diff --git a/test/bcdd/result/config/feature_test.rb b/test/solid/result/config/feature_test.rb
similarity index 56%
rename from test/bcdd/result/config/feature_test.rb
rename to test/solid/result/config/feature_test.rb
index 950203c0..d0b542e3 100644
--- a/test/bcdd/result/config/feature_test.rb
+++ b/test/solid/result/config/feature_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class FeatureInstanceTest < Minitest::Test
test 'the switcher' do
- config = BCDD::Result.config.feature
+ config = Solid::Result.config.feature
assert_instance_of(Switcher, config)
@@ -13,13 +13,13 @@ class FeatureInstanceTest < Minitest::Test
{
expectations: {
enabled: true,
- affects: ['BCDD::Result::Expectations', 'BCDD::Context::Expectations']
+ affects: ['Solid::Result::Expectations', 'Solid::Output::Expectations']
},
event_logs: { enabled: true, affects: %w[
- BCDD::Result BCDD::Context BCDD::Result::Expectations BCDD::Context::Expectations
+ Solid::Result Solid::Output Solid::Result::Expectations Solid::Output::Expectations
] },
and_then!: { enabled: false, affects: %w[
- BCDD::Result BCDD::Context BCDD::Result::Expectations BCDD::Context::Expectations
+ Solid::Result Solid::Output Solid::Result::Expectations Solid::Output::Expectations
] }
},
config.options
diff --git a/test/bcdd/result/config/pattern_matching/nil_as_valid_value_checking_test.rb b/test/solid/result/config/pattern_matching/nil_as_valid_value_checking_test.rb
similarity index 50%
rename from test/bcdd/result/config/pattern_matching/nil_as_valid_value_checking_test.rb
rename to test/solid/result/config/pattern_matching/nil_as_valid_value_checking_test.rb
index 27a590ef..9e556c76 100644
--- a/test/bcdd/result/config/pattern_matching/nil_as_valid_value_checking_test.rb
+++ b/test/solid/result/config/pattern_matching/nil_as_valid_value_checking_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class PatternMatchingNilAsAValidValueCheckingTest < Minitest::Test
test 'the side effects' do
is_numeric = ->(v) do
@@ -22,55 +22,55 @@ class PatternMatchingNilAsAValidValueCheckingTest < Minitest::Test
end
class1a = Class.new do
- include BCDD::Result::Expectations.mixin(success: { ok: is_numeric })
+ include Solid::Result::Expectations.mixin(success: { ok: is_numeric })
def call; Success(:ok, 1); end
end
class1b = Class.new
- class1b.const_set(:Result, BCDD::Result::Expectations.new(success: { ok: is_numeric }))
+ 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 BCDD::Context::Expectations.mixin(success: { ok: is_hash_numeric })
+ 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, BCDD::Context::Expectations.new(success: { ok: is_hash_numeric }))
+ 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(BCDD::Result::Contract::Error::UnexpectedValue) { class1a.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class1b.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class1c.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class1d.new.call }
+ 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(BCDD::Result::Contract::Error::UnexpectedValue) { class1a::Result::Success(:ok, 1) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class1b::Result::Success(:ok, 1) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class1c::Result::Success(:ok, number: 1) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class1d::Result::Success(:ok, number: 1) }
+ 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) }
- BCDD::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
+ Solid::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
class2a = Class.new do
- include BCDD::Result::Expectations.mixin(success: { ok: is_numeric })
+ include Solid::Result::Expectations.mixin(success: { ok: is_numeric })
def call; Success(:ok, 1); end
end
class2b = Class.new
- class2b.const_set(:Result, BCDD::Result::Expectations.new(success: { ok: is_numeric }))
+ 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 BCDD::Context::Expectations.mixin(success: { ok: is_hash_numeric })
+ 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, BCDD::Context::Expectations.new(success: { ok: is_hash_numeric }))
+ 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 })
@@ -83,46 +83,46 @@ def call; Success(:ok, number: 1); end
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(BCDD::Result::Contract::Error::UnexpectedValue) { class2a::Result::Success(:ok, '1') }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class2b::Result::Success(:ok, '1') }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class2c::Result::Success(:ok, number: '1') }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class2d::Result::Success(:ok, 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
- BCDD::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
+ Solid::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
class3a = Class.new do
- include BCDD::Result::Expectations.mixin(success: { ok: is_numeric })
+ include Solid::Result::Expectations.mixin(success: { ok: is_numeric })
def call; Success(:ok, 1); end
end
class3b = Class.new
- class3b.const_set(:Result, BCDD::Result::Expectations.new(success: { ok: is_numeric }))
+ 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 BCDD::Context::Expectations.mixin(success: { ok: is_hash_numeric })
+ 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, BCDD::Context::Expectations.new(success: { ok: is_hash_numeric }))
+ 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(BCDD::Result::Contract::Error::UnexpectedValue) { class3a.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class3b.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class3c.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class3d.new.call }
+ 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(BCDD::Result::Contract::Error::UnexpectedValue) { class3a::Result::Success(:ok, 1) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class3b::Result::Success(:ok, 1) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class3c::Result::Success(:ok, number: 1) }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class3d::Result::Success(:ok, number: 1) }
+ 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
- BCDD::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
+ Solid::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
is_numeric = ->(v) do
case v
@@ -141,7 +141,7 @@ def call; Success(:ok, number: 1); end
end
class1 = Class.new do
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
config: { pattern_matching: { nil_as_valid_value_checking: false } },
success: { ok: is_numeric }
)
@@ -152,7 +152,7 @@ def call; Success(:ok, 1); end
class2 = Class.new
class2.const_set(
:Result,
- BCDD::Result::Expectations.new(
+ Solid::Result::Expectations.new(
config: { pattern_matching: { nil_as_valid_value_checking: false } },
success: { ok: is_numeric }
)
@@ -160,7 +160,7 @@ def call; Success(:ok, 1); end
class2.class_eval { def call; self.class.const_get(:Result, false)::Success(:ok, 1); end }
class3 = Class.new do
- include BCDD::Context::Expectations.mixin(
+ include Solid::Output::Expectations.mixin(
config: { pattern_matching: { nil_as_valid_value_checking: false } },
success: { ok: is_hash_numeric }
)
@@ -171,19 +171,19 @@ def call; Success(:ok, number: 1); end
class4 = Class.new
class4.const_set(
:Result,
- BCDD::Context::Expectations.new(
+ 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(BCDD::Result::Contract::Error::UnexpectedValue) { class1.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class2.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class3.new.call }
- assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) { class4.new.call }
+ 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
- BCDD::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
+ Solid::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
end
end
end
diff --git a/test/bcdd/result/config/pattern_matching_test.rb b/test/solid/result/config/pattern_matching_test.rb
similarity index 69%
rename from test/bcdd/result/config/pattern_matching_test.rb
rename to test/solid/result/config/pattern_matching_test.rb
index 712747f7..115b3e5f 100644
--- a/test/bcdd/result/config/pattern_matching_test.rb
+++ b/test/solid/result/config/pattern_matching_test.rb
@@ -2,10 +2,10 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class PatternMatchingTest < Minitest::Test
test 'the switcher' do
- config = BCDD::Result.config.pattern_matching
+ config = Solid::Result.config.pattern_matching
assert_instance_of(Switcher, config)
@@ -14,8 +14,8 @@ class PatternMatchingTest < Minitest::Test
nil_as_valid_value_checking: {
enabled: false,
affects: [
- 'BCDD::Result::Expectations',
- 'BCDD::Context::Expectations'
+ 'Solid::Result::Expectations',
+ 'Solid::Output::Expectations'
]
}
},
diff --git a/test/bcdd/result/config/switcher_test.rb b/test/solid/result/config/switcher_test.rb
similarity index 97%
rename from test/bcdd/result/config/switcher_test.rb
rename to test/solid/result/config/switcher_test.rb
index 4e559480..24eea0e0 100644
--- a/test/bcdd/result/config/switcher_test.rb
+++ b/test/solid/result/config/switcher_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class SwitcherTest < Minitest::Test
test '#inspect' do
switcher = Switcher.new(
@@ -13,7 +13,7 @@ class SwitcherTest < Minitest::Test
)
assert_equal(
- '#true, :bar=>false}>',
+ '#true, :bar=>false}>',
switcher.inspect
)
end
diff --git a/test/bcdd/result/config_test.rb b/test/solid/result/config_test.rb
similarity index 57%
rename from test/bcdd/result/config_test.rb
rename to test/solid/result/config_test.rb
index f15d4223..e5db889f 100644
--- a/test/bcdd/result/config_test.rb
+++ b/test/solid/result/config_test.rb
@@ -2,32 +2,32 @@
require 'test_helper'
-class BCDD::Result::Config
+class Solid::Result::Config
class Test < Minitest::Test
test '.instance' do
- assert BCDD::Result::Config.instance.is_a?(BCDD::Result::Config)
+ assert Solid::Result::Config.instance.is_a?(Solid::Result::Config)
- assert_same(BCDD::Result::Config.instance, BCDD::Result.config)
+ assert_same(Solid::Result::Config.instance, Solid::Result.config)
end
test '#addon' do
- assert_respond_to(BCDD::Result.config, :addon)
+ assert_respond_to(Solid::Result.config, :addon)
end
test '#feature' do
- assert_respond_to(BCDD::Result.config, :feature)
+ assert_respond_to(Solid::Result.config, :feature)
end
test '#constant_alias' do
- assert_respond_to(BCDD::Result.config, :constant_alias)
+ assert_respond_to(Solid::Result.config, :constant_alias)
end
test '#pattern_matching' do
- assert_respond_to(BCDD::Result.config, :pattern_matching)
+ assert_respond_to(Solid::Result.config, :pattern_matching)
end
test '#options' do
- assert_instance_of(Hash, BCDD::Result.config.options)
+ assert_instance_of(Hash, Solid::Result.config.options)
assert_equal(
%i[
@@ -36,46 +36,46 @@ class Test < Minitest::Test
feature
pattern_matching
],
- BCDD::Result.config.options.keys.sort
+ Solid::Result.config.options.keys.sort
)
- BCDD::Result.config.options.each_value do |switcher|
+ Solid::Result.config.options.each_value do |switcher|
assert_instance_of(Switcher, switcher)
end
end
test '#to_h' do
- config_values = BCDD::Result.config.to_h
+ 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])
- BCDD::Result.config.options.each do |key, switcher|
+ Solid::Result.config.options.each do |key, switcher|
assert_equal(switcher.to_h, config_values[key])
end
end
test '#inspect' do
assert_equal(
- '#:call}>',
- BCDD::Result.config.inspect
+ Solid::Result.config.inspect
)
end
test '#freeze' do
- event_logs_config_instance = BCDD::Result::EventLogs::Config.send(:new)
+ event_logs_config_instance = Solid::Result::EventLogs::Config.send(:new)
- BCDD::Result::EventLogs::Config.expects(:instance).returns(event_logs_config_instance)
+ Solid::Result::EventLogs::Config.expects(:instance).returns(event_logs_config_instance)
- instance = BCDD::Result::Config.send(:new)
+ instance = Solid::Result::Config.send(:new)
- assert_instance_of(BCDD::Result::Config, instance)
+ assert_instance_of(Solid::Result::Config, instance)
- refute_same(BCDD::Result::Config.instance, instance)
+ refute_same(Solid::Result::Config.instance, instance)
instance.freeze
diff --git a/test/bcdd/result/configuration_test.rb b/test/solid/result/configuration_test.rb
similarity index 59%
rename from test/bcdd/result/configuration_test.rb
rename to test/solid/result/configuration_test.rb
index d1585385..634d2b4e 100644
--- a/test/bcdd/result/configuration_test.rb
+++ b/test/solid/result/configuration_test.rb
@@ -2,20 +2,20 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class ConfigurationTest < Minitest::Test
test '.configuration' do
config_instance = Config.send(:new)
event_logs_config_instance = EventLogs::Config.send(:new)
- BCDD::Result.expects(:config).twice.returns(config_instance)
+ 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))
- BCDD::Result.configuration do |config|
+ Solid::Result.configuration do |config|
assert_same(config_instance, config)
config.addon.enable!(:continue)
@@ -31,23 +31,23 @@ class ConfigurationTest < Minitest::Test
test 'configuration freezing' do
String(ENV.fetch('TEST_CONFIG_FREEZING', nil)).match?(/true/i) or return
- refute(BCDD::Result.config.addon.enabled?(:continue))
+ refute(Solid::Result.config.addon.enabled?(:continue))
- BCDD::Result.configuration do |config|
- assert_same(BCDD::Result.config, config)
+ Solid::Result.configuration do |config|
+ assert_same(Solid::Result.config, config)
config.addon.enable!(:continue)
- refute_predicate(BCDD::Result.config, :frozen?)
+ refute_predicate(Solid::Result.config, :frozen?)
end
- assert(BCDD::Result.config.addon.enabled?(:continue))
+ assert(Solid::Result.config.addon.enabled?(:continue))
- assert_predicate(BCDD::Result.config, :frozen?)
+ assert_predicate(Solid::Result.config, :frozen?)
- assert_predicate(BCDD::Result.config.and_then!, :frozen?)
+ assert_predicate(Solid::Result.config.and_then!, :frozen?)
- assert_predicate(BCDD::Result.config.event_logs, :frozen?)
+ assert_predicate(Solid::Result.config.event_logs, :frozen?)
end
end
end
diff --git a/test/bcdd/result/contract/for_types_and_values_test.rb b/test/solid/result/contract/for_types_and_values_test.rb
similarity index 93%
rename from test/bcdd/result/contract/for_types_and_values_test.rb
rename to test/solid/result/contract/for_types_and_values_test.rb
index 251139b0..1407c65f 100644
--- a/test/bcdd/result/contract/for_types_and_values_test.rb
+++ b/test/solid/result/contract/for_types_and_values_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class Contract::ForTypesAndValuesTest < Minitest::Test
test '#type?' do
contract = Contract::ForTypesAndValues.new({ ok: Object }, nil)
diff --git a/test/bcdd/result/contract/interface_test.rb b/test/solid/result/contract/interface_test.rb
similarity index 91%
rename from test/bcdd/result/contract/interface_test.rb
rename to test/solid/result/contract/interface_test.rb
index 904b1223..0277ad8e 100644
--- a/test/bcdd/result/contract/interface_test.rb
+++ b/test/solid/result/contract/interface_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class Contract::InterfaceTest < Minitest::Test
test '#allowed_types' do
object = Object.new.extend(Contract::Interface)
@@ -29,7 +29,7 @@ class Contract::InterfaceTest < Minitest::Test
end
test '#type_and_value!' do
- data = BCDD::Result::Success(:ok, 'value').data
+ data = Solid::Result::Success(:ok, 'value').data
object = Object.new.extend(Contract::Interface)
diff --git a/test/bcdd/result/contract/nil_as_valid_value_checking_test.rb b/test/solid/result/contract/nil_as_valid_value_checking_test.rb
similarity index 58%
rename from test/bcdd/result/contract/nil_as_valid_value_checking_test.rb
rename to test/solid/result/contract/nil_as_valid_value_checking_test.rb
index 25702280..1eb055d3 100644
--- a/test/bcdd/result/contract/nil_as_valid_value_checking_test.rb
+++ b/test/solid/result/contract/nil_as_valid_value_checking_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class Contract::NiltAsValidValueCheckingTest < Minitest::Test
- test 'BCDD::Result::Expectations' do
+ test 'Solid::Result::Expectations' do
contract = {
ok: ->(value) {
case value
@@ -13,25 +13,25 @@ class Contract::NiltAsValidValueCheckingTest < Minitest::Test
}
}
- _Result1 = BCDD::Result::Expectations.new(success: contract)
+ _Result1 = Solid::Result::Expectations.new(success: contract)
assert_raises(Contract::Error::UnexpectedValue) do
_Result1::Success(:ok, 1)
end
- BCDD::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
+ Solid::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
- _Result2 = BCDD::Result::Expectations.new(success: contract)
+ _Result2 = Solid::Result::Expectations.new(success: contract)
result = _Result2::Success(:ok, 1)
assert result.success?(:ok)
assert_equal(1, result.value)
ensure
- BCDD::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
+ Solid::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
end
- test 'BCDD::Context::Expectations' do
+ test 'Solid::Output::Expectations' do
contract = {
ok: ->(value) {
case value
@@ -40,22 +40,22 @@ class Contract::NiltAsValidValueCheckingTest < Minitest::Test
}
}
- _Result1 = BCDD::Context::Expectations.new(success: contract)
+ _Result1 = Solid::Output::Expectations.new(success: contract)
assert_raises(Contract::Error::UnexpectedValue) do
_Result1::Success(:ok, number: 1)
end
- BCDD::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
+ Solid::Result.config.pattern_matching.enable!(:nil_as_valid_value_checking)
- _Result2 = BCDD::Context::Expectations.new(success: contract)
+ _Result2 = Solid::Output::Expectations.new(success: contract)
result = _Result2::Success(:ok, number: 1)
assert result.success?(:ok)
assert_equal({ number: 1 }, result.value)
ensure
- BCDD::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
+ Solid::Result.config.pattern_matching.disable!(:nil_as_valid_value_checking)
end
end
end
diff --git a/test/bcdd/result/data_test.rb b/test/solid/result/data_test.rb
similarity index 93%
rename from test/bcdd/result/data_test.rb
rename to test/solid/result/data_test.rb
index 3be556b7..b15ecf15 100644
--- a/test/bcdd/result/data_test.rb
+++ b/test/solid/result/data_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class DataTest < Minitest::Test
test '#kind' do
success = Success.new(type: :ok, value: 1)
@@ -65,12 +65,12 @@ class DataTest < Minitest::Test
failure = Failure.new(type: :err, value: 0)
assert_equal(
- '#',
+ '#',
success.data.inspect
)
assert_equal(
- '#',
+ '#',
failure.data.inspect
)
end
diff --git a/test/bcdd/result/error_test.rb b/test/solid/result/error_test.rb
similarity index 52%
rename from test/bcdd/result/error_test.rb
rename to test/solid/result/error_test.rb
index bc10b120..cf0b5c17 100644
--- a/test/bcdd/result/error_test.rb
+++ b/test/solid/result/error_test.rb
@@ -2,50 +2,50 @@
require 'test_helper'
-class BCDD::Result::ErrorTest < Minitest::Test
+class Solid::Result::ErrorTest < Minitest::Test
test '::Error' do
- assert BCDD::Result::Error < StandardError
+ assert Solid::Result::Error < StandardError
end
test '::Error.build' do
hash = [{}, { a: 1 }, { b: 2 }].sample
- error = BCDD::Result::Error.build(**hash)
+ error = Solid::Result::Error.build(**hash)
- assert_instance_of BCDD::Result::Error, error
+ assert_instance_of Solid::Result::Error, error
- assert_equal BCDD::Result::Error.new.message, error.message
+ assert_equal Solid::Result::Error.new.message, error.message
end
test '::Error::NotImplemented' do
- assert BCDD::Result::Error::NotImplemented < BCDD::Result::Error
+ assert Solid::Result::Error::NotImplemented < Solid::Result::Error
end
test '::Error::MissingTypeArgument' do
- assert BCDD::Result::Error::MissingTypeArgument < BCDD::Result::Error
+ assert Solid::Result::Error::MissingTypeArgument < Solid::Result::Error
assert_equal(
'A type (argument) is required to invoke the #on/#on_type method',
- BCDD::Result::Error::MissingTypeArgument.new.message
+ Solid::Result::Error::MissingTypeArgument.new.message
)
end
test '::Error::UnexpectedOutcome.build' do
- assert BCDD::Result::Error::UnexpectedOutcome < BCDD::Result::Error
+ 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 ' \
- 'BCDD::Result::Success or BCDD::Result::Failure',
- BCDD::Result::Error::UnexpectedOutcome.build(**error_input).message
+ 'Solid::Result::Success or Solid::Result::Failure',
+ Solid::Result::Error::UnexpectedOutcome.build(**error_input).message
)
end
test '::Error::InvalidResultSource.build' do
- assert BCDD::Result::Error::InvalidResultSource < BCDD::Result::Error
+ assert Solid::Result::Error::InvalidResultSource < Solid::Result::Error
- given_result = BCDD::Result::Success.new(type: :number, value: 3, source: 1)
+ given_result = Solid::Result::Success.new(type: :number, value: 3, source: 1)
error_input = { given_result: given_result, expected_source: 2 }
@@ -53,13 +53,13 @@ class BCDD::Result::ErrorTest < Minitest::Test
"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: #',
- BCDD::Result::Error::InvalidResultSource.build(**error_input).message
+ 'Given result: #',
+ Solid::Result::Error::InvalidResultSource.build(**error_input).message
)
end
test '::Error::InvalidSourceMethodArity.build' do
- assert BCDD::Result::Error::InvalidSourceMethodArity < BCDD::Result::Error
+ assert Solid::Result::Error::InvalidSourceMethodArity < Solid::Result::Error
source = Object.new
@@ -71,7 +71,7 @@ def source.do_something(_arg1, _arg2, _arg3); end
assert_equal(
'Object#do_something has unsupported arity (3). Expected 0..2',
- BCDD::Result::Error::InvalidSourceMethodArity.build(**error_input).message
+ Solid::Result::Error::InvalidSourceMethodArity.build(**error_input).message
)
end
end
diff --git a/test/bcdd/result/event_logs/disabled/with_source/flat_test.rb b/test/solid/result/event_logs/disabled/with_source/flat_test.rb
similarity index 84%
rename from test/bcdd/result/event_logs/disabled/with_source/flat_test.rb
rename to test/solid/result/event_logs/disabled/with_source/flat_test.rb
index cda35500..cf1aebdf 100644
--- a/test/bcdd/result/event_logs/disabled/with_source/flat_test.rb
+++ b/test/solid/result/event_logs/disabled/with_source/flat_test.rb
@@ -2,22 +2,22 @@
require 'test_helper'
-class BCDD::Result::EventLogsDisabledWithSourceFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsDisabledWithSourceFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
class Division
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
@@ -75,7 +75,7 @@ def divide((num1, num2))
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
@@ -87,7 +87,7 @@ def divide((num1, num2))
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise ::NotImplementedError }
+ Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.new.call(4, 2)
diff --git a/test/bcdd/result/event_logs/disabled/with_source/nested_test.rb b/test/solid/result/event_logs/disabled/with_source/nested_test.rb
similarity index 85%
rename from test/bcdd/result/event_logs/disabled/with_source/nested_test.rb
rename to test/solid/result/event_logs/disabled/with_source/nested_test.rb
index 5764ea37..d295f735 100644
--- a/test/bcdd/result/event_logs/disabled/with_source/nested_test.rb
+++ b/test/solid/result/event_logs/disabled/with_source/nested_test.rb
@@ -2,22 +2,22 @@
require 'test_helper'
-class BCDD::Result::EventLogsDisabledWithSourceNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsDisabledWithSourceNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
module Division
- extend self, BCDD::Result.mixin
+ extend self, Solid::Result.mixin
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
@@ -45,10 +45,10 @@ def divide((num1, num2))
end
class SumDivisionsByTwo
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call(*numbers)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
@@ -97,7 +97,7 @@ def divide_by_two(num)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
@@ -109,7 +109,7 @@ def divide_by_two(num)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
diff --git a/test/bcdd/result/event_logs/disabled/with_source/recursion_test.rb b/test/solid/result/event_logs/disabled/with_source/recursion_test.rb
similarity index 78%
rename from test/bcdd/result/event_logs/disabled/with_source/recursion_test.rb
rename to test/solid/result/event_logs/disabled/with_source/recursion_test.rb
index 27724b1a..23e9248b 100644
--- a/test/bcdd/result/event_logs/disabled/with_source/recursion_test.rb
+++ b/test/solid/result/event_logs/disabled/with_source/recursion_test.rb
@@ -2,22 +2,22 @@
require 'test_helper'
-class BCDD::Result::EventLogsDisabledWithSourceRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsDisabledWithSourceRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
class Fibonacci
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call(input)
- BCDD::Result.event_logs do
+ 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
diff --git a/test/bcdd/result/event_logs/disabled/without_source/flat_test.rb b/test/solid/result/event_logs/disabled/without_source/flat_test.rb
similarity index 69%
rename from test/bcdd/result/event_logs/disabled/without_source/flat_test.rb
rename to test/solid/result/event_logs/disabled/without_source/flat_test.rb
index 67795fd1..bb65d88a 100644
--- a/test/bcdd/result/event_logs/disabled/without_source/flat_test.rb
+++ b/test/solid/result/event_logs/disabled/without_source/flat_test.rb
@@ -2,22 +2,22 @@
require 'test_helper'
-class BCDD::Result::EventLogsDisabledWithoutSourceFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsDisabledWithoutSourceFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
module Division
extend self
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
@@ -27,20 +27,20 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num1 must be numeric')
- num2.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num2 must be numeric')
+ 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')
- BCDD::Result::Success(:ok, [num1, num2])
+ Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
- return BCDD::Result::Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
+ return Solid::Result::Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
- BCDD::Result::Success(:ok, numbers)
+ Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
- BCDD::Result::Success(:ok, num1 / num2)
+ Solid::Result::Success(:ok, num1 / num2)
end
end
@@ -75,7 +75,7 @@ def divide((num1, num2))
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
@@ -87,7 +87,7 @@ def divide((num1, num2))
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise ::NotImplementedError }
+ Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.call(4, 2)
diff --git a/test/bcdd/result/event_logs/disabled/without_source/nested_test.rb b/test/solid/result/event_logs/disabled/without_source/nested_test.rb
similarity index 72%
rename from test/bcdd/result/event_logs/disabled/without_source/nested_test.rb
rename to test/solid/result/event_logs/disabled/without_source/nested_test.rb
index f7140c23..dcadb993 100644
--- a/test/bcdd/result/event_logs/disabled/without_source/nested_test.rb
+++ b/test/solid/result/event_logs/disabled/without_source/nested_test.rb
@@ -2,20 +2,20 @@
require 'test_helper'
-class BCDD::Result::EventLogsDisabledWithoutSourceNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsDisabledWithoutSourceNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
class Division
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
@@ -25,20 +25,20 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num1 must be numeric')
- num2.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num2 must be numeric')
+ 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')
- BCDD::Result::Success(:ok, [num1, num2])
+ Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
- BCDD::Result::Success(:ok, numbers)
+ Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
- BCDD::Result::Success(:ok, num1 / num2)
+ Solid::Result::Success(:ok, num1 / num2)
end
end
@@ -46,13 +46,13 @@ module SumDivisionsByTwo
extend self
def call(*numbers)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
- BCDD::Result::Failure(:errors, divisions.select(&:failure?).map(&:value))
+ Solid::Result::Failure(:errors, divisions.select(&:failure?).map(&:value))
else
- BCDD::Result::Success(:sum, divisions.sum(&:value))
+ Solid::Result::Success(:sum, divisions.sum(&:value))
end
end
end
@@ -95,7 +95,7 @@ def divide_by_two(num)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
@@ -107,7 +107,7 @@ def divide_by_two(num)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
diff --git a/test/bcdd/result/event_logs/disabled/without_source/recursion_test.rb b/test/solid/result/event_logs/disabled/without_source/recursion_test.rb
similarity index 58%
rename from test/bcdd/result/event_logs/disabled/without_source/recursion_test.rb
rename to test/solid/result/event_logs/disabled/without_source/recursion_test.rb
index c695ca56..9735a04d 100644
--- a/test/bcdd/result/event_logs/disabled/without_source/recursion_test.rb
+++ b/test/solid/result/event_logs/disabled/without_source/recursion_test.rb
@@ -2,26 +2,26 @@
require 'test_helper'
-class BCDD::Result::EventLogsDisabledWithoutSourceRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsDisabledWithoutSourceRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
def setup
- BCDD::Result.config.feature.disable!(:event_logs)
+ Solid::Result.config.feature.disable!(:event_logs)
end
def teardown
- BCDD::Result.config.feature.enable!(:event_logs)
+ Solid::Result.config.feature.enable!(:event_logs)
end
module Fibonacci
extend self
def call(input)
- BCDD::Result.event_logs do
+ 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
- BCDD::Result::Success(:fibonacci, fibonacci)
+ Solid::Result::Success(:fibonacci, fibonacci)
end
end
end
@@ -29,11 +29,11 @@ def call(input)
private
def require_valid_number(input)
- input.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_input, 'input must be numeric')
+ input.is_a?(Numeric) or return Solid::Result::Failure(:invalid_input, 'input must be numeric')
- input.negative? and return BCDD::Result::Failure(:invalid_number, 'number cannot be negative')
+ input.negative? and return Solid::Result::Failure(:invalid_number, 'number cannot be negative')
- BCDD::Result::Success(:positive_number, input)
+ Solid::Result::Success(:positive_number, input)
end
end
diff --git a/test/bcdd/result/event_logs/duration_test.rb b/test/solid/result/event_logs/duration_test.rb
similarity index 64%
rename from test/bcdd/result/event_logs/duration_test.rb
rename to test/solid/result/event_logs/duration_test.rb
index 7e2df73c..5cc64abe 100644
--- a/test/bcdd/result/event_logs/duration_test.rb
+++ b/test/solid/result/event_logs/duration_test.rb
@@ -2,13 +2,13 @@
require 'test_helper'
-class BCDD::Result::EventLogsDurationTest < Minitest::Test
- Sleep = -> { sleep(0.1).then { BCDD::Result::Success(:ok) } }
+class Solid::Result::EventLogsDurationTest < Minitest::Test
+ Sleep = -> { sleep(0.1).then { Solid::Result::Success(:ok) } }
test '#duration' do
- return unless ENV['BCDD_RESULT_TEST_EVENT_LOGS_DURATION']
+ return unless ENV['Solid_RESULT_TEST_EVENT_LOGS_DURATION']
- result = BCDD::Result.event_logs do
+ result = Solid::Result.event_logs do
Sleep
.call
.and_then { Sleep.call }
diff --git a/test/solid/result/event_logs/enabled/not_been_started_test.rb b/test/solid/result/event_logs/enabled/not_been_started_test.rb
new file mode 100644
index 00000000..013710d6
--- /dev/null
+++ b/test/solid/result/event_logs/enabled/not_been_started_test.rb
@@ -0,0 +1,15 @@
+# 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
diff --git a/test/bcdd/result/event_logs/enabled/with_source/instance/flat_test.rb b/test/solid/result/event_logs/enabled/with_source/instance/flat_test.rb
similarity index 94%
rename from test/bcdd/result/event_logs/enabled/with_source/instance/flat_test.rb
rename to test/solid/result/event_logs/enabled/with_source/instance/flat_test.rb
index a7d44e7d..31dcac9a 100644
--- a/test/bcdd/result/event_logs/enabled/with_source/instance/flat_test.rb
+++ b/test/solid/result/event_logs/enabled/with_source/instance/flat_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithSourceInstanceFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithSourceInstanceFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Division
- include BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
- BCDD::Result.event_logs(name: 'Division', desc: 'divide two numbers') do
+ Solid::Result.event_logs(name: 'Division', desc: 'divide two numbers') do
require_numbers(arg1, arg2)
.and_then(:check_for_zeros)
.and_then(:divide)
@@ -76,7 +76,7 @@ def divide((num1, num2))
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
@@ -88,7 +88,7 @@ def divide((num1, num2))
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise ::NotImplementedError }
+ Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.new.call(4, 2)
diff --git a/test/bcdd/result/event_logs/enabled/with_source/instance/nested_test.rb b/test/solid/result/event_logs/enabled/with_source/instance/nested_test.rb
similarity index 91%
rename from test/bcdd/result/event_logs/enabled/with_source/instance/nested_test.rb
rename to test/solid/result/event_logs/enabled/with_source/instance/nested_test.rb
index ae56bfcf..9830349e 100644
--- a/test/bcdd/result/event_logs/enabled/with_source/instance/nested_test.rb
+++ b/test/solid/result/event_logs/enabled/with_source/instance/nested_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithSourceInstanceNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithSourceInstanceNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Division
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call(num1, num2)
- BCDD::Result.event_logs(name: 'Division') do
+ Solid::Result.event_logs(name: 'Division') do
validate_numbers(num1, num2)
.and_then(:divide, 'useless_arg')
end
@@ -25,16 +25,16 @@ def validate_numbers(num1, num2)
end
DetectZero = ->(number) do
- BCDD::Result.event_logs(name: 'DetectZero') do
- number.zero? ? BCDD::Result::Success(:is_zero) : BCDD::Result::Failure(:not_zero)
+ 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
- BCDD::Result.event_logs(name: 'CheckForZeros') do
+ Solid::Result.event_logs(name: 'CheckForZeros') do
DetectZero[num2].handle do |on|
- on.success { BCDD::Result::Success(:num2_is_zero) }
- on.failure { num1.zero? ? BCDD::Result::Success(:num1_is_zero) : BCDD::Result::Failure(:no_zeros) }
+ 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
@@ -49,10 +49,10 @@ def divide(numbers)
end
class SumDivisionsByTwo
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call(*numbers)
- BCDD::Result.event_logs(name: 'SumDivisionsByTwo') do
+ Solid::Result.event_logs(name: 'SumDivisionsByTwo') do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
@@ -101,7 +101,7 @@ def divide_by_two(num)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
@@ -113,7 +113,7 @@ def divide_by_two(num)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
diff --git a/test/bcdd/result/event_logs/enabled/with_source/instance/recursion_test.rb b/test/solid/result/event_logs/enabled/with_source/instance/recursion_test.rb
similarity index 84%
rename from test/bcdd/result/event_logs/enabled/with_source/instance/recursion_test.rb
rename to test/solid/result/event_logs/enabled/with_source/instance/recursion_test.rb
index 42950034..9df86b54 100644
--- a/test/bcdd/result/event_logs/enabled/with_source/instance/recursion_test.rb
+++ b/test/solid/result/event_logs/enabled/with_source/instance/recursion_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithSourceInstanceRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithSourceInstanceRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Fibonacci
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call(input)
- BCDD::Result.event_logs do
+ 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
diff --git a/test/bcdd/result/event_logs/enabled/with_source/singleton/flat_test.rb b/test/solid/result/event_logs/enabled/with_source/singleton/flat_test.rb
similarity index 87%
rename from test/bcdd/result/event_logs/enabled/with_source/singleton/flat_test.rb
rename to test/solid/result/event_logs/enabled/with_source/singleton/flat_test.rb
index f6b55a75..95fb2d2e 100644
--- a/test/bcdd/result/event_logs/enabled/with_source/singleton/flat_test.rb
+++ b/test/solid/result/event_logs/enabled/with_source/singleton/flat_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithSourceSingletonFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithSourceSingletonFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
module Division
- extend self, BCDD::Result.mixin
+ extend self, Solid::Result.mixin
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then(:validate_nonzero)
.and_then(:divide)
@@ -67,7 +67,7 @@ def divide((num1, num2))
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
@@ -79,7 +79,7 @@ def divide((num1, num2))
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise ::NotImplementedError }
+ Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.call(4, 2)
diff --git a/test/bcdd/result/event_logs/enabled/with_source/singleton/nested_test.rb b/test/solid/result/event_logs/enabled/with_source/singleton/nested_test.rb
similarity index 90%
rename from test/bcdd/result/event_logs/enabled/with_source/singleton/nested_test.rb
rename to test/solid/result/event_logs/enabled/with_source/singleton/nested_test.rb
index 05746441..bb10c8d1 100644
--- a/test/bcdd/result/event_logs/enabled/with_source/singleton/nested_test.rb
+++ b/test/solid/result/event_logs/enabled/with_source/singleton/nested_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithSourceSingletonNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithSourceSingletonNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
module CheckForZeros
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(numbers)
- BCDD::Result.event_logs(name: 'CheckForZeros') do
+ Solid::Result.event_logs(name: 'CheckForZeros') do
Given(numbers)
.and_then(:detect_zero, index: 1)
.and_then(:detect_zero, index: 0)
@@ -27,10 +27,10 @@ def detect_zero(numbers, ref)
end
module Division
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(num1, num2)
- BCDD::Result.event_logs(name: 'Division') do
+ Solid::Result.event_logs(name: 'Division') do
Given([num1, num2])
.and_then(:validate_numbers)
.and_then(:check_for_zeros)
@@ -61,10 +61,10 @@ def divide((num1, num2))
end
module SumDivisionsByTwo
- extend self, BCDD::Result.mixin(config: { addon: { continue: true } })
+ extend self, Solid::Result.mixin(config: { addon: { continue: true } })
def call(*numbers)
- BCDD::Result.event_logs(name: 'SumDivisionsByTwo') do
+ Solid::Result.event_logs(name: 'SumDivisionsByTwo') do
Given(numbers)
.and_then(:divide_numbers_by_two)
.and_then(:sum_divisions)
@@ -181,7 +181,7 @@ def sum_divisions(divisions)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
@@ -193,7 +193,7 @@ def sum_divisions(divisions)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
diff --git a/test/bcdd/result/event_logs/enabled/with_source/singleton/recursion_test.rb b/test/solid/result/event_logs/enabled/with_source/singleton/recursion_test.rb
similarity index 83%
rename from test/bcdd/result/event_logs/enabled/with_source/singleton/recursion_test.rb
rename to test/solid/result/event_logs/enabled/with_source/singleton/recursion_test.rb
index f969fc53..09c49a21 100644
--- a/test/bcdd/result/event_logs/enabled/with_source/singleton/recursion_test.rb
+++ b/test/solid/result/event_logs/enabled/with_source/singleton/recursion_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithSourceSingletonRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithSourceSingletonRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
module Fibonacci
- extend self, BCDD::Result.mixin
+ extend self, Solid::Result.mixin
def call(input)
- BCDD::Result.event_logs do
+ 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
diff --git a/test/bcdd/result/event_logs/enabled/without_source/instance/flat_test.rb b/test/solid/result/event_logs/enabled/without_source/instance/flat_test.rb
similarity index 71%
rename from test/bcdd/result/event_logs/enabled/without_source/instance/flat_test.rb
rename to test/solid/result/event_logs/enabled/without_source/instance/flat_test.rb
index 70b18278..b08db902 100644
--- a/test/bcdd/result/event_logs/enabled/without_source/instance/flat_test.rb
+++ b/test/solid/result/event_logs/enabled/without_source/instance/flat_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithoutSourceInstanceFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithoutSourceInstanceFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Division
- include BCDD::Result.mixin
+ include Solid::Result.mixin
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
@@ -19,20 +19,20 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num1 must be numeric')
- num2.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num2 must be numeric')
+ 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')
- BCDD::Result::Success(:ok, [num1, num2])
+ Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
- return BCDD::Result::Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
+ return Solid::Result::Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
- BCDD::Result::Success(:ok, numbers)
+ Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
- BCDD::Result::Success(:ok, num1 / num2)
+ Solid::Result::Success(:ok, num1 / num2)
end
end
@@ -67,7 +67,7 @@ def divide((num1, num2))
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.new.call(4, 0)
@@ -79,7 +79,7 @@ def divide((num1, num2))
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise ::NotImplementedError }
+ Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.new.call(4, 2)
diff --git a/test/bcdd/result/event_logs/enabled/without_source/instance/nested_test.rb b/test/solid/result/event_logs/enabled/without_source/instance/nested_test.rb
similarity index 75%
rename from test/bcdd/result/event_logs/enabled/without_source/instance/nested_test.rb
rename to test/solid/result/event_logs/enabled/without_source/instance/nested_test.rb
index bcdb89ff..eaf3dbd4 100644
--- a/test/bcdd/result/event_logs/enabled/without_source/instance/nested_test.rb
+++ b/test/solid/result/event_logs/enabled/without_source/instance/nested_test.rb
@@ -2,12 +2,12 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithoutSourceInstanceNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithoutSourceInstanceNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Division
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
@@ -17,32 +17,32 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num1 must be numeric')
- num2.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num2 must be numeric')
+ 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')
- BCDD::Result::Success(:ok, [num1, num2])
+ Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
- BCDD::Result::Success(:ok, numbers)
+ Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
- BCDD::Result::Success(:ok, num1 / num2)
+ Solid::Result::Success(:ok, num1 / num2)
end
end
class SumDivisionsByTwo
def call(*numbers)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
- BCDD::Result::Failure(:errors, divisions.select(&:failure?).map(&:value))
+ Solid::Result::Failure(:errors, divisions.select(&:failure?).map(&:value))
else
- BCDD::Result::Success(:sum, divisions.sum(&:value))
+ Solid::Result::Success(:sum, divisions.sum(&:value))
end
end
end
@@ -85,7 +85,7 @@ def divide_by_two(num)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.new.call(30, 20, '10')
@@ -97,7 +97,7 @@ def divide_by_two(num)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.new.call(30, 20, 10)
diff --git a/test/bcdd/result/event_logs/enabled/without_source/instance/recursion_test.rb b/test/solid/result/event_logs/enabled/without_source/instance/recursion_test.rb
similarity index 62%
rename from test/bcdd/result/event_logs/enabled/without_source/instance/recursion_test.rb
rename to test/solid/result/event_logs/enabled/without_source/instance/recursion_test.rb
index eebcdadf..f27d0f79 100644
--- a/test/bcdd/result/event_logs/enabled/without_source/instance/recursion_test.rb
+++ b/test/solid/result/event_logs/enabled/without_source/instance/recursion_test.rb
@@ -2,16 +2,16 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithoutSourceInstanceRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithoutSourceInstanceRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
class Fibonacci
def call(input)
- BCDD::Result.event_logs do
+ 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
- BCDD::Result::Success(:fibonacci, fibonacci)
+ Solid::Result::Success(:fibonacci, fibonacci)
end
end
end
@@ -19,11 +19,11 @@ def call(input)
private
def require_valid_number(input)
- input.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_input, 'input must be numeric')
+ input.is_a?(Numeric) or return Solid::Result::Failure(:invalid_input, 'input must be numeric')
- input.negative? and return BCDD::Result::Failure(:invalid_number, 'number cannot be negative')
+ input.negative? and return Solid::Result::Failure(:invalid_number, 'number cannot be negative')
- BCDD::Result::Success(:positive_number, input)
+ Solid::Result::Success(:positive_number, input)
end
end
diff --git a/test/bcdd/result/event_logs/enabled/without_source/singleton/flat_test.rb b/test/solid/result/event_logs/enabled/without_source/singleton/flat_test.rb
similarity index 71%
rename from test/bcdd/result/event_logs/enabled/without_source/singleton/flat_test.rb
rename to test/solid/result/event_logs/enabled/without_source/singleton/flat_test.rb
index 3e53ed50..65d3d033 100644
--- a/test/bcdd/result/event_logs/enabled/without_source/singleton/flat_test.rb
+++ b/test/solid/result/event_logs/enabled/without_source/singleton/flat_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithoutSourceSingletonFlatTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithoutSourceSingletonFlatTest < Minitest::Test
+ include SolidResultEventLogAssertions
module Division
extend self
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
@@ -19,20 +19,20 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num1 must be numeric')
- num2.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num2 must be numeric')
+ 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')
- BCDD::Result::Success(:ok, [num1, num2])
+ Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
- return BCDD::Result::Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
+ return Solid::Result::Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
- BCDD::Result::Success(:ok, numbers)
+ Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
- BCDD::Result::Success(:ok, num1 / num2)
+ Solid::Result::Success(:ok, num1 / num2)
end
end
@@ -67,7 +67,7 @@ def divide((num1, num2))
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = Division.call(4, 0)
@@ -79,7 +79,7 @@ def divide((num1, num2))
test 'an exception handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise ::NotImplementedError }
+ Solid::Result.event_logs { raise ::NotImplementedError }
end
result1 = Division.call(4, 2)
diff --git a/test/bcdd/result/event_logs/enabled/without_source/singleton/nested_test.rb b/test/solid/result/event_logs/enabled/without_source/singleton/nested_test.rb
similarity index 75%
rename from test/bcdd/result/event_logs/enabled/without_source/singleton/nested_test.rb
rename to test/solid/result/event_logs/enabled/without_source/singleton/nested_test.rb
index 332138d2..426874b5 100644
--- a/test/bcdd/result/event_logs/enabled/without_source/singleton/nested_test.rb
+++ b/test/solid/result/event_logs/enabled/without_source/singleton/nested_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithoutSourceSingletonNestedTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithoutSourceSingletonNestedTest < Minitest::Test
+ include SolidResultEventLogAssertions
module Division
extend self
def call(num1, num2)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
validate_numbers(num1, num2)
.and_then { |numbers| validate_nonzero(numbers) }
.and_then { |numbers| divide(numbers) }
@@ -19,20 +19,20 @@ def call(num1, num2)
private
def validate_numbers(num1, num2)
- num1.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num1 must be numeric')
- num2.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_arg, 'num2 must be numeric')
+ 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')
- BCDD::Result::Success(:ok, [num1, num2])
+ Solid::Result::Success(:ok, [num1, num2])
end
def validate_nonzero(numbers)
return Failure(:division_by_zero, 'num2 cannot be zero') if numbers.last.zero?
- BCDD::Result::Success(:ok, numbers)
+ Solid::Result::Success(:ok, numbers)
end
def divide((num1, num2))
- BCDD::Result::Success(:ok, num1 / num2)
+ Solid::Result::Success(:ok, num1 / num2)
end
end
@@ -40,13 +40,13 @@ module SumDivisionsByTwo
extend self
def call(*numbers)
- BCDD::Result.event_logs do
+ Solid::Result.event_logs do
divisions = numbers.map { divide_by_two(_1) }
if divisions.any?(&:failure?)
- BCDD::Result::Failure(:errors, divisions.select(&:failure?).map(&:value))
+ Solid::Result::Failure(:errors, divisions.select(&:failure?).map(&:value))
else
- BCDD::Result::Success(:sum, divisions.sum(&:value))
+ Solid::Result::Success(:sum, divisions.sum(&:value))
end
end
end
@@ -89,7 +89,7 @@ def divide_by_two(num)
test 'the standard error handling' do
assert_raises(ZeroDivisionError) do
- BCDD::Result.event_logs { 2 / 0 }
+ Solid::Result.event_logs { 2 / 0 }
end
result1 = SumDivisionsByTwo.call(30, 20, '10')
@@ -101,7 +101,7 @@ def divide_by_two(num)
test 'an exception error handling' do
assert_raises(NotImplementedError) do
- BCDD::Result.event_logs { raise NotImplementedError }
+ Solid::Result.event_logs { raise NotImplementedError }
end
result1 = SumDivisionsByTwo.call(30, 20, 10)
diff --git a/test/bcdd/result/event_logs/enabled/without_source/singleton/recursion_test.rb b/test/solid/result/event_logs/enabled/without_source/singleton/recursion_test.rb
similarity index 62%
rename from test/bcdd/result/event_logs/enabled/without_source/singleton/recursion_test.rb
rename to test/solid/result/event_logs/enabled/without_source/singleton/recursion_test.rb
index f6053b2b..a68e8a04 100644
--- a/test/bcdd/result/event_logs/enabled/without_source/singleton/recursion_test.rb
+++ b/test/solid/result/event_logs/enabled/without_source/singleton/recursion_test.rb
@@ -2,18 +2,18 @@
require 'test_helper'
-class BCDD::Result::EventLogsEnabledWithoutSourceSingletonRecursionTest < Minitest::Test
- include BCDDResultEventLogAssertions
+class Solid::Result::EventLogsEnabledWithoutSourceSingletonRecursionTest < Minitest::Test
+ include SolidResultEventLogAssertions
module Fibonacci
extend self
def call(input)
- BCDD::Result.event_logs do
+ 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
- BCDD::Result::Success(:fibonacci, fibonacci)
+ Solid::Result::Success(:fibonacci, fibonacci)
end
end
end
@@ -21,11 +21,11 @@ def call(input)
private
def require_valid_number(input)
- input.is_a?(Numeric) or return BCDD::Result::Failure(:invalid_input, 'input must be numeric')
+ input.is_a?(Numeric) or return Solid::Result::Failure(:invalid_input, 'input must be numeric')
- input.negative? and return BCDD::Result::Failure(:invalid_number, 'number cannot be negative')
+ input.negative? and return Solid::Result::Failure(:invalid_number, 'number cannot be negative')
- BCDD::Result::Success(:positive_number, input)
+ Solid::Result::Success(:positive_number, input)
end
end
diff --git a/test/bcdd/result/event_logs/listener_test.rb b/test/solid/result/event_logs/listener_test.rb
similarity index 94%
rename from test/bcdd/result/event_logs/listener_test.rb
rename to test/solid/result/event_logs/listener_test.rb
index 345b9235..69d87666 100644
--- a/test/bcdd/result/event_logs/listener_test.rb
+++ b/test/solid/result/event_logs/listener_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-module BCDD::Result::EventLogs
+module Solid::Result::EventLogs
class ListenerTest < Minitest::Test
module ModuleListener
extend Listener
diff --git a/test/bcdd/result/event_logs/listeners_test.rb b/test/solid/result/event_logs/listeners_test.rb
similarity index 75%
rename from test/bcdd/result/event_logs/listeners_test.rb
rename to test/solid/result/event_logs/listeners_test.rb
index 0a6622fd..e5f24b42 100644
--- a/test/bcdd/result/event_logs/listeners_test.rb
+++ b/test/solid/result/event_logs/listeners_test.rb
@@ -2,12 +2,12 @@
require 'test_helper'
-module BCDD::Result::EventLogs
+module Solid::Result::EventLogs
class ListenersTest < Minitest::Test
- include BCDDResultEventLogAssertions
+ include SolidResultEventLogAssertions
module AroundListener
- extend BCDD::Result::EventLogs::Listener
+ extend Solid::Result::EventLogs::Listener
def self.around_and_then?
true
@@ -39,7 +39,7 @@ def around_and_then(scope:, and_then:)
end
module InspectListener
- extend BCDD::Result::EventLogs::Listener
+ extend Solid::Result::EventLogs::Listener
class << self
attr_reader :memo
@@ -67,10 +67,10 @@ def before_interruption(exception:, event_logs:)
end
class Division
- include BCDD::Result.mixin(config: { addon: { continue: true } })
+ include Solid::Result.mixin(config: { addon: { continue: true } })
def call(arg1, arg2)
- BCDD::Result.event_logs(name: 'Division') do
+ Solid::Result.event_logs(name: 'Division') do
Given([arg1, arg2])
.and_then(:require_numbers)
.and_then(:check_for_zeros)
@@ -99,9 +99,9 @@ def divide((num1, num2))
end
test 'one listener (without interruption)' do
- original_listener = BCDD::Result.config.event_logs.listener
+ original_listener = Solid::Result.config.event_logs.listener
- BCDD::Result.config.event_logs.listener = Listeners[InspectListener]
+ Solid::Result.config.event_logs.listener = Listeners[InspectListener]
result = Division.new.call(10, 2)
@@ -115,13 +115,13 @@ def divide((num1, num2))
assert_equal(result.event_logs, InspectListener.memo[:on_finish].first)
ensure
- BCDD::Result.config.event_logs.listener = original_listener
+ Solid::Result.config.event_logs.listener = original_listener
end
test 'multiple listeners' do
- original_listener = BCDD::Result.config.event_logs.listener
+ original_listener = Solid::Result.config.event_logs.listener
- BCDD::Result.config.event_logs.listener = Listeners[InspectListener, AroundListener]
+ Solid::Result.config.event_logs.listener = Listeners[InspectListener, AroundListener]
result = Division.new.call(10, 2)
@@ -148,13 +148,13 @@ def divide((num1, num2))
assert_equal(result.event_logs, InspectListener.memo[:on_finish].first)
ensure
- BCDD::Result.config.event_logs.listener = original_listener
+ Solid::Result.config.event_logs.listener = original_listener
end
test 'multiple listeners (with interruption)' do
- original_listener = BCDD::Result.config.event_logs.listener
+ original_listener = Solid::Result.config.event_logs.listener
- BCDD::Result.config.event_logs.listener = Listeners[InspectListener, AroundListener]
+ Solid::Result.config.event_logs.listener = Listeners[InspectListener, AroundListener]
assert_raises(ZeroDivisionError, 'divided by 0') { Division.new.call(10, 0) }
@@ -166,11 +166,11 @@ def divide((num1, num2))
assert_equal(on_record, before_interruption[:event_logs][:records])
ensure
- BCDD::Result.config.event_logs.listener = original_listener
+ Solid::Result.config.event_logs.listener = original_listener
end
module AroundAndThenListener
- extend BCDD::Result::EventLogs::Listener
+ extend Solid::Result::EventLogs::Listener
def self.around_and_then?
true
@@ -178,7 +178,7 @@ def self.around_and_then?
end
test 'multiple around_and_then? listeners' do
- original_listener = BCDD::Result.config.event_logs.listener
+ original_listener = Solid::Result.config.event_logs.listener
assert_raises ArgumentError, 'Only one listener can have around_and_then? == true' do
Listeners[
@@ -188,11 +188,11 @@ def self.around_and_then?
]
end
ensure
- BCDD::Result.config.event_logs.listener = original_listener
+ Solid::Result.config.event_logs.listener = original_listener
end
module AroundEventLogsListener
- extend BCDD::Result::EventLogs::Listener
+ extend Solid::Result::EventLogs::Listener
def self.around_event_logs?
true
@@ -200,7 +200,7 @@ def self.around_event_logs?
end
test 'multiple around_event_logs? listeners' do
- original_listener = BCDD::Result.config.event_logs.listener
+ original_listener = Solid::Result.config.event_logs.listener
assert_raises ArgumentError, 'only one listener can have around_event_logs? == true' do
Listeners[
@@ -210,27 +210,27 @@ def self.around_event_logs?
]
end
ensure
- BCDD::Result.config.event_logs.listener = original_listener
+ Solid::Result.config.event_logs.listener = original_listener
end
test 'invalid argument (empty)' do
- original_listener = BCDD::Result.config.event_logs.listener
+ original_listener = Solid::Result.config.event_logs.listener
- assert_raises ArgumentError, 'listeners must be a list of BCDD::Result::EventLogs::Listener' do
+ assert_raises ArgumentError, 'listeners must be a list of Solid::Result::EventLogs::Listener' do
Listeners[]
end
ensure
- BCDD::Result.config.event_logs.listener = original_listener
+ Solid::Result.config.event_logs.listener = original_listener
end
test 'invalid argument (non Listener)' do
- original_listener = BCDD::Result.config.event_logs.listener
+ original_listener = Solid::Result.config.event_logs.listener
- assert_raises ArgumentError, 'listeners must be a list of BCDD::Result::EventLogs::Listener' do
+ assert_raises ArgumentError, 'listeners must be a list of Solid::Result::EventLogs::Listener' do
Listeners[String]
end
ensure
- BCDD::Result.config.event_logs.listener = original_listener
+ Solid::Result.config.event_logs.listener = original_listener
end
end
end
diff --git a/test/bcdd/result/event_logs/tree_test.rb b/test/solid/result/event_logs/tree_test.rb
similarity index 94%
rename from test/bcdd/result/event_logs/tree_test.rb
rename to test/solid/result/event_logs/tree_test.rb
index 0551299c..42963b5b 100644
--- a/test/bcdd/result/event_logs/tree_test.rb
+++ b/test/solid/result/event_logs/tree_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-module BCDD::Result::EventLogs
+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)
+ assert_equal('#', tree.root.inspect)
end
test '#root_value' do
@@ -28,7 +28,7 @@ class TreeTest < Minitest::Test
assert_equal(:child, tree.parent_value)
- assert_equal('#', tree.current.parent.inspect)
+ assert_equal('#', tree.current.parent.inspect)
end
test '#current_value' do
@@ -38,7 +38,7 @@ class TreeTest < Minitest::Test
assert_equal('grandchild', tree.current_value)
- assert_equal('#', tree.current.inspect)
+ assert_equal('#', tree.current.inspect)
end
test '#insert' do
diff --git a/test/bcdd/result/event_logs_test.rb b/test/solid/result/event_logs_test.rb
similarity index 52%
rename from test/bcdd/result/event_logs_test.rb
rename to test/solid/result/event_logs_test.rb
index dfe2d273..9cb6461a 100644
--- a/test/bcdd/result/event_logs_test.rb
+++ b/test/solid/result/event_logs_test.rb
@@ -2,15 +2,15 @@
require 'test_helper'
-class BCDD::Result::EventLogsTest < Minitest::Test
+class Solid::Result::EventLogsTest < Minitest::Test
test 'the unexpected outcome error' do
- err = assert_raises(BCDD::Result::Error::UnexpectedOutcome) do
- BCDD::Result.event_logs { 1 }
+ 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 ' \
- 'BCDD::Result::Success or BCDD::Result::Failure',
+ 'Solid::Result::Success or Solid::Result::Failure',
err.message
)
end
diff --git a/test/bcdd/result/expectations/mixin_constants_test.rb b/test/solid/result/expectations/mixin_constants_test.rb
similarity index 59%
rename from test/bcdd/result/expectations/mixin_constants_test.rb
rename to test/solid/result/expectations/mixin_constants_test.rb
index fd4b3376..ca47c6b3 100644
--- a/test/bcdd/result/expectations/mixin_constants_test.rb
+++ b/test/solid/result/expectations/mixin_constants_test.rb
@@ -2,24 +2,24 @@
require 'test_helper'
-class BCDD::Result::Expectations::MixinConstantsTest < Minitest::Test
+class Solid::Result::Expectations::MixinConstantsTest < Minitest::Test
class IncludingInClass
- include BCDD::Result::Expectations.mixin
+ include Solid::Result::Expectations.mixin
end
module IncludingInModule
- include BCDD::Result::Expectations.mixin
+ include Solid::Result::Expectations.mixin
end
class ExtendingInClass
- extend BCDD::Result::Expectations.mixin
+ extend Solid::Result::Expectations.mixin
end
module ExtendingInModule
- extend BCDD::Result::Expectations.mixin
+ extend Solid::Result::Expectations.mixin
end
- test 'BCDD::Result::Expectations.mixin sets a constant in all classes/modules' do
+ 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)
diff --git a/test/bcdd/result/expectations/with_source/failure/type/invalid_type_test.rb b/test/solid/result/expectations/with_source/failure/type/invalid_type_test.rb
similarity index 81%
rename from test/bcdd/result/expectations/with_source/failure/type/invalid_type_test.rb
rename to test/solid/result/expectations/with_source/failure/type/invalid_type_test.rb
index 46ea2572..f844dda1 100644
--- a/test/bcdd/result/expectations/with_source/failure/type/invalid_type_test.rb
+++ b/test/solid/result/expectations/with_source/failure/type/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceFailureInvalidTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceFailureInvalidTypeTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
failure: :err
)
@@ -35,7 +35,7 @@ def divide((number1, number2))
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call('10', 2)
end
diff --git a/test/bcdd/result/expectations/with_source/failure/type_and_value/invalid_type_test.rb b/test/solid/result/expectations/with_source/failure/type_and_value/invalid_type_test.rb
similarity index 81%
rename from test/bcdd/result/expectations/with_source/failure/type_and_value/invalid_type_test.rb
rename to test/solid/result/expectations/with_source/failure/type_and_value/invalid_type_test.rb
index c157329e..66e9ceeb 100644
--- a/test/bcdd/result/expectations/with_source/failure/type_and_value/invalid_type_test.rb
+++ b/test/solid/result/expectations/with_source/failure/type_and_value/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceFailureInvalidTypeAndValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceFailureInvalidTypeAndValueTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
failure: {
err1: String,
err2: String
@@ -38,7 +38,7 @@ def divide((number1, number2))
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/result/expectations/with_source/failure/type_and_value/invalid_value_test.rb b/test/solid/result/expectations/with_source/failure/type_and_value/invalid_value_test.rb
similarity index 76%
rename from test/bcdd/result/expectations/with_source/failure/type_and_value/invalid_value_test.rb
rename to test/solid/result/expectations/with_source/failure/type_and_value/invalid_value_test.rb
index bd29aa87..75d11ca8 100644
--- a/test/bcdd/result/expectations/with_source/failure/type_and_value/invalid_value_test.rb
+++ b/test/solid/result/expectations/with_source/failure/type_and_value/invalid_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
failure: {
invalid_arg: String,
division_by_zero: String
@@ -22,7 +22,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/result/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb b/test/solid/result/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb
similarity index 79%
rename from test/bcdd/result/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb
rename to test/solid/result/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb
index 7c0f7daf..c4f32cf0 100644
--- a/test/bcdd/result/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb
+++ b/test/solid/result/expectations/with_source/failure/type_and_value/pattern_matching_error_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
failure: {
invalid_arg: String,
division_by_zero: ->(value) do
@@ -26,7 +26,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 0)
end
diff --git a/test/bcdd/result/expectations/with_source/failure/type_and_value_test.rb b/test/solid/result/expectations/with_source/failure/type_and_value_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/with_source/failure/type_and_value_test.rb
rename to test/solid/result/expectations/with_source/failure/type_and_value_test.rb
index 54e5bba5..8d87f4f0 100644
--- a/test/bcdd/result/expectations/with_source/failure/type_and_value_test.rb
+++ b/test/solid/result/expectations/with_source/failure/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceFailureTypeAndValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceFailureTypeAndValueTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
failure: {
invalid_arg: String,
division_by_zero: ->(value) { value.is_a?(String) }
@@ -78,7 +78,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -91,11 +91,11 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
@@ -113,13 +113,13 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -137,19 +137,19 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/with_source/failure/type_test.rb b/test/solid/result/expectations/with_source/failure/type_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/with_source/failure/type_test.rb
rename to test/solid/result/expectations/with_source/failure/type_test.rb
index 58b4bea5..1c082484 100644
--- a/test/bcdd/result/expectations/with_source/failure/type_test.rb
+++ b/test/solid/result/expectations/with_source/failure/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceFailureTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceFailureTypeTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
failure: :err
)
@@ -75,7 +75,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -88,11 +88,11 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
@@ -110,13 +110,13 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -134,7 +134,7 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err = assert_raises(BCDD::Result::Error::UnhandledTypes) 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
diff --git a/test/bcdd/result/expectations/with_source/failure/types/invalid_type_test.rb b/test/solid/result/expectations/with_source/failure/types/invalid_type_test.rb
similarity index 81%
rename from test/bcdd/result/expectations/with_source/failure/types/invalid_type_test.rb
rename to test/solid/result/expectations/with_source/failure/types/invalid_type_test.rb
index c47d94d0..6c162a5b 100644
--- a/test/bcdd/result/expectations/with_source/failure/types/invalid_type_test.rb
+++ b/test/solid/result/expectations/with_source/failure/types/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceFailureInvalidTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceFailureInvalidTypesTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
failure: %i[err1 err2]
)
@@ -35,7 +35,7 @@ def divide((number1, number2))
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/result/expectations/with_source/failure/types_test.rb b/test/solid/result/expectations/with_source/failure/types_test.rb
similarity index 83%
rename from test/bcdd/result/expectations/with_source/failure/types_test.rb
rename to test/solid/result/expectations/with_source/failure/types_test.rb
index 4d692880..d5e880f1 100644
--- a/test/bcdd/result/expectations/with_source/failure/types_test.rb
+++ b/test/solid/result/expectations/with_source/failure/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceFailureTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceFailureTypesTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
failure: %i[invalid_arg division_by_zero]
)
@@ -75,7 +75,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -88,15 +88,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -119,19 +119,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -154,25 +154,25 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/with_source/success/type/invalid_type_test.rb b/test/solid/result/expectations/with_source/success/type/invalid_type_test.rb
similarity index 75%
rename from test/bcdd/result/expectations/with_source/success/type/invalid_type_test.rb
rename to test/solid/result/expectations/with_source/success/type/invalid_type_test.rb
index a3033f25..69388a65 100644
--- a/test/bcdd/result/expectations/with_source/success/type/invalid_type_test.rb
+++ b/test/solid/result/expectations/with_source/success/type/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessInvalidTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessInvalidTypeTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: :ok
)
@@ -19,7 +19,7 @@ def call(arg1, arg2)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/result/expectations/with_source/success/type_and_value/invalid_type_test.rb b/test/solid/result/expectations/with_source/success/type_and_value/invalid_type_test.rb
similarity index 76%
rename from test/bcdd/result/expectations/with_source/success/type_and_value/invalid_type_test.rb
rename to test/solid/result/expectations/with_source/success/type_and_value/invalid_type_test.rb
index 789d0139..95f6c902 100644
--- a/test/bcdd/result/expectations/with_source/success/type_and_value/invalid_type_test.rb
+++ b/test/solid/result/expectations/with_source/success/type_and_value/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: {
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
}
@@ -21,7 +21,7 @@ def call(arg1, arg2)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/result/expectations/with_source/success/type_and_value/invalid_value_test.rb b/test/solid/result/expectations/with_source/success/type_and_value/invalid_value_test.rb
similarity index 76%
rename from test/bcdd/result/expectations/with_source/success/type_and_value/invalid_value_test.rb
rename to test/solid/result/expectations/with_source/success/type_and_value/invalid_value_test.rb
index a876de1b..4d32e3de 100644
--- a/test/bcdd/result/expectations/with_source/success/type_and_value/invalid_value_test.rb
+++ b/test/solid/result/expectations/with_source/success/type_and_value/invalid_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: {
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
}
@@ -21,7 +21,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/result/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb b/test/solid/result/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb
similarity index 78%
rename from test/bcdd/result/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb
rename to test/solid/result/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb
index b56cc16d..e897d44e 100644
--- a/test/bcdd/result/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb
+++ b/test/solid/result/expectations/with_source/success/type_and_value/pattern_matching_error_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: {
division_completed: ->(value) do
case value
@@ -25,7 +25,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/result/expectations/with_source/success/type_and_value_test.rb b/test/solid/result/expectations/with_source/success/type_and_value_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/with_source/success/type_and_value_test.rb
rename to test/solid/result/expectations/with_source/success/type_and_value_test.rb
index 54a4c2b3..d85f4a05 100644
--- a/test/bcdd/result/expectations/with_source/success/type_and_value_test.rb
+++ b/test/solid/result/expectations/with_source/success/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessTypeAndValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessTypeAndValueTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: {
numbers: Array,
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
@@ -77,7 +77,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -90,11 +90,11 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
@@ -112,13 +112,13 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -136,19 +136,19 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/with_source/success/type_test.rb b/test/solid/result/expectations/with_source/success/type_test.rb
similarity index 85%
rename from test/bcdd/result/expectations/with_source/success/type_test.rb
rename to test/solid/result/expectations/with_source/success/type_test.rb
index b285a8de..1296a098 100644
--- a/test/bcdd/result/expectations/with_source/success/type_test.rb
+++ b/test/solid/result/expectations/with_source/success/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessTypeTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: :ok
)
@@ -74,7 +74,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:numbers)
end
@@ -87,11 +87,11 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -109,7 +109,7 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -122,7 +122,7 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err = assert_raises(BCDD::Result::Error::UnhandledTypes) 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
diff --git a/test/bcdd/result/expectations/with_source/success/types/invalid_type_test.rb b/test/solid/result/expectations/with_source/success/types/invalid_type_test.rb
similarity index 82%
rename from test/bcdd/result/expectations/with_source/success/types/invalid_type_test.rb
rename to test/solid/result/expectations/with_source/success/types/invalid_type_test.rb
index 85f59f1f..af0979cd 100644
--- a/test/bcdd/result/expectations/with_source/success/types/invalid_type_test.rb
+++ b/test/solid/result/expectations/with_source/success/types/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessInvalidTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessInvalidTypesTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: %i[ok1 ok2 ok3]
)
@@ -35,7 +35,7 @@ def divide((number1, number2))
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/result/expectations/with_source/success/types_test.rb b/test/solid/result/expectations/with_source/success/types_test.rb
similarity index 83%
rename from test/bcdd/result/expectations/with_source/success/types_test.rb
rename to test/solid/result/expectations/with_source/success/types_test.rb
index 7c0486be..e6208c98 100644
--- a/test/bcdd/result/expectations/with_source/success/types_test.rb
+++ b/test/solid/result/expectations/with_source/success/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessTypesTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: %i[numbers division_completed]
)
@@ -74,7 +74,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -87,15 +87,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -118,19 +118,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -153,25 +153,25 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb b/test/solid/result/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb
rename to test/solid/result/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb
index 9952c567..dd8e0f1b 100644
--- a/test/bcdd/result/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb
+++ b/test/solid/result/expectations/with_source/success_and_failure/mixed/type_and_value_with_types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: {
numbers: Array,
division_completed: Numeric
@@ -117,7 +117,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -128,7 +128,7 @@ def divide((number1, number2))
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -141,15 +141,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -172,19 +172,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -207,37 +207,37 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb b/test/solid/result/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb
rename to test/solid/result/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb
index 01a02716..b3629f32 100644
--- a/test/bcdd/result/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb
+++ b/test/solid/result/expectations/with_source/success_and_failure/mixed/types_with_type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: %i[numbers division_completed],
failure: {
invalid_arg: String,
@@ -117,7 +117,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -128,7 +128,7 @@ def divide((number1, number2))
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -141,15 +141,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -172,19 +172,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -207,37 +207,37 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/with_source/success_and_failure/type_and_value_test.rb b/test/solid/result/expectations/with_source/success_and_failure/type_and_value_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/with_source/success_and_failure/type_and_value_test.rb
rename to test/solid/result/expectations/with_source/success_and_failure/type_and_value_test.rb
index 6b0de858..379d61d4 100644
--- a/test/bcdd/result/expectations/with_source/success_and_failure/type_and_value_test.rb
+++ b/test/solid/result/expectations/with_source/success_and_failure/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: {
numbers: Array,
division_completed: Numeric
@@ -120,7 +120,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -131,7 +131,7 @@ def divide((number1, number2))
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -144,15 +144,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -175,19 +175,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -210,37 +210,37 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/with_source/success_and_failure/type_test.rb b/test/solid/result/expectations/with_source/success_and_failure/type_test.rb
similarity index 83%
rename from test/bcdd/result/expectations/with_source/success_and_failure/type_test.rb
rename to test/solid/result/expectations/with_source/success_and_failure/type_test.rb
index b9af5835..84a2a1bb 100644
--- a/test/bcdd/result/expectations/with_source/success_and_failure/type_test.rb
+++ b/test/solid/result/expectations/with_source/success_and_failure/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessAndFailureTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessAndFailureTypeTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: :ok,
failure: :err
)
@@ -114,7 +114,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:division_completed)
end
@@ -125,7 +125,7 @@ def divide((number1, number2))
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:division_by_zero)
end
@@ -138,15 +138,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -169,19 +169,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -204,37 +204,37 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/with_source/success_and_failure/types_test.rb b/test/solid/result/expectations/with_source/success_and_failure/types_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/with_source/success_and_failure/types_test.rb
rename to test/solid/result/expectations/with_source/success_and_failure/types_test.rb
index 13f47aff..a67ea2bd 100644
--- a/test/bcdd/result/expectations/with_source/success_and_failure/types_test.rb
+++ b/test/solid/result/expectations/with_source/success_and_failure/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithSourceSuccessAndFailureTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithSourceSuccessAndFailureTypesTest < Minitest::Test
class Divide
- include BCDD::Result::Expectations.mixin(
+ include Solid::Result::Expectations.mixin(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
@@ -114,7 +114,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -125,7 +125,7 @@ def divide((number1, number2))
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -138,15 +138,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -169,19 +169,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -204,37 +204,37 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/without_source/failure/type/invalid_type_test.rb b/test/solid/result/expectations/without_source/failure/type/invalid_type_test.rb
similarity index 82%
rename from test/bcdd/result/expectations/without_source/failure/type/invalid_type_test.rb
rename to test/solid/result/expectations/without_source/failure/type/invalid_type_test.rb
index f07a6c8d..9ca0c07c 100644
--- a/test/bcdd/result/expectations/without_source/failure/type/invalid_type_test.rb
+++ b/test/solid/result/expectations/without_source/failure/type/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceFailureInvalidTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceFailureInvalidTypeTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
failure: :err
)
@@ -35,7 +35,7 @@ def divide((number1, number2))
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call('10', 2)
end
diff --git a/test/bcdd/result/expectations/without_source/failure/type_and_value/invalid_type_test.rb b/test/solid/result/expectations/without_source/failure/type_and_value/invalid_type_test.rb
similarity index 82%
rename from test/bcdd/result/expectations/without_source/failure/type_and_value/invalid_type_test.rb
rename to test/solid/result/expectations/without_source/failure/type_and_value/invalid_type_test.rb
index 1af03c63..234af8d7 100644
--- a/test/bcdd/result/expectations/without_source/failure/type_and_value/invalid_type_test.rb
+++ b/test/solid/result/expectations/without_source/failure/type_and_value/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceFailureInvalidTypeAndValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceFailureInvalidTypeAndValueTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
failure: {
err1: String,
err2: String
@@ -38,7 +38,7 @@ def divide((number1, number2))
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/result/expectations/without_source/failure/type_and_value/invalid_value_test.rb b/test/solid/result/expectations/without_source/failure/type_and_value/invalid_value_test.rb
similarity index 77%
rename from test/bcdd/result/expectations/without_source/failure/type_and_value/invalid_value_test.rb
rename to test/solid/result/expectations/without_source/failure/type_and_value/invalid_value_test.rb
index 9d853480..eabf0b25 100644
--- a/test/bcdd/result/expectations/without_source/failure/type_and_value/invalid_value_test.rb
+++ b/test/solid/result/expectations/without_source/failure/type_and_value/invalid_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceFailureTypeAndValueInvalidValueTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
failure: {
invalid_arg: String,
division_by_zero: String
@@ -22,7 +22,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/result/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb b/test/solid/result/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb
similarity index 79%
rename from test/bcdd/result/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb
rename to test/solid/result/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb
index 7ab52d01..7c33765d 100644
--- a/test/bcdd/result/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb
+++ b/test/solid/result/expectations/without_source/failure/type_and_value/pattern_matching_error_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceFailureTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
failure: {
invalid_arg: String,
division_by_zero: ->(value) do
@@ -26,7 +26,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 0)
end
diff --git a/test/bcdd/result/expectations/without_source/failure/type_and_value_test.rb b/test/solid/result/expectations/without_source/failure/type_and_value_test.rb
similarity index 85%
rename from test/bcdd/result/expectations/without_source/failure/type_and_value_test.rb
rename to test/solid/result/expectations/without_source/failure/type_and_value_test.rb
index 1a8542af..7d6f1e7b 100644
--- a/test/bcdd/result/expectations/without_source/failure/type_and_value_test.rb
+++ b/test/solid/result/expectations/without_source/failure/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceFailureTypeAndValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceFailureTypeAndValueTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
failure: {
invalid_arg: String,
division_by_zero: ->(value) { value.is_a?(String) }
@@ -78,7 +78,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -91,11 +91,11 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
@@ -113,13 +113,13 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -137,19 +137,19 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/without_source/failure/type_test.rb b/test/solid/result/expectations/without_source/failure/type_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/without_source/failure/type_test.rb
rename to test/solid/result/expectations/without_source/failure/type_test.rb
index 3d5d45f3..8dc55489 100644
--- a/test/bcdd/result/expectations/without_source/failure/type_test.rb
+++ b/test/solid/result/expectations/without_source/failure/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceFailureTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceFailureTypeTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
failure: :err
)
@@ -75,7 +75,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -88,11 +88,11 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_failure(:error) { :this_type_is_not_defined_in_the_expectations }
end
@@ -110,13 +110,13 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -134,7 +134,7 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err = assert_raises(BCDD::Result::Error::UnhandledTypes) 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
diff --git a/test/bcdd/result/expectations/without_source/failure/types/invalid_type_test.rb b/test/solid/result/expectations/without_source/failure/types/invalid_type_test.rb
similarity index 82%
rename from test/bcdd/result/expectations/without_source/failure/types/invalid_type_test.rb
rename to test/solid/result/expectations/without_source/failure/types/invalid_type_test.rb
index db27a732..1eb46a9b 100644
--- a/test/bcdd/result/expectations/without_source/failure/types/invalid_type_test.rb
+++ b/test/solid/result/expectations/without_source/failure/types/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceFailureInvalidTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceFailureInvalidTypesTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
failure: %i[err1 err2]
)
@@ -35,7 +35,7 @@ def divide((number1, number2))
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2')
end
diff --git a/test/bcdd/result/expectations/without_source/failure/types_test.rb b/test/solid/result/expectations/without_source/failure/types_test.rb
similarity index 83%
rename from test/bcdd/result/expectations/without_source/failure/types_test.rb
rename to test/solid/result/expectations/without_source/failure/types_test.rb
index 676a2e81..4ad82e64 100644
--- a/test/bcdd/result/expectations/without_source/failure/types_test.rb
+++ b/test/solid/result/expectations/without_source/failure/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceFailureTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceFailureTypesTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
failure: %i[invalid_arg division_by_zero]
)
@@ -75,7 +75,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -88,15 +88,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -119,19 +119,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, '2')
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -154,25 +154,25 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/without_source/success/type/invalid_type_test.rb b/test/solid/result/expectations/without_source/success/type/invalid_type_test.rb
similarity index 76%
rename from test/bcdd/result/expectations/without_source/success/type/invalid_type_test.rb
rename to test/solid/result/expectations/without_source/success/type/invalid_type_test.rb
index 641ab706..fb016ac3 100644
--- a/test/bcdd/result/expectations/without_source/success/type/invalid_type_test.rb
+++ b/test/solid/result/expectations/without_source/success/type/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessInvalidTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessInvalidTypeTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: :ok
)
@@ -19,7 +19,7 @@ def call(arg1, arg2)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/result/expectations/without_source/success/type_and_value/invalid_type_test.rb b/test/solid/result/expectations/without_source/success/type_and_value/invalid_type_test.rb
similarity index 76%
rename from test/bcdd/result/expectations/without_source/success/type_and_value/invalid_type_test.rb
rename to test/solid/result/expectations/without_source/success/type_and_value/invalid_type_test.rb
index 3dfe1e35..d76b4dca 100644
--- a/test/bcdd/result/expectations/without_source/success/type_and_value/invalid_type_test.rb
+++ b/test/solid/result/expectations/without_source/success/type_and_value/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessTypeAndValueInvalidTypeTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: {
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
}
@@ -21,7 +21,7 @@ def call(arg1, arg2)
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/result/expectations/without_source/success/type_and_value/invalid_value_test.rb b/test/solid/result/expectations/without_source/success/type_and_value/invalid_value_test.rb
similarity index 77%
rename from test/bcdd/result/expectations/without_source/success/type_and_value/invalid_value_test.rb
rename to test/solid/result/expectations/without_source/success/type_and_value/invalid_value_test.rb
index b72e990c..e378a406 100644
--- a/test/bcdd/result/expectations/without_source/success/type_and_value/invalid_value_test.rb
+++ b/test/solid/result/expectations/without_source/success/type_and_value/invalid_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessTypeAndValueInvalidValueTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: {
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
}
@@ -21,7 +21,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/result/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb b/test/solid/result/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb
similarity index 78%
rename from test/bcdd/result/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb
rename to test/solid/result/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb
index ebd201b7..dce7a5e0 100644
--- a/test/bcdd/result/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb
+++ b/test/solid/result/expectations/without_source/success/type_and_value/pattern_matching_error_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessTypeAndValuePatterMatchingErrorTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: {
division_completed: ->(value) do
case value
@@ -25,7 +25,7 @@ def call(arg1, arg2)
end
test 'unexpected value error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedValue) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedValue) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/result/expectations/without_source/success/type_and_value_test.rb b/test/solid/result/expectations/without_source/success/type_and_value_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/without_source/success/type_and_value_test.rb
rename to test/solid/result/expectations/without_source/success/type_and_value_test.rb
index c79772ba..6d13898c 100644
--- a/test/bcdd/result/expectations/without_source/success/type_and_value_test.rb
+++ b/test/solid/result/expectations/without_source/success/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessTypeAndValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessTypeAndValueTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: {
numbers: Array,
division_completed: ->(value) { value.is_a?(Integer) || value.is_a?(Float) }
@@ -77,7 +77,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -90,11 +90,11 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:foo) { :this_type_is_not_defined_in_the_expectations }
end
@@ -112,13 +112,13 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -136,19 +136,19 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/without_source/success/type_test.rb b/test/solid/result/expectations/without_source/success/type_test.rb
similarity index 85%
rename from test/bcdd/result/expectations/without_source/success/type_test.rb
rename to test/solid/result/expectations/without_source/success/type_test.rb
index 740c0cda..231c807d 100644
--- a/test/bcdd/result/expectations/without_source/success/type_test.rb
+++ b/test/solid/result/expectations/without_source/success/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessTypeTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: :ok
)
@@ -74,7 +74,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:numbers)
end
@@ -87,11 +87,11 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on_success(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -109,7 +109,7 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -122,7 +122,7 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err = assert_raises(BCDD::Result::Error::UnhandledTypes) 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
diff --git a/test/bcdd/result/expectations/without_source/success/types/invalid_type_test.rb b/test/solid/result/expectations/without_source/success/types/invalid_type_test.rb
similarity index 83%
rename from test/bcdd/result/expectations/without_source/success/types/invalid_type_test.rb
rename to test/solid/result/expectations/without_source/success/types/invalid_type_test.rb
index 4e6083aa..e06f3a36 100644
--- a/test/bcdd/result/expectations/without_source/success/types/invalid_type_test.rb
+++ b/test/solid/result/expectations/without_source/success/types/invalid_type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessInvalidTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessInvalidTypesTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: %i[ok1 ok2 ok3]
)
@@ -35,7 +35,7 @@ def divide((number1, number2))
end
test 'unexpected type error' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2)
end
diff --git a/test/bcdd/result/expectations/without_source/success/types_test.rb b/test/solid/result/expectations/without_source/success/types_test.rb
similarity index 83%
rename from test/bcdd/result/expectations/without_source/success/types_test.rb
rename to test/solid/result/expectations/without_source/success/types_test.rb
index f4b72704..3f26c923 100644
--- a/test/bcdd/result/expectations/without_source/success/types_test.rb
+++ b/test/solid/result/expectations/without_source/success/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessTypesTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: %i[numbers division_completed]
)
@@ -74,7 +74,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -87,15 +87,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -118,19 +118,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -153,25 +153,25 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb b/test/solid/result/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb
rename to test/solid/result/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb
index 96a64b0b..b60af6ae 100644
--- a/test/bcdd/result/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb
+++ b/test/solid/result/expectations/without_source/success_and_failure/mixed/type_and_value_with_types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueWithTypesTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: {
numbers: Array,
division_completed: Numeric
@@ -117,7 +117,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -128,7 +128,7 @@ def divide((number1, number2))
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -141,15 +141,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -172,19 +172,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -207,37 +207,37 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb b/test/solid/result/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb
rename to test/solid/result/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb
index da9fb4da..4c50e877 100644
--- a/test/bcdd/result/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb
+++ b/test/solid/result/expectations/without_source/success_and_failure/mixed/types_with_type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessAndFailureTypesWithTypeAndValueTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: %i[numbers division_completed],
failure: {
invalid_arg: String,
@@ -117,7 +117,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -128,7 +128,7 @@ def divide((number1, number2))
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -141,15 +141,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -172,19 +172,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -207,37 +207,37 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/without_source/success_and_failure/type_and_value_test.rb b/test/solid/result/expectations/without_source/success_and_failure/type_and_value_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/without_source/success_and_failure/type_and_value_test.rb
rename to test/solid/result/expectations/without_source/success_and_failure/type_and_value_test.rb
index 3c99d452..f6f16654 100644
--- a/test/bcdd/result/expectations/without_source/success_and_failure/type_and_value_test.rb
+++ b/test/solid/result/expectations/without_source/success_and_failure/type_and_value_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessAndFailureTypeAndValueTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: {
numbers: Array,
division_completed: Numeric
@@ -120,7 +120,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -131,7 +131,7 @@ def divide((number1, number2))
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -144,15 +144,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -175,19 +175,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -210,37 +210,37 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/without_source/success_and_failure/type_test.rb b/test/solid/result/expectations/without_source/success_and_failure/type_test.rb
similarity index 83%
rename from test/bcdd/result/expectations/without_source/success_and_failure/type_test.rb
rename to test/solid/result/expectations/without_source/success_and_failure/type_test.rb
index 9305bb57..ef0a80a6 100644
--- a/test/bcdd/result/expectations/without_source/success_and_failure/type_test.rb
+++ b/test/solid/result/expectations/without_source/success_and_failure/type_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessAndFailureTypeTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessAndFailureTypeTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: :ok,
failure: :err
)
@@ -114,7 +114,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:division_completed)
end
@@ -125,7 +125,7 @@ def divide((number1, number2))
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:division_by_zero)
end
@@ -138,15 +138,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -169,19 +169,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -204,37 +204,37 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/expectations/without_source/success_and_failure/types_test.rb b/test/solid/result/expectations/without_source/success_and_failure/types_test.rb
similarity index 84%
rename from test/bcdd/result/expectations/without_source/success_and_failure/types_test.rb
rename to test/solid/result/expectations/without_source/success_and_failure/types_test.rb
index d4a0f7ed..6155d39d 100644
--- a/test/bcdd/result/expectations/without_source/success_and_failure/types_test.rb
+++ b/test/solid/result/expectations/without_source/success_and_failure/types_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::ExpectationsWithoutSourceSuccessAndFailureTypesTest < Minitest::Test
+class Solid::Result::ExpectationsWithoutSourceSuccessAndFailureTypesTest < Minitest::Test
class Divide
- Result = BCDD::Result::Expectations.new(
+ Result = Solid::Result::Expectations.new(
success: %i[numbers division_completed],
failure: %i[invalid_arg division_by_zero]
)
@@ -114,7 +114,7 @@ def divide((number1, number2))
end
test 'invalid result type' do
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err1 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, 2).success?(:invalid_arg)
end
@@ -125,7 +125,7 @@ def divide((number1, number2))
# ---
- err2 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ err2 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
Divide.new.call(10, '2').failure?(:numbers)
end
@@ -138,15 +138,15 @@ def divide((number1, number2))
test 'invalid hooks' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ err3 = assert_raises(Solid::Result::Contract::Error::UnexpectedType) do
result.on(:bar) { :this_type_is_not_defined_in_the_expectations }
end
@@ -169,19 +169,19 @@ def divide((number1, number2))
test 'invalid handlers' do
result = Divide.new.call(6, 2)
- err1 = assert_raises(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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(BCDD::Result::Contract::Error::UnexpectedType) do
+ 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
@@ -204,37 +204,37 @@ def divide((number1, number2))
end
test 'does not handle all cases' do
- err1 = assert_raises(BCDD::Result::Error::UnhandledTypes) 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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(BCDD::Result::Error::UnhandledTypes) do
+ 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
diff --git a/test/bcdd/result/factories_test.rb b/test/solid/result/factories_test.rb
similarity index 76%
rename from test/bcdd/result/factories_test.rb
rename to test/solid/result/factories_test.rb
index 6f8c7bfb..95a4dda7 100644
--- a/test/bcdd/result/factories_test.rb
+++ b/test/solid/result/factories_test.rb
@@ -2,9 +2,9 @@
require 'test_helper'
-class BCDD::Result::FactoriesTest < Minitest::Test
+class Solid::Result::FactoriesTest < Minitest::Test
test '.Success() wihout a value' do
- result = BCDD::Result.Success(:ok)
+ result = Solid::Result.Success(:ok)
assert result.success?(:ok)
@@ -16,7 +16,7 @@ class BCDD::Result::FactoriesTest < Minitest::Test
test '.Success() with a value' do
value = [rand, 1, '1', [], {}].sample
- result = BCDD::Result.Success(:ok, value)
+ result = Solid::Result.Success(:ok, value)
assert result.success?(:ok)
@@ -26,7 +26,7 @@ class BCDD::Result::FactoriesTest < Minitest::Test
end
test '.Failure() wihout a value' do
- result = BCDD::Result.Failure(:err)
+ result = Solid::Result.Failure(:err)
assert result.failure?(:err)
@@ -38,7 +38,7 @@ class BCDD::Result::FactoriesTest < Minitest::Test
test '.Failure() with a value' do
value = [rand, 2, '2', [], {}].sample
- result = BCDD::Result.Failure(:err, value)
+ result = Solid::Result.Failure(:err, value)
assert result.failure?(:err)
diff --git a/test/bcdd/result/failure_test.rb b/test/solid/result/failure_test.rb
similarity index 87%
rename from test/bcdd/result/failure_test.rb
rename to test/solid/result/failure_test.rb
index 621a99fe..044440db 100644
--- a/test/bcdd/result/failure_test.rb
+++ b/test/solid/result/failure_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class FailureTest < Minitest::Test
- test 'is a BCDD::Result' do
- assert Failure < BCDD::Result
+ test 'is a Solid::Result' do
+ assert Failure < Solid::Result
end
- test 'is a BCDD::Failure' do
- assert Failure < BCDD::Failure
+ test 'is a Solid::Failure' do
+ assert Failure < Solid::Failure
end
test '#terminal?' do
@@ -83,7 +83,7 @@ class FailureTest < Minitest::Test
test '#inspect' do
result = Failure.new(type: :err, value: 2)
- assert_equal '#', result.inspect
+ assert_equal '#', result.inspect
end
end
end
diff --git a/test/bcdd/result/hooks/handle/failure_test.rb b/test/solid/result/hooks/handle/failure_test.rb
similarity index 94%
rename from test/bcdd/result/hooks/handle/failure_test.rb
rename to test/solid/result/hooks/handle/failure_test.rb
index e54c533b..c39f3de5 100644
--- a/test/bcdd/result/hooks/handle/failure_test.rb
+++ b/test/solid/result/hooks/handle/failure_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+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)
@@ -57,7 +57,7 @@ class HandleFailureTest < Minitest::Test
test '#handle raises an error when type handler does not receive an argument' do
result = Failure.new(type: :foo, value: :bar)
- error = assert_raises(BCDD::Result::Error::MissingTypeArgument) do
+ error = assert_raises(Solid::Result::Error::MissingTypeArgument) do
result.handle do |on|
on.type { 1 }
end
diff --git a/test/bcdd/result/hooks/handle/success_test.rb b/test/solid/result/hooks/handle/success_test.rb
similarity index 94%
rename from test/bcdd/result/hooks/handle/success_test.rb
rename to test/solid/result/hooks/handle/success_test.rb
index 53797461..4072f36f 100644
--- a/test/bcdd/result/hooks/handle/success_test.rb
+++ b/test/solid/result/hooks/handle/success_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+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)
@@ -57,7 +57,7 @@ class HandleSuccessTest < Minitest::Test
test '#handle raises an error when type handler does not receive an argument' do
result = Success.new(type: :foo, value: :bar)
- error = assert_raises(BCDD::Result::Error::MissingTypeArgument) do
+ error = assert_raises(Solid::Result::Error::MissingTypeArgument) do
result.handle do |on|
on.type { 1 }
end
diff --git a/test/bcdd/result/hooks/handle/unknown_test.rb b/test/solid/result/hooks/handle/unknown_test.rb
similarity index 97%
rename from test/bcdd/result/hooks/handle/unknown_test.rb
rename to test/solid/result/hooks/handle/unknown_test.rb
index 65a6eedc..c0c51cbd 100644
--- a/test/bcdd/result/hooks/handle/unknown_test.rb
+++ b/test/solid/result/hooks/handle/unknown_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+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)
diff --git a/test/bcdd/result/hooks/on_failure_test.rb b/test/solid/result/hooks/on_failure_test.rb
similarity index 99%
rename from test/bcdd/result/hooks/on_failure_test.rb
rename to test/solid/result/hooks/on_failure_test.rb
index 4bedfe10..7953085b 100644
--- a/test/bcdd/result/hooks/on_failure_test.rb
+++ b/test/solid/result/hooks/on_failure_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class OnFailureHookTest < Minitest::Test
test '#on_failure returns the result itself' do
result = Failure.new(type: :error, value: 1)
diff --git a/test/bcdd/result/hooks/on_success_test.rb b/test/solid/result/hooks/on_success_test.rb
similarity index 99%
rename from test/bcdd/result/hooks/on_success_test.rb
rename to test/solid/result/hooks/on_success_test.rb
index 27419b61..a4b80906 100644
--- a/test/bcdd/result/hooks/on_success_test.rb
+++ b/test/solid/result/hooks/on_success_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class OnSuccessHookTest < Minitest::Test
test '#on_success returns the result itself' do
result = Success.new(type: :okay, value: 1)
diff --git a/test/bcdd/result/hooks/on_test.rb b/test/solid/result/hooks/on_test.rb
similarity index 95%
rename from test/bcdd/result/hooks/on_test.rb
rename to test/solid/result/hooks/on_test.rb
index 68d8f53b..b9bfff16 100644
--- a/test/bcdd/result/hooks/on_test.rb
+++ b/test/solid/result/hooks/on_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class OnHookTest < Minitest::Test
test '#on returns the result itself' do
result = Success.new(type: :okay, value: 1)
@@ -35,7 +35,7 @@ class OnHookTest < Minitest::Test
result = Success.new(type: :okay, value: 1)
- error = assert_raises(BCDD::Result::Error::MissingTypeArgument) do
+ error = assert_raises(Solid::Result::Error::MissingTypeArgument) do
result.on { |value| number += value }
end
diff --git a/test/bcdd/result/hooks/on_type_test.rb b/test/solid/result/hooks/on_type_test.rb
similarity index 95%
rename from test/bcdd/result/hooks/on_type_test.rb
rename to test/solid/result/hooks/on_type_test.rb
index 44454c79..a244202c 100644
--- a/test/bcdd/result/hooks/on_type_test.rb
+++ b/test/solid/result/hooks/on_type_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class OnTypeHookTest < Minitest::Test
test '#on_type is an alias for #on' do
success = Success.new(type: :okay, value: 1)
diff --git a/test/bcdd/result/hooks/on_unknown_test.rb b/test/solid/result/hooks/on_unknown_test.rb
similarity index 98%
rename from test/bcdd/result/hooks/on_unknown_test.rb
rename to test/solid/result/hooks/on_unknown_test.rb
index 896b1485..37e28fa6 100644
--- a/test/bcdd/result/hooks/on_unknown_test.rb
+++ b/test/solid/result/hooks/on_unknown_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class OnUnknownHookTest < Minitest::Test
test '#on_unknown is ignored when a success hook is called' do
Success
diff --git a/test/bcdd/result/mixin_constants_test.rb b/test/solid/result/mixin_constants_test.rb
similarity index 64%
rename from test/bcdd/result/mixin_constants_test.rb
rename to test/solid/result/mixin_constants_test.rb
index ec22a013..61b65619 100644
--- a/test/bcdd/result/mixin_constants_test.rb
+++ b/test/solid/result/mixin_constants_test.rb
@@ -2,24 +2,24 @@
require 'test_helper'
-class BCDD::Result::MixinConstantsTest < Minitest::Test
+class Solid::Result::MixinConstantsTest < Minitest::Test
class IncludingInClass
- include BCDD::Result.mixin
+ include Solid::Result.mixin
end
module IncludingInModule
- include BCDD::Result.mixin
+ include Solid::Result.mixin
end
class ExtendingInClass
- extend BCDD::Result.mixin
+ extend Solid::Result.mixin
end
module ExtendingInModule
- extend BCDD::Result.mixin
+ extend Solid::Result.mixin
end
- test 'BCDD::Result.mixin sets a constant in all classes/modules' do
+ test 'Solid::Result.mixin sets a constant in all classes/modules' do
assert IncludingInClass.const_defined?(:ResultMixin, false)
assert IncludingInModule.const_defined?(:ResultMixin, false)
diff --git a/test/solid/result/pattern_matching/deconstruct_keys_test.rb b/test/solid/result/pattern_matching/deconstruct_keys_test.rb
new file mode 100644
index 00000000..340c49e3
--- /dev/null
+++ b/test/solid/result/pattern_matching/deconstruct_keys_test.rb
@@ -0,0 +1,54 @@
+# 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
diff --git a/test/solid/result/pattern_matching/deconstruct_test.rb b/test/solid/result/pattern_matching/deconstruct_test.rb
new file mode 100644
index 00000000..93cbac97
--- /dev/null
+++ b/test/solid/result/pattern_matching/deconstruct_test.rb
@@ -0,0 +1,54 @@
+# 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
diff --git a/test/bcdd/result/success_test.rb b/test/solid/result/success_test.rb
similarity index 87%
rename from test/bcdd/result/success_test.rb
rename to test/solid/result/success_test.rb
index 8ce86184..c78dc451 100644
--- a/test/bcdd/result/success_test.rb
+++ b/test/solid/result/success_test.rb
@@ -2,14 +2,14 @@
require 'test_helper'
-class BCDD::Result
+class Solid::Result
class SuccessTest < Minitest::Test
- test 'is a BCDD::Result' do
- assert Success < BCDD::Result
+ test 'is a Solid::Result' do
+ assert Success < Solid::Result
end
- test 'is a BCDD::Success' do
- assert Success < BCDD::Success
+ test 'is a Solid::Success' do
+ assert Success < Solid::Success
end
test '#terminal?' do
@@ -83,7 +83,7 @@ class SuccessTest < Minitest::Test
test '#inspect' do
result = Success.new(type: :ok, value: 2)
- assert_equal '#', result.inspect
+ assert_equal '#', result.inspect
end
end
end
diff --git a/test/bcdd/result/version_test.rb b/test/solid/result/version_test.rb
similarity index 53%
rename from test/bcdd/result/version_test.rb
rename to test/solid/result/version_test.rb
index a0127f32..e1285a6a 100644
--- a/test/bcdd/result/version_test.rb
+++ b/test/solid/result/version_test.rb
@@ -2,8 +2,8 @@
require 'test_helper'
-class BCDD::Result::VersionTest < Minitest::Test
+class Solid::Result::VersionTest < Minitest::Test
test 'should have a version number' do
- refute_nil ::BCDD::Result::VERSION
+ refute_nil ::Solid::Result::VERSION
end
end
diff --git a/test/bcdd/result_test.rb b/test/solid/result_test.rb
similarity index 83%
rename from test/bcdd/result_test.rb
rename to test/solid/result_test.rb
index 607f09c5..5a92843c 100644
--- a/test/bcdd/result_test.rb
+++ b/test/solid/result_test.rb
@@ -2,7 +2,7 @@
require 'test_helper'
-module BCDD
+module Solid
class ResultTest < Minitest::Test
test '#initialize errors' do
error1 = assert_raises(ArgumentError) { Result.new(type: :ok) }
@@ -33,17 +33,17 @@ class ResultTest < Minitest::Test
test '#success?' do
result = Result.new(type: :ok, value: 1)
- assert_raises(BCDD::Result::Error::NotImplemented) { result.success? }
+ assert_raises(Solid::Result::Error::NotImplemented) { result.success? }
- assert_raises(BCDD::Result::Error::NotImplemented) { result.success?(:ok) }
+ assert_raises(Solid::Result::Error::NotImplemented) { result.success?(:ok) }
end
test '#failure?' do
result = Result.new(type: :err, value: 0)
- assert_raises(BCDD::Result::Error::NotImplemented) { result.failure? }
+ assert_raises(Solid::Result::Error::NotImplemented) { result.failure? }
- assert_raises(BCDD::Result::Error::NotImplemented) { result.failure?(:err) }
+ assert_raises(Solid::Result::Error::NotImplemented) { result.failure?(:err) }
end
test '#terminal?' do
@@ -55,7 +55,7 @@ class ResultTest < Minitest::Test
test '#value_or' do
result = Result.new(type: :ok, value: 1)
- assert_raises(BCDD::Result::Error::NotImplemented) { result.value_or { 0 } }
+ assert_raises(Solid::Result::Error::NotImplemented) { result.value_or { 0 } }
end
test '#deconstruct' do
@@ -100,7 +100,7 @@ class ResultTest < Minitest::Test
test '#inspect' do
result = Result.new(type: :ok, value: 2)
- assert_equal '#', result.inspect
+ assert_equal '#', result.inspect
end
end
end
diff --git a/test/test_helper.rb b/test/test_helper.rb
index 1d88eba5..8a547315 100644
--- a/test/test_helper.rb
+++ b/test/test_helper.rb
@@ -9,7 +9,7 @@
end
$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
-require 'bcdd/result'
+require 'solid/result'
require 'minitest/autorun'
@@ -87,7 +87,7 @@ def assert_collection_diff(expected, actual, context_message:)
end
end
-module BCDDResultEventLogAssertions
+module SolidResultEventLogAssertions
include HashSchemaAssertions
def assert_empty_event_logs(result, version: 1)