pax_global_header 0000666 0000000 0000000 00000000064 15136200163 0014507 g ustar 00root root 0000000 0000000 52 comment=93a081f8165fef99724ebe687d384ea6ba4d4726
solid-process-0.5.0/ 0000775 0000000 0000000 00000000000 15136200163 0014277 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/.claude/ 0000775 0000000 0000000 00000000000 15136200163 0015612 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/.claude/CLAUDE.md 0000664 0000000 0000000 00000007206 15136200163 0017076 0 ustar 00root root 0000000 0000000 # CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
## Project Overview
`solid-process` is a Ruby gem for encapsulating business logic into manageable processes. It integrates with Rails and provides input validation, dependency injection, and observability features.
## Common Commands
```bash
# Setup (install dependencies: bundle + appraisal)
bin/setup
# Clean install + full test suite. Useful when switching Ruby versions.
bin/matrix
# Run all tests for current Ruby version
bin/rake matrix
# Run a single test file
bundle exec appraisal rails-8-1 ruby -Ilib:test test/solid/process/result_test.rb
# Run a specific test by name
bundle exec appraisal rails-8-1 ruby -Ilib:test test/solid/process/result_test.rb -n test_method_name
# Interactive console
bin/console
```
## Lint
**Ensure lint is green before committing.**
```bash
# Check for style violations (Ruby 3.4+)
bin/rake standard
# Auto-fix style violations
bin/rake standard:fix
```
### Release Checklist
When `lib/solid/process/version.rb` is changed:
1. Verify `CHANGELOG.md` has a matching version entry (e.g., `## [0.5.0] - YYYY-MM-DD`)
2. Verify `README.md` compatibility matrix is up-to-date if Ruby/Rails support changed
### Ruby/Rails Version Alignment
When modifying Ruby or Rails version support, ensure these files stay aligned:
| File | Purpose |
|------|---------|
| `Appraisals` | Source of truth for gem dependencies per Rails version |
| `Rakefile` | Local `rake matrix` task conditions |
| `.github/workflows/main.yml` | CI matrix and step conditions |
| `README.md` | Compatibility matrix table |
**Key checks:**
1. Ruby version conditions must match across `Appraisals`, `Rakefile`, and CI
2. CI string values (e.g., `'head'`) need explicit checks since numeric comparisons won't match them
3. README table must reflect the actual tested combinations
4. Ruby `head` should only run against Rails edge (not stable Rails versions)
## Switching Ruby Versions
### ASDF
```bash
asdf list ruby # List installed Ruby versions
asdf set ruby 4.0.1 # Ruby 4.x
```
## Tests
Always test on multiple Ruby versions when fixing compatibility issues.
### Support Files
Test fixtures in `test/support/` follow numbered naming (e.g., `051_user_token_creation.rb`) for load order. These define sample processes used across multiple tests.
### Fix Library Code, Not Tests
When tests fail due to Ruby version differences:
1. First check if the **library code** can be updated to normalize behavior
2. Only modify tests if the library fix isn't possible
### Available Rails versions (see Rakefile for full list)
```sh
bundle exec appraisal rails-6-0 rake test # Ruby 2.7, 3.0
bundle exec appraisal rails-6-1 rake test # Ruby 2.7, 3.0
bundle exec appraisal rails-7-0 rake test # Ruby 3.0, 3.1, 3.2, 3.3
bundle exec appraisal rails-7-1 rake test # Ruby 3.0, 3.1, 3.2, 3.3
bundle exec appraisal rails-7-2 rake test # Ruby 3.1, 3.2, 3.3, 3.4
bundle exec appraisal rails-8-0 rake test # Ruby 3.2, 3.3, 3.4
bundle exec appraisal rails-8-1 rake test # Ruby 3.3, 3.4, 4.x
```
## Architecture
### Core Classes
- **Solid::Process** (`lib/solid/process.rb`) - Base class for business processes. Requires `input` block and `call` method. Returns `Success` or `Failure` outputs.
- **Solid::Model** (`lib/solid/model.rb`) - ActiveModel-based concern providing attributes, validations, and callbacks.
- **Solid::Input** (`lib/solid/input.rb`) - Input validation class, includes Solid::Model.
- **Solid::Value** (`lib/solid/value.rb`) - Immutable value objects.
- **Solid::Output** (`lib/solid/output.rb`) - Wraps solid-result gem for Success/Failure return types.
solid-process-0.5.0/.github/ 0000775 0000000 0000000 00000000000 15136200163 0015637 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/.github/workflows/ 0000775 0000000 0000000 00000000000 15136200163 0017674 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/.github/workflows/main.yml 0000664 0000000 0000000 00000004742 15136200163 0021352 0 ustar 00root root 0000000 0000000 name: Ruby
on:
push:
branches:
- main
pull_request:
jobs:
test:
runs-on: ubuntu-latest
name: Ruby ${{ matrix.ruby }}
strategy:
matrix:
ruby: ["2.7", "3.0", "3.1", "3.2", "3.3", "3.4", "4.0", head]
env:
CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
steps:
- uses: actions/checkout@v4
- name: Set up Ruby
uses: ruby/setup-ruby@v1
with:
ruby-version: ${{ matrix.ruby }}
- name: Install bundler
run: gem install bundler -v 2.4.22
if: ${{ matrix.ruby == '2.7' || matrix.ruby == '3.0' }}
- name: Bundle install
run: bundle install
- name: Setup project
run: bundle exec appraisal install
- name: Run tests for Rails 6.0
run: bundle exec appraisal rails-6-0 rake test
if: ${{ matrix.ruby == '2.7' || matrix.ruby == '3.0' }}
- name: Run tests for Rails 6.1
run: bundle exec appraisal rails-6-1 rake test
if: ${{ matrix.ruby == '2.7' || matrix.ruby == '3.0' }}
- name: Run tests for Rails 7.0
run: bundle exec appraisal rails-7-0 rake test
if: ${{ matrix.ruby == '3.0' || matrix.ruby == '3.1' || matrix.ruby == '3.2' || matrix.ruby == '3.3' }}
- name: Run tests for Rails 7.1
run: bundle exec appraisal rails-7-1 rake test
if: ${{ matrix.ruby == '3.0' || matrix.ruby == '3.1' || matrix.ruby == '3.2' || matrix.ruby == '3.3' }}
- name: Run tests for Rails 7.2
run: bundle exec appraisal rails-7-2 rake test
if: ${{ matrix.ruby == '3.1' || matrix.ruby == '3.2' || matrix.ruby == '3.3' || matrix.ruby == '3.4' }}
- name: Run tests for Rails 8.0
run: bundle exec appraisal rails-8-0 rake test
if: ${{ matrix.ruby == '3.2' || matrix.ruby == '3.3' || matrix.ruby == '3.4' }}
- name: Run tests for Rails 8.1
run: bundle exec appraisal rails-8-1 rake test
if: ${{ matrix.ruby == '3.3' || matrix.ruby == '3.4' || matrix.ruby == '4.0' }}
- name: Run tests for Rails edge
run: bundle exec appraisal rails-edge rake test
if: ${{ matrix.ruby == '4.0' || matrix.ruby == 'head' }}
- uses: paambaati/codeclimate-action@v5
if: ${{ matrix.ruby == '3.4' && !github.base_ref }}
standard:
name: Run standard
runs-on: 'ubuntu-latest'
steps:
- uses: actions/checkout@v4
- uses: ruby/setup-ruby@v1
with:
ruby-version: "3.4"
- name: Setup project
run: bundle install
- name: Rake standard
run: bundle exec rake standard
solid-process-0.5.0/.gitignore 0000664 0000000 0000000 00000000301 15136200163 0016261 0 ustar 00root root 0000000 0000000 .DS_Store
/.bundle/
/.yardoc
/_yardoc/
/coverage/
/doc/
/pkg/
/spec/reports/
/tmp/
Gemfile.lock
gemfiles/*.lock
gemfiles/.bundle/
.ruby-version
.tool-versions
/.claude/settings.local.json
solid-process-0.5.0/.rubocop.yml 0000664 0000000 0000000 00000000063 15136200163 0016550 0 ustar 00root root 0000000 0000000 inherit_gem:
standard:
- config/ruby-2.7.yml
solid-process-0.5.0/.standard.yml 0000664 0000000 0000000 00000000127 15136200163 0016700 0 ustar 00root root 0000000 0000000 ruby_version: 2.7
ignore:
- ./examples/**/*
- ./**/*.gemfile.lock
- Gemfile.lock
solid-process-0.5.0/Appraisals 0000664 0000000 0000000 00000004030 15136200163 0016316 0 ustar 00root root 0000000 0000000 if RUBY_VERSION < "3.1"
appraise "rails-6-0" do
group :test do
gem "logger", "~> 1.6", ">= 1.6.6"
gem "stringio", "~> 3.2"
gem "sqlite3", "~> 1.7"
gem "minitest", "5.26.1"
gem "activerecord", "~> 6.0.0"
end
end
appraise "rails-6-1" do
group :test do
gem "logger", "~> 1.6", ">= 1.6.6"
gem "stringio", "~> 3.2"
gem "sqlite3", "~> 1.7"
gem "minitest", "5.26.1"
gem "activerecord", "~> 6.1.0"
end
end
end
if RUBY_VERSION >= "2.7" && RUBY_VERSION < "3.4"
appraise "rails-7-0" do
group :test do
gem "logger", "~> 1.6", ">= 1.6.6"
gem "stringio", "~> 3.2"
gem "securerandom", "~> 0.3.2"
gem "sqlite3", "~> 1.7"
gem "minitest", "5.26.1"
gem "activerecord", "~> 7.0.0"
end
end
appraise "rails-7-1" do
group :test do
gem "logger", "~> 1.6", ">= 1.6.6"
gem "stringio", "~> 3.2"
gem "securerandom", "~> 0.3.2"
gem "sqlite3", "~> 1.7"
gem "minitest", "5.26.1"
gem "activerecord", "~> 7.1.0"
end
end
end
if RUBY_VERSION >= "3.1" && RUBY_VERSION < "4.0"
appraise "rails-7-2" do
group :test do
gem "sqlite3", "~> 2.8", ">= 2.8.1"
gem "minitest", "~> 5.27"
gem "activerecord", "~> 7.2.0"
end
end
end
if RUBY_VERSION >= "3.2" && RUBY_VERSION < "4.0"
appraise "rails-8-0" do
group :test do
gem "sqlite3", "~> 2.9"
gem "ostruct", "~> 0.6.3"
gem "minitest", "~> 5.27"
gem "activerecord", "~> 8.0.0"
end
end
end
if RUBY_VERSION >= "3.3.0"
minitest_version = (RUBY_VERSION >= "4.0.0") ? "~> 6.0" : "~> 5.27"
appraise "rails-8-1" do
group :test do
gem "sqlite3", "~> 2.9"
gem "ostruct", "~> 0.6.3"
gem "minitest", minitest_version
gem "activerecord", "~> 8.1.0"
end
end
appraise "rails-edge" do
group :test do
gem "sqlite3", "~> 2.9"
gem "ostruct", "~> 0.6.3"
gem "minitest", minitest_version
gem "activerecord", github: "rails/rails", branch: "main"
end
end
end
solid-process-0.5.0/CHANGELOG.md 0000664 0000000 0000000 00000006263 15136200163 0016117 0 ustar 00root root 0000000 0000000 ## [Unreleased]
## [0.5.0] - 2025-01-27
### Added
- Add support for Ruby 3.4 and 4.x.
- Add support for Rails 7.2, 8.0, and 8.1.
### Fixed
- Fix `BacktraceCleaner::BLOCKS_PATTERN` to handle Ruby 4.x backtrace format (`'Kernel#then'` instead of `` `then' ``).
## [0.4.0] - 2024-06-23
### Added
- Add `Solid::Process.configuration(freeze: true)`.
- Add `Solid::Process::EventLogs::BasicLoggerListener`.
- Add `Solid::Process::BacktraceCleaner`.
- Add `Solid::Process.configure` as an alias to `Solid::Process.configuration`.
- Add `Solid::Value` to allow defining a value object.
- `Solid::Model`
- Add `after_initialize` callback.
- Add `#[]` to access instance attributes.
- `solid/validators`
- Add `id_validator`, to check if the value is a positive integer or a string that represents a positive integer.
- Add `is_validator`, to check if the value satisfy the given predicate methods.
### Changed
- Replace the usage of `deep_symbolize_keys` with `symbolize_keys` to perform the call more efficiently.
- Change `email_validator` and `uuid_validator` to use `I18n` messages.
- Relax `ActiveModel` dependency to `>= 6.0`.
### Removed
- Remove some validators:
- `bool_validator`
- `is_a_validator`
- `persisted_validator`
## [0.3.0] - 2024-04-14
### Changed
- Replace `bcdd-result` gem `solid-result` gem. This change removes the constant aliases `Solid::Output` and `Solid::Result`, as they are no longer needed.
## [0.2.0] - 2024-03-18
### Added
- Add `Solid::Process#success?`, `Solid::Process#failure?` that delegate to `Solid::Process#output.success?` and `Solid::Process#output.failure?`.
- Add `Solid::Process#with` method to create a new process instance with new dependencies.
- Add `Solid::Process#new` method. It's similar to `Solid::Process#with` but does not require passing the dependencies. If nothing is passed, it will use the same dependencies.
- Add `rescue_from` (from `::ActiveSupport::Rescuable`) method to `Solid::Process` to rescue exceptions and return a `Solid::Output`.
- Add `Solid::Process.config` and `Solid::Process.configuration` methods to define a configuration for all processes.
### Changed
- Move `Solid::Input` features to `Solid::Model` module. This change does not promote breaking changes.
## [0.1.0] - 2024-03-16
### Added
- Add `Solid::Model` module to define a model with attributes and validations.
- It includes `ActiveModel::Api`, `ActiveModel::Access`, `ActiveModel::Attributes`, `ActiveModel::Dirty`, `ActiveModel::Validations::Callbacks`.
- Add `Solid::Input` class (which includes `Solid::Model`) to define an input object with attributes and validations.
- Add `Solid::Output` and `Solid::Result` as constant aliases of `BCDD::Context`.
- Add `Solid::Success()` and `Solid::Failure()` methods to create `BCDD::Context` instances.
- Add `Solid::Process` class to be inherited and define a process with inputs, outputs, and steps.
- Add several ActiveModel validations to be used in `Solid::Model` and `Solid::Input` classes.
- `bool_validator`
- `email_validator`
- `instance_of_validator`
- `is_a_validator`
- `kind_of_validator`
- `persisted_validator`
- `respond_to_validator`
- `singleton_validator`
- `uuid_validator`
solid-process-0.5.0/CODE_OF_CONDUCT.md 0000664 0000000 0000000 00000012151 15136200163 0017076 0 ustar 00root root 0000000 0000000 # Contributor Covenant Code of Conduct
## Our Pledge
We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, religion, or sexual identity and orientation.
We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
## Our Standards
Examples of behavior that contributes to a positive environment for our community include:
* Demonstrating empathy and kindness toward other people
* Being respectful of differing opinions, viewpoints, and experiences
* Giving and gracefully accepting constructive feedback
* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
* Focusing on what is best not just for us as individuals, but for the overall community
Examples of unacceptable behavior include:
* The use of sexualized language or imagery, and sexual attention or
advances of any kind
* Trolling, insulting or derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or email
address, without their explicit permission
* Other conduct which could reasonably be considered inappropriate in a
professional setting
## Enforcement Responsibilities
Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful.
Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate.
## Scope
This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at rodrigo.serradura@gmail.com. All complaints will be reviewed and investigated promptly and fairly.
All community leaders are obligated to respect the privacy and security of the reporter of any incident.
## Enforcement Guidelines
Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct:
### 1. Correction
**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested.
### 2. Warning
**Community Impact**: A violation through a single incident or series of actions.
**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban.
### 3. Temporary Ban
**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior.
**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
### 4. Permanent Ban
**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
**Consequence**: A permanent ban from any sort of public interaction within the community.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder](https://github.com/mozilla/diversity).
[homepage]: https://www.contributor-covenant.org
For answers to common questions about this code of conduct, see the FAQ at
https://www.contributor-covenant.org/faq. Translations are available at https://www.contributor-covenant.org/translations.
solid-process-0.5.0/Gemfile 0000664 0000000 0000000 00000000511 15136200163 0015567 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
source "https://rubygems.org"
# Specify your gem's dependencies in solid-process.gemspec
gemspec
gem "rake", "~> 13.3", ">= 13.3.1"
if RUBY_VERSION >= "3.4"
gem "standard", "~> 1.53"
end
group :test do
gem "bcrypt", "~> 3.1", ">= 3.1.21"
gem "simplecov", "~> 0.22.0", require: false
end
solid-process-0.5.0/LICENSE.txt 0000664 0000000 0000000 00000002074 15136200163 0016125 0 ustar 00root root 0000000 0000000 The MIT License (MIT)
Copyright (c) 2024 Rodrigo Serradura
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
solid-process-0.5.0/README.md 0000664 0000000 0000000 00000024437 15136200163 0015570 0 ustar 00root root 0000000 0000000
βοΈ Solid::Process
Write business logic for Ruby/Rails that scales.
## π Table of Contents
- [Introduction](#introduction)
- [Installation](#installation)
- [The Basic Structure](#the-basic-structure)
- [Further Reading](#further-reading)
- [Development](#development)
- [Contributing](#contributing)
- [License](#license)
- [Code of Conduct](#code-of-conduct)
- [Acknowledgments](#acknowledgments)
- [About](#about)
## Supported Ruby and Rails
This library is tested (100% coverage) against:
| Ruby / Rails | 6.0 | 6.1 | 7.0 | 7.1 | 7.2 | 8.0 | 8.1 | Edge |
|--------------|-----|-----|-----|-----|-----|-----|-----|------|
| 2.7 | β
| β
| β
| β
| | | | |
| 3.0 | β
| β
| β
| β
| | | | |
| 3.1 | | | β
| β
| β
| | | |
| 3.2 | | | β
| β
| β
| β
| | |
| 3.3 | | | β
| β
| β
| β
| β
| β
|
| 3.4 | | | | | β
| β
| β
| β
|
| 4.x | | | | | | | β
| β
|
## Introduction
`solid-process` is a Ruby/Rails library designed to encapsulate business logic into manageable processes. It simplifies writing, testing, maintaining, and evolving your code, ensuring it remains clear and approachable as your application scales.
**Features:** (_touch to expand_)
1οΈβ£ Seamless Rails integration
> Designed to complement Ruby on Rails, this library integrates smoothly without conflicting with existing framework conventions and features.
2οΈβ£ Support progressive mastery
> Offers an intuitive entry point for novices while providing robust, advanced features that cater to experienced developers.
3οΈβ£ Promote conceptual integrity and rapid onboarding
> By maintaining a consistent design philosophy, `solid-process` reduces the learning curve for new developers, allowing them to contribute more effectively and quickly to a codebase.
4οΈβ£ Enhanced observability
> Equipped with sophisticated instrumentation mechanisms, the library enables detailed logging and tracing without compromising code readability, even when processes are nested.
β¬οΈ back to top
### Examples
Check out [Solid Rails App](https://github.com/solid-process/solid-rails-app) for a complete example of how to use `solid-process` in a Rails application. [Twelve versions (branches)](https://github.com/solid-process/solid-rails-app?tab=readme-ov-file#-repository-branches) show how the gem can be incrementally integrated, access it to see from simple services/form objects to implementing the ports and adapters (hexagonal) architectural pattern.
You can also check the [examples](examples) directory for more simple examples of how to use the gem.
β¬οΈ back to top
## Installation
Install the gem and add to the application's Gemfile by executing:
$ bundle add solid-process
If bundler is not being used to manage dependencies, install the gem by executing:
$ gem install solid-process
And require it in your code:
require 'solid/process'
β¬οΈ back to top
## The Basic Structure
All `Solid::Process` requires at least two things: an `input` and a `call` method.
1. The `input` is a set of attributes needed to perform the work.
2. The `#call` method is the entry point and where the work is done.
- It receives the attributes Hash (symbolized keys), defined by the `input`.
- It returns a `Success` or `Failure` as the output.
```ruby
class User::Creation < Solid::Process
input do
# Define the attributes needed to perform the work
end
def call(attributes)
# Perform the work and return a Success or Failure as the output
end
end
```
#### Example
```ruby
class User::Creation < Solid::Process
input do
attribute :email
attribute :password
attribute :password_confirmation
end
def call(attributes)
user = User.create(attributes)
if user.persisted?
Success(:user_created, user: user)
else
Failure(:user_not_created, user: user)
end
end
end
```
β¬οΈ back to top
### Calling a Process
To call a process, you can use the `call` method directly, or instantiate the class and call the `#call` method.
```ruby
###############
# Direct call #
###############
User::Creation.call(email: 'john.doe@email.com', password: 'password', password_confirmation: 'password')
# => ##}>
########################
# Instantiate and call #
########################
process = User::Creation.new
process.call(email: 'john.doe@email.com', password: 'password', password_confirmation: 'password')
```
For now, it's essential to know that a process instance is stateful, and because of this, you can call it only once.
```ruby
process = User::Creation.new
input = {email: 'john.doe@email.com', password: 'password', password_confirmation: 'password'}
process.call(input)
process.call(input)
# The `User::Creation#output` is already set. Use `.output` to access the result or create a new instance to call again. (Solid::Process::Error)
```
β¬οΈ back to top
## Further Reading
1. [Key Concepts](docs/010_KEY_CONCEPTS.md)
2. [Basic Usage](docs/020_BASIC_USAGE.md)
3. [Intermediate Usage](docs/030_INTERMEDIATE_USAGE.md)
4. [Advanced Usage](docs/040_ADVANCED_USAGE.md)
5. [Error Handling](docs/050_ERROR_HANDLING.md)
6. [Testing](docs/060_TESTING.md)
7. [Instrumentation / Observability](docs/070_INSTRUMENTATION.md)
8. [Rails Integration](docs/080_RAILS_INTEGRATION.md)
9. [Internal libraries](docs/090_INTERNAL_LIBRARIES.md)
- Solid::Input
- Solid::Model
- Solid::Value
- ActiveModel validations
10. [Ports and Adapters (Hexagonal Architecture)](docs/100_PORTS_AND_ADAPTERS.md)
β¬οΈ back to top
## Development
After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake matrix` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
```bash
# Run full test suite for current Ruby version
bin/rake matrix
# Run tests for a specific Rails version
bundle exec appraisal rails-8-1 rake test
# Run a single test file
bundle exec appraisal rails-8-1 ruby -Ilib:test test/solid/process/result_test.rb
# Lint (Ruby 3.4+)
bin/rake standard
# Clean install + full test suite (useful when switching Ruby versions)
# asdf set ruby
bin/matrix
```
To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
β¬οΈ back to top
## Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/solid-process/solid-process. 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-process/blob/main/CODE_OF_CONDUCT.md).
β¬οΈ back to top
## License
The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
β¬οΈ back to top
## Code of Conduct
Everyone interacting in the Solid::Process project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/solid-process/solid-process/blob/main/CODE_OF_CONDUCT.md).
β¬οΈ back to top
## Acknowledgments
I want to thank some people who helped me by testing and giving feedback as this project took shape, they are:
- [Diego Linhares](https://github.com/diegolinhares) and [Ralf Schmitz Bongiolo](https://github.com/mrbongiolo) they were the brave ones who worked for a few months with the first versions of the ecosystem (it was called B/CDD). Their feedback was essential for improving DX and helped me to pivot some core decisions.
- [Vitor Avelino](https://github.com/vitoravelino), [TomΓ‘s CoΓͺlho](https://github.com/tomascco), [Haroldo Furtado](https://github.com/haroldofurtado) (I could repeat Ralf and Diego again) for the various feedbacks, documentation, API, support and words of encouragement.
## About
[Rodrigo Serradura](https://rodrigoserradura.com) created this project. He is the Solid Process creator and has already made similar gems like the [u-case](https://github.com/serradura/u-case) and [kind](https://github.com/serradura/kind). This gem can be used independently, but it also contains essential features that facilitate the adoption of Solid Process (the method) in code.
β¬οΈ back to top
solid-process-0.5.0/Rakefile 0000664 0000000 0000000 00000002135 15136200163 0015745 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "bundler/gem_tasks"
require "rake/testtask"
Rake::TestTask.new(:test) do |t|
t.libs += %w[lib test]
t.test_files = FileList.new("test/**/*_test.rb")
end
require "appraisal/task"
Appraisal::Task.new
require "standard/rake" if RUBY_VERSION >= "3.4"
desc "Run the full test suite in all supported Rails versions"
task :matrix do
if RUBY_VERSION < "3.1"
system "bundle exec appraisal rails-6-0 rake test"
system "bundle exec appraisal rails-6-1 rake test"
end
if RUBY_VERSION >= "2.7" && RUBY_VERSION < "3.4"
system "bundle exec appraisal rails-7-0 rake test"
system "bundle exec appraisal rails-7-1 rake test"
end
if RUBY_VERSION >= "3.1" && RUBY_VERSION < "4.0"
system "bundle exec appraisal rails-7-2 rake test"
end
if RUBY_VERSION >= "3.2" && RUBY_VERSION < "4.0"
system "bundle exec appraisal rails-8-0 rake test"
end
if RUBY_VERSION >= "3.3"
system "bundle exec appraisal rails-8-1 rake test"
system "bundle exec appraisal rails-edge rake test"
end
Rake::Task[:standard].invoke if RUBY_VERSION >= "3.4"
end
solid-process-0.5.0/bin/ 0000775 0000000 0000000 00000000000 15136200163 0015047 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/bin/console 0000775 0000000 0000000 00000000437 15136200163 0016443 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
# frozen_string_literal: true
require "bundler/setup"
require "solid/process"
# You can add fixtures and/or initialization code here to make experimenting
# with your gem easier. You can also use a different console, if you like.
require "irb"
IRB.start(__FILE__)
solid-process-0.5.0/bin/matrix 0000775 0000000 0000000 00000000247 15136200163 0016304 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'
set -vx
ruby -v
rm -f Gemfile.lock
bundle install
bundle exec appraisal update
bundle exec rake matrix
ruby -v
solid-process-0.5.0/bin/rake 0000775 0000000 0000000 00000000533 15136200163 0015720 0 ustar 00root root 0000000 0000000 #!/usr/bin/env ruby
# frozen_string_literal: true
#
# This file was generated by Bundler.
#
# The application 'rake' is installed as part of a gem, and
# this file is here to facilitate running it.
#
ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
require "rubygems"
require "bundler/setup"
load Gem.bin_path("rake", "rake")
solid-process-0.5.0/bin/setup 0000775 0000000 0000000 00000000266 15136200163 0016141 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'
set -vx
rm -f Gemfile.lock
bundle install
bundle exec appraisal install
# Do any other automated setup that you need to do here
solid-process-0.5.0/docs/ 0000775 0000000 0000000 00000000000 15136200163 0015227 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/docs/010_KEY_CONCEPTS.md 0000664 0000000 0000000 00000002452 15136200163 0020062 0 ustar 00root root 0000000 0000000
`Previous` [Table of Contents](../README.md#further-reading) | `Next` [Basic Usage](./020_BASIC_USAGE.md)
# The Key Concepts
### What is a process?
A sequence of steps or actions to achieve a specific end. In other words, it is a series of steps that produce a result.
### What is a `Solid::Process`?
It is a class that encapsulates reusable business logic. Its main goal is to **ACT AS AN ORCHESTRATOR** who knows the order, what to use, and the steps necessary to produce an expected result.
### Emergent Design
The business rule is directly coupled with business needs. We are often unclear about these rules and how they will be implemented as code. Clarity tends to improve over time and after many maintenance cycles.
For this reason, this abstraction embraces emerging design, allowing developers to implement code in a basic structure that can evolve and become sophisticated through the learnings obtained over time.
### The Mantra
* **Make it Work**, then
* **Make it Better**, then
* **Make it Even Better**.
Using the emerging design concept, I invite you to embrace this development cycle, write the minimum necessary to implement processes and add more solid-process features based on actual needs.
β¬οΈ back to top
solid-process-0.5.0/docs/020_BASIC_USAGE.md 0000664 0000000 0000000 00000001705 15136200163 0017702 0 ustar 00root root 0000000 0000000
`Previous` [Key Concepts](./010_KEY_CONCEPTS.md) | `Next` [Intermediate Usage](./030_INTERMEDIATE_USAGE.md)
# Basic Usage
**Status:** π‘ `in-progress`
In this section, we will learn how to create a simple process to register a user.
```ruby
class User::Registration < Solid::Process
input do
attribute :email
attribute :password
attribute :password_confirmation
end
def call(attributes)
user = User.new(attributes)
return Failure(:invalid_user, user:) if user.invalid?
ActiveRecord::Base.transaction do
user.save!
account = Account.create!(uuid: SecureRandom.uuid)
account.memberships.create!(user: user, role: :owner)
account.task_lists.inbox.create!
user.create_token!
end
UserMailer.with(
user: user,
token: user.generate_token_for(:email_confirmation)
).email_confirmation.deliver_later
Success(:user_registered, user: user)
end
end
```
solid-process-0.5.0/docs/030_INTERMEDIATE_USAGE.md 0000664 0000000 0000000 00000003075 15136200163 0020736 0 ustar 00root root 0000000 0000000
`Previous` [Basic Usage](./020_BASIC_USAGE.md) | `Next` [Advanced Usage](./040_ADVANCED_USAGE.md)
# Intermediate Usage
**Status:** π‘ `in-progress`
In this section, we will learn how to use steps to express the process in a more structured way.
```ruby
class User::Registration < Solid::Process
input do
attribute :email, :string
attribute :password, :string
attribute :password_confirmation, :string
end
def call(attributes)
rollback_on_failure {
Given(attributes)
.and_then(:create_user)
.and_then(:create_user_account)
.and_then(:create_user_inbox)
.and_then(:create_user_token)
}
.and_then(:send_email_confirmation)
.and_expose(:user_registered, [:user])
end
private
def create_user(email:, password:, password_confirmation:, **)
user = User.create(email:, password:, password_confirmation:)
return Continue(user:) if user.persisted?
input.errors.merge!(user.errors)
Failure(:invalid_input, input:)
end
def create_user_account(user:, **)
account = Account.create!(uuid: SecureRandom.uuid)
account.memberships.create!(user:, role: :owner)
Continue(account:)
end
def create_user_inbox(account:, **)
account.task_lists.inbox.create!
Continue()
end
def create_user_token(user:, **)
user.create_token!
Continue()
end
def send_email_confirmation(user:, **)
UserMailer.with(
user:,
token: user.generate_token_for(:email_confirmation)
).email_confirmation.deliver_later
Continue()
end
end
```
solid-process-0.5.0/docs/040_ADVANCED_USAGE.md 0000664 0000000 0000000 00000004624 15136200163 0020233 0 ustar 00root root 0000000 0000000
`Previous` [Intermediate Usage](./030_INTERMEDIATE_USAGE.md) | `Next` [Error Handling](./050_ERROR_HANDLING.md)
# Advanced Usage
**Status:** π‘ `in-progress`
In this section, we will learn how to use input normalization and validation, dependencies, and nested processes.
```ruby
class User::Registration < Solid::Process
deps do
attribute :mailer, default: UserMailer
attribute :token_creation, default: User::Token::Creation
attribute :task_list_creation, default: Account::Task::List::Creation
end
input do
attribute :email, :string
attribute :password, :string
attribute :password_confirmation, :string
before_validation do
self.email = email.downcase.strip
end
with_options presence: true do
validates :email, format: User::Email::REGEXP
validates :password, confirmation: true, length: {minimum: User::Password::MINIMUM_LENGTH}
end
end
def call(attributes)
rollback_on_failure {
Given(attributes)
.and_then(:check_if_email_is_taken)
.and_then(:create_user)
.and_then(:create_user_account)
.and_then(:create_user_inbox)
.and_then(:create_user_token)
}
.and_then(:send_email_confirmation)
.and_expose(:user_registered, [:user])
end
private
def check_if_email_is_taken(email:, **)
input.errors.add(:email, "has already been taken") if User.exists?(email:)
input.errors.any? ? Failure(:invalid_input, input:) : Continue()
end
def create_user(email:, password:, password_confirmation:, **)
user = User.create(email:, password:, password_confirmation:)
return Continue(user:) if user.persisted?
input.errors.merge!(user.errors)
Failure(:invalid_input, input:)
end
def create_user_account(user:, **)
account = Account.create!(uuid: SecureRandom.uuid)
account.memberships.create!(user:, role: :owner)
Continue(account:)
end
def create_user_inbox(account:, **)
case deps.task_list_creation.call(account:, inbox: true)
in Solid::Success(task_list:) then Continue()
end
end
def create_user_token(user:, **)
case deps.token_creation.call(user:)
in Solid::Success(token:) then Continue()
end
end
def send_email_confirmation(user:, **)
deps.mailer.with(
user:,
token: user.generate_token_for(:email_confirmation)
).email_confirmation.deliver_later
Continue()
end
end
```
solid-process-0.5.0/docs/050_ERROR_HANDLING.md 0000664 0000000 0000000 00000000053 15136200163 0020270 0 ustar 00root root 0000000 0000000 # Error handling
**Status:** π΄ `to-do`
solid-process-0.5.0/docs/060_TESTING.md 0000664 0000000 0000000 00000000044 15136200163 0017251 0 ustar 00root root 0000000 0000000 # Testing
**Status:** π΄ `to-do`
solid-process-0.5.0/docs/070_INSTRUMENTATION.md 0000664 0000000 0000000 00000000054 15136200163 0020441 0 ustar 00root root 0000000 0000000 # Instrumentation
**Status:** π΄ `to-do`
solid-process-0.5.0/docs/080_RAILS_INTEGRATION.md 0000664 0000000 0000000 00000000054 15136200163 0020654 0 ustar 00root root 0000000 0000000 # Instrumentation
**Status:** π΄ `to-do`
solid-process-0.5.0/docs/090_INTERNAL_LIBRARIES.md 0000664 0000000 0000000 00000000057 15136200163 0020753 0 ustar 00root root 0000000 0000000 # Internal Libraries
**Status:** π΄ `to-do`
solid-process-0.5.0/docs/100_PORTS_AND_ADAPTERS.md 0000664 0000000 0000000 00000000110 15136200163 0020775 0 ustar 00root root 0000000 0000000 # Ports and Adapters (Hexagonal Architecture)
**Status:** π΄ `to-do`
solid-process-0.5.0/examples/ 0000775 0000000 0000000 00000000000 15136200163 0016115 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/examples/business_processes/ 0000775 0000000 0000000 00000000000 15136200163 0022036 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/examples/business_processes/.rubocop.yml 0000664 0000000 0000000 00000000063 15136200163 0024307 0 ustar 00root root 0000000 0000000 inherit_gem:
standard:
- config/ruby-3.1.yml
solid-process-0.5.0/examples/business_processes/.ruby-version 0000664 0000000 0000000 00000000006 15136200163 0024477 0 ustar 00root root 0000000 0000000 3.2.2
solid-process-0.5.0/examples/business_processes/.standard.yml 0000664 0000000 0000000 00000000022 15136200163 0024431 0 ustar 00root root 0000000 0000000 ruby_version: 3.1
solid-process-0.5.0/examples/business_processes/Gemfile 0000664 0000000 0000000 00000000475 15136200163 0023337 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
source "https://rubygems.org"
gem "sqlite3", "~> 1.7"
gem "bcrypt", "~> 3.1.20"
gem "activerecord", "~> 7.1", ">= 7.1.3", require: "active_record"
gem "type_validator"
gem "solid-process", path: "../../"
gem "rake", "~> 13.0", require: false
gem "standard", "~> 1.34", require: false
solid-process-0.5.0/examples/business_processes/Rakefile 0000664 0000000 0000000 00000005207 15136200163 0023507 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "bundler/setup"
Bundler.require(:default)
require "standard/rake"
if RUBY_VERSION <= "3.1"
puts "This example requires Ruby 3.1 or higher."
exit! 1
end
task :config do
require_relative "config"
end
task default: %i[solid_result]
desc "Do pattern matching in Solid::Result"
task solid_result: %i[config] do
input = {
uuid: SecureRandom.uuid,
owner: {
name: "\tJohn Doe \n",
email: " JOHN.doe@email.com",
password: "123123123",
password_confirmation: "123123123"
}
}
case Account::OwnerCreation.call(input)
in Solid::Result(user:, account:)
puts "Account and owner user created: #{account.uuid} and #{user.uuid}"
in Solid::Result(type:, value:)
puts "Account creation failed: #{type} - #{value}"
end
# Different ways to match
#
# in Solid::Result(value: {user:, account:})
# in Solid::Result(type:, value: {user:, account:})
# in Solid::Result(type: :account_owner_created, value: {user:, account:})
end
desc "Do pattern matching in Solid::Output"
task solid_output: %i[config] do
input = {
uuid: SecureRandom.uuid,
owner: {
name: "\tJohn Doe \n",
email: " JOHN.doe@email.com",
password: "123123123",
password_confirmation: "123123123"
}
}
case Account::OwnerCreation.call(input)
in Solid::Output(user:, account:)
puts "Account and owner user created: #{account.uuid} and #{user.uuid}"
in Solid::Output(type:, value:)
puts "Account creation failed: #{type} - #{value}"
end
# Different ways to match
#
# in Solid::Output(value: {user:, account:})
# in Solid::Output(type:, value: {user:, account:})
# in Solid::Output(type: :account_owner_created, value: {user:, account:})
end
desc "Do pattern matching in Solid::Success and Solid::Failure"
task solid_success_and_failure: %i[config] do
input = {
uuid: SecureRandom.uuid,
owner: {
name: "\tJohn Doe \n",
email: " JOHN.doe@email.com",
password: "123123123",
password_confirmation: "123123123"
}
}
case Account::OwnerCreation.call(input)
in Solid::Success(user:, account:)
puts "Account and owner user created: #{account.uuid} and #{user.uuid}"
in Solid::Failure(type:, value:)
puts "Account creation failed: #{type} - #{value}"
end
# Different ways to match
#
# in Solid::Success(value: {user:, account:})
# in Solid::Success(type:, value: {user:, account:})
# in Solid::Success(type: :account_owner_created, value: {user:, account:})
#
# in Solid::Failure(input:)
# in Solid::Failure(value: {input:})
# in Solid::Failure(type: :invalid_input, value: {input:})
end
solid-process-0.5.0/examples/business_processes/app/ 0000775 0000000 0000000 00000000000 15136200163 0022616 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/examples/business_processes/app/models/ 0000775 0000000 0000000 00000000000 15136200163 0024101 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/examples/business_processes/app/models/account.rb 0000664 0000000 0000000 00000000720 15136200163 0026061 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account < ActiveRecord::Base
has_many :memberships, inverse_of: :account, dependent: :destroy, class_name: "::Account::Member"
has_many :users, through: :memberships, inverse_of: :accounts
where_ownership = -> { where(account_members: {role: :owner}) }
has_one :ownership, where_ownership, dependent: nil, inverse_of: :account, class_name: "::Account::Member"
has_one :owner, through: :ownership, source: :user
end
solid-process-0.5.0/examples/business_processes/app/models/account/ 0000775 0000000 0000000 00000000000 15136200163 0025535 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/examples/business_processes/app/models/account/member.rb 0000664 0000000 0000000 00000000405 15136200163 0027330 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account::Member < ActiveRecord::Base
self.table_name = "account_members"
enum role: {owner: 0, admin: 1, contributor: 2}
belongs_to :user, inverse_of: :memberships
belongs_to :account, inverse_of: :memberships
end
solid-process-0.5.0/examples/business_processes/app/models/account/owner_creation.rb 0000664 0000000 0000000 00000002524 15136200163 0031103 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account
class OwnerCreation < Solid::Process
deps do
attribute :user_creation, default: ::User::Creation
end
input do
attribute :uuid, :string, default: -> { ::SecureRandom.uuid }
attribute :owner
before_validation do |input|
input.uuid = input.uuid.strip.downcase
end
validates :uuid, presence: true, format: {with: /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i}
validates :owner, presence: true
end
def call(attributes)
rollback_on_failure {
Given(attributes)
.and_then(:create_owner)
.and_then(:create_account)
.and_then(:link_owner_to_account)
}.and_expose(:account_owner_created, %i[user account])
end
private
def create_owner(owner:, **)
case deps.user_creation.call(owner)
in Solid::Success(user:, token:)
Continue(user:, user_token: token)
in Solid::Failure(type:, value:)
Failure(:invalid_owner, **{type => value})
end
end
def create_account(uuid:, **)
account = ::Account.create(uuid:)
account.persisted? ? Continue(account:) : Failure(:invalid_account, account:)
end
def link_owner_to_account(account:, user:, **)
Member.create!(account:, user:, role: :owner)
Continue()
end
end
end
solid-process-0.5.0/examples/business_processes/app/models/user.rb 0000664 0000000 0000000 00000001054 15136200163 0025404 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User < ActiveRecord::Base
has_secure_password
has_many :memberships, inverse_of: :user, dependent: :destroy, class_name: "::Account::Member"
has_many :accounts, through: :memberships, inverse_of: :users
where_ownership = -> { where(account_members: {role: :owner}) }
has_one :ownership, where_ownership, inverse_of: :user, class_name: "::Account::Member"
has_one :account, through: :ownership, inverse_of: :owner
has_one :token, inverse_of: :user, dependent: :destroy, class_name: "::User::Token"
end
solid-process-0.5.0/examples/business_processes/app/models/user/ 0000775 0000000 0000000 00000000000 15136200163 0025057 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/examples/business_processes/app/models/user/creation.rb 0000664 0000000 0000000 00000003504 15136200163 0027212 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User
class Creation < Solid::Process
deps do
attribute :token_creation, default: ::User::Token::Creation
end
input do
attribute :uuid, :string, default: -> { ::SecureRandom.uuid }
attribute :name, :string
attribute :email, :string
attribute :password, :string
attribute :password_confirmation, :string
before_validation do |input|
input.uuid = input.uuid.strip.downcase
input.name = input.name.strip.gsub(/\s+/, " ")
input.email = input.email.strip.downcase
end
validates :uuid, presence: true, format: {with: /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i}
validates :name, presence: true
validates :email, presence: true, format: {with: ::URI::MailTo::EMAIL_REGEXP}
validates :password, :password_confirmation, presence: true
end
def call(attributes)
Given(attributes)
.and_then(:validate_email_uniqueness)
.then { |result|
rollback_on_failure {
result
.and_then(:create_user)
.and_then(:create_user_token)
}
}
.and_expose(:user_created, %i[user token])
end
private
def validate_email_uniqueness(email:, **)
::User.exists?(email:) ? Failure(:email_already_taken) : Continue()
end
def create_user(uuid:, name:, email:, password:, password_confirmation:)
user = ::User.create(uuid:, name:, email:, password:, password_confirmation:)
user.persisted? ? Continue(user:) : Failure(:invalid_record, **user.errors.messages)
end
def create_user_token(user:, **)
case deps.token_creation.call(user: user)
in Solid::Success(token:)
Continue(token:)
in Solid::Failure
raise "Token creation failed"
end
end
end
end
solid-process-0.5.0/examples/business_processes/app/models/user/token.rb 0000664 0000000 0000000 00000000224 15136200163 0026522 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User::Token < ActiveRecord::Base
self.table_name = "user_tokens"
belongs_to :user, inverse_of: :token
end
solid-process-0.5.0/examples/business_processes/app/models/user/token/ 0000775 0000000 0000000 00000000000 15136200163 0026177 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/examples/business_processes/app/models/user/token/creation.rb 0000664 0000000 0000000 00000002060 15136200163 0030326 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User::Token
class Creation < Solid::Process
input do
attribute :user
attribute :executed_at, :time, default: -> { ::Time.current }
validates :user, presence: true
validates :executed_at, presence: true
end
def call(attributes)
Given(attributes)
.and_then(:validate_token_existence)
.and_then(:create_token_if_not_exists)
.and_expose(:token_created, %i[token])
end
private
def validate_token_existence(user:, **)
token = user.token
token&.persisted? ? Success(:token_already_exists, token:) : Continue()
end
def create_token_if_not_exists(user:, executed_at:, **)
token = user.create_token(
access_token: ::SecureRandom.hex(24),
refresh_token: ::SecureRandom.hex(24),
access_token_expires_at: executed_at + 15.days,
refresh_token_expires_at: executed_at + 30.days
)
token.persisted? ? Continue(token:) : Failure(:token_creation_failed, **token.errors.messages)
end
end
end
solid-process-0.5.0/examples/business_processes/config.rb 0000664 0000000 0000000 00000000504 15136200163 0023627 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
$LOAD_PATH.unshift(__dir__)
require "db/setup"
require "app/models/account"
require "app/models/account/member"
require "app/models/user"
require "app/models/user/token"
require "app/models/user/token/creation"
require "app/models/user/creation"
require "app/models/account/owner_creation"
solid-process-0.5.0/examples/business_processes/db/ 0000775 0000000 0000000 00000000000 15136200163 0022423 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/examples/business_processes/db/setup.rb 0000664 0000000 0000000 00000002451 15136200163 0024112 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "active_support/all"
ActiveRecord::Base.establish_connection(
host: "localhost",
adapter: "sqlite3",
database: ":memory:"
)
ActiveRecord::Schema.define do
suppress_messages do
create_table :accounts do |t|
t.string :uuid, null: false, index: {unique: true}
t.timestamps
end
create_table :users do |t|
t.string :uuid, null: false, index: {unique: true}
t.string :name, null: false
t.string :email, null: false, index: {unique: true}
t.string :password_digest, null: false
t.timestamps
end
create_table :user_tokens do |t|
t.belongs_to :user, null: false, foreign_key: true, index: true
t.string :access_token, null: false
t.string :refresh_token, null: false
t.datetime :access_token_expires_at, null: false
t.datetime :refresh_token_expires_at, null: false
t.timestamps
end
create_table :account_members do |t|
t.integer :role, null: false, default: 0
t.belongs_to :user, null: false, foreign_key: true, index: true
t.belongs_to :account, null: false, foreign_key: true, index: true
t.timestamps
t.index %i[account_id role], unique: true, where: "(role = 0)"
t.index %i[account_id user_id], unique: true
end
end
end
solid-process-0.5.0/gemfiles/ 0000775 0000000 0000000 00000000000 15136200163 0016072 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/gemfiles/rails_6_0.gemfile 0000664 0000000 0000000 00000000576 15136200163 0021212 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.3", ">= 13.3.1"
group :test do
gem "bcrypt", "~> 3.1", ">= 3.1.21"
gem "simplecov", "~> 0.22.0", require: false
gem "logger", "~> 1.6", ">= 1.6.6"
gem "stringio", "~> 3.2"
gem "sqlite3", "~> 1.7"
gem "minitest", "5.26.1"
gem "activerecord", "~> 6.0.0"
end
gemspec path: "../"
solid-process-0.5.0/gemfiles/rails_6_1.gemfile 0000664 0000000 0000000 00000000576 15136200163 0021213 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.3", ">= 13.3.1"
group :test do
gem "bcrypt", "~> 3.1", ">= 3.1.21"
gem "simplecov", "~> 0.22.0", require: false
gem "logger", "~> 1.6", ">= 1.6.6"
gem "stringio", "~> 3.2"
gem "sqlite3", "~> 1.7"
gem "minitest", "5.26.1"
gem "activerecord", "~> 6.1.0"
end
gemspec path: "../"
solid-process-0.5.0/gemfiles/rails_7_0.gemfile 0000664 0000000 0000000 00000000637 15136200163 0021211 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.3", ">= 13.3.1"
group :test do
gem "bcrypt", "~> 3.1", ">= 3.1.21"
gem "simplecov", "~> 0.22.0", require: false
gem "logger", "~> 1.6", ">= 1.6.6"
gem "stringio", "~> 3.2"
gem "securerandom", "~> 0.3.2"
gem "sqlite3", "~> 1.7"
gem "minitest", "5.26.1"
gem "activerecord", "~> 7.0.0"
end
gemspec path: "../"
solid-process-0.5.0/gemfiles/rails_7_1.gemfile 0000664 0000000 0000000 00000000653 15136200163 0021210 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.3", ">= 13.3.1"
group :test do
gem "bcrypt", "~> 3.1", ">= 3.1.21"
gem "simplecov", "~> 0.22.0", require: false
gem "logger", "~> 1.6", ">= 1.6.6"
gem "stringio", "~> 3.2"
gem "securerandom", "~> 0.3.2"
gem "sqlite3", "~> 2.0", ">= 2.0.4"
gem "minitest", "5.26.1"
gem "activerecord", "~> 7.1.0"
end
gemspec path: "../"
solid-process-0.5.0/gemfiles/rails_7_2.gemfile 0000664 0000000 0000000 00000000545 15136200163 0021211 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.3", ">= 13.3.1"
gem "standard", "~> 1.53"
group :test do
gem "bcrypt", "~> 3.1", ">= 3.1.21"
gem "simplecov", "~> 0.22.0", require: false
gem "sqlite3", "~> 2.8", ">= 2.8.1"
gem "minitest", "~> 5.27"
gem "activerecord", "~> 7.2.0"
end
gemspec path: "../"
solid-process-0.5.0/gemfiles/rails_8_0.gemfile 0000664 0000000 0000000 00000000565 15136200163 0021212 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.3", ">= 13.3.1"
gem "standard", "~> 1.53"
group :test do
gem "bcrypt", "~> 3.1", ">= 3.1.21"
gem "simplecov", "~> 0.22.0", require: false
gem "sqlite3", "~> 2.9"
gem "ostruct", "~> 0.6.3"
gem "minitest", "~> 5.27"
gem "activerecord", "~> 8.0.0"
end
gemspec path: "../"
solid-process-0.5.0/gemfiles/rails_8_1.gemfile 0000664 0000000 0000000 00000000564 15136200163 0021212 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.3", ">= 13.3.1"
gem "standard", "~> 1.53"
group :test do
gem "bcrypt", "~> 3.1", ">= 3.1.21"
gem "simplecov", "~> 0.22.0", require: false
gem "sqlite3", "~> 2.9"
gem "ostruct", "~> 0.6.3"
gem "minitest", "~> 6.0"
gem "activerecord", "~> 8.1.0"
end
gemspec path: "../"
solid-process-0.5.0/gemfiles/rails_edge.gemfile 0000664 0000000 0000000 00000000617 15136200163 0021526 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.3", ">= 13.3.1"
gem "standard", "~> 1.53"
group :test do
gem "bcrypt", "~> 3.1", ">= 3.1.21"
gem "simplecov", "~> 0.22.0", require: false
gem "sqlite3", "~> 2.9"
gem "ostruct", "~> 0.6.3"
gem "minitest", "~> 6.0"
gem "activerecord", github: "rails/rails", branch: "main"
end
gemspec path: "../"
solid-process-0.5.0/lib/ 0000775 0000000 0000000 00000000000 15136200163 0015045 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/lib/solid/ 0000775 0000000 0000000 00000000000 15136200163 0016157 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/lib/solid/input.rb 0000664 0000000 0000000 00000000117 15136200163 0017642 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Input
include ::Solid::Model
end
solid-process-0.5.0/lib/solid/model.rb 0000664 0000000 0000000 00000001623 15136200163 0017606 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require_relative "model/access"
module Solid::Model
extend ::ActiveSupport::Concern
module ClassMethods
def [](...)
new(...)
end
def inherited(subclass)
subclass.include(::Solid::Model)
end
end
included do
include ::ActiveModel.const_defined?(:Api, false) ? ::ActiveModel::Api : ::ActiveModel::Model
include ::ActiveModel.const_defined?(:Access, false) ? ::ActiveModel::Access : ::Solid::Model::Access
include ::ActiveModel::Attributes
include ::ActiveModel::Dirty
include ::ActiveModel::Validations::Callbacks
extend ActiveModel::Callbacks
define_model_callbacks :initialize, only: :after
end
def initialize(...)
super
run_callbacks(:initialize)
end
def inspect
"#<#{self.class.name} #{attributes.map { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>"
end
alias_method :[], :public_send
end
solid-process-0.5.0/lib/solid/model/ 0000775 0000000 0000000 00000000000 15136200163 0017257 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/lib/solid/model/access.rb 0000664 0000000 0000000 00000001520 15136200163 0021043 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Model
# Implementation based on ActiveModel::Access
# https://github.com/rails/rails/blob/7-1-stable/activemodel/lib/active_model/access.rb
module Access
# Returns a hash of the given methods with their names as keys and returned
# values as values.
#
# person = Person.new(id: 1, name: "bob")
# person.slice(:id, :name)
# => { "id" => 1, "name" => "bob" }
def slice(*methods)
methods.flatten.index_with { |method| public_send(method) }.with_indifferent_access
end
# Returns an array of the values returned by the given methods.
#
# person = Person.new(id: 1, name: "bob")
# person.values_at(:id, :name)
# => [1, "bob"]
def values_at(*methods)
methods.flatten.map! { |method| public_send(method) }
end
end
end
solid-process-0.5.0/lib/solid/output.rb 0000664 0000000 0000000 00000000311 15136200163 0020037 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "solid/result"
module Solid
def self.Success(...)
::Solid::Output::Success(...)
end
def self.Failure(...)
::Solid::Output::Failure(...)
end
end
solid-process-0.5.0/lib/solid/process.rb 0000664 0000000 0000000 00000007000 15136200163 0020157 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "active_support/all"
require "active_model"
module Solid
require_relative "model"
require_relative "value"
require_relative "input"
require_relative "output"
class Process
require "solid/process/version"
require "solid/process/error"
require "solid/process/config"
require "solid/process/caller"
require "solid/process/callbacks"
require "solid/process/class_methods"
require "solid/process/active_record"
require "solid/process/backtrace_cleaner"
require "solid/process/event_logs"
extend ClassMethods
include Callbacks
include ::ActiveSupport::Rescuable
include ::Solid::Output.mixin(config: {addon: {continue: true}})
def self.inherited(subclass)
super
subclass.prepend(Caller)
end
def self.call(arg = nil)
new.call(arg)
end
def self.config
Config.instance
end
def self.configuration(freeze: true, &block)
yield config
config.tap { _1.freeze if freeze }
end
singleton_class.alias_method :configure, :configuration
attr_reader :output, :input, :dependencies
def initialize(arg = nil)
self.dependencies = arg
end
def call(_arg = nil)
raise Error, "#{self.class}#call must be implemented."
end
def with(dependencies)
self.class.new(dependencies.with_indifferent_access.with_defaults(deps&.attributes))
end
def new(dependencies = {})
with(dependencies)
end
def input?
!input.nil?
end
def output?(type = nil)
type.nil? ? !output.nil? : !!output&.is?(type)
end
def dependencies?
!dependencies.nil?
end
def success?(type = nil)
!!output&.success?(type)
end
def failure?(type = nil)
!!output&.failure?(type)
end
def inspect
"#<#{self.class.name} dependencies=#{dependencies.inspect} input=#{input.inspect} output=#{output.inspect}>"
end
def method_missing(name, *args, &block)
name.end_with?("?") ? output&.is?(name.to_s.chomp("?")) : super
end
def respond_to_missing?(name, include_private = false)
name.end_with?("?") || super
end
alias_method :deps, :dependencies
alias_method :deps?, :dependencies?
alias_method :result, :output
alias_method :result?, :output?
private
def dependencies=(arg)
raise Error, "The `#{self.class}#dependencies` is already set." unless dependencies.nil?
@dependencies = self.class.dependencies&.then { arg.instance_of?(_1) ? arg : _1.new(arg) }
end
def input=(arg)
raise Error, "The `#{self.class}#input` is already set." unless input.nil?
@input = self.class.input.then { arg.instance_of?(_1) ? arg : _1.new(arg) }
end
def output_already_set!
raise Error, "The `#{self.class}#output` is already set. " \
"Use `.output` to access the result or create a new instance to call again."
end
def output=(result)
output_already_set! unless output.nil?
raise Error, "The result #{result.inspect} must be a Solid::Output." unless result.is_a?(::Solid::Output)
@output = result
end
def Success!(...)
return self.output = Success(...) if output.nil?
raise Error, "`Success!()` cannot be called because the `#{self.class}#output` is already set."
end
def Failure!(...)
return self.output = Failure(...) if output.nil?
raise Error, "`Failure!()` cannot be called because the `#{self.class}#output` is already set."
end
end
end
solid-process-0.5.0/lib/solid/process/ 0000775 0000000 0000000 00000000000 15136200163 0017635 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/lib/solid/process/active_record.rb 0000664 0000000 0000000 00000000633 15136200163 0022775 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
begin
require "active_record"
rescue LoadError
end
module Solid
class Process
private
if defined?(::ActiveRecord)
def rollback_on_failure(model: ::ActiveRecord::Base)
result = nil
model.transaction do
result = yield
raise ::ActiveRecord::Rollback if result.failure?
end
result
end
end
end
end
solid-process-0.5.0/lib/solid/process/backtrace_cleaner.rb 0000664 0000000 0000000 00000000571 15136200163 0023575 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Process::BacktraceCleaner < ActiveSupport::BacktraceCleaner
def initialize
super
add_blocks_silencer
end
private
BLOCKS_PATTERN = /in [`']block in|in [`'](?:Kernel#)?then'|internal:kernel|block \(\d+ levels?\) in/.freeze
def add_blocks_silencer
add_silencer { |line| line.match?(BLOCKS_PATTERN) }
end
end
solid-process-0.5.0/lib/solid/process/callbacks.rb 0000664 0000000 0000000 00000001501 15136200163 0022076 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Process
module Callbacks
def self.included(subclass)
subclass.include ActiveSupport::Callbacks
subclass.define_callbacks(:call, :success, :failure)
subclass.extend ClassMethods
end
module ClassMethods
def before_call(*filters, &block)
set_callback(:call, :before, *filters, &block)
end
def around_call(*filters, &block)
set_callback(:call, :around, *filters, &block)
end
def after_call(*filters, &block)
set_callback(:call, :after, *filters, &block)
end
def after_success(*filters, &block)
set_callback(:success, :after, *filters, &block)
end
def after_failure(*filters, &block)
set_callback(:failure, :after, *filters, &block)
end
end
end
end
solid-process-0.5.0/lib/solid/process/caller.rb 0000664 0000000 0000000 00000001571 15136200163 0021430 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
# rubocop:disable Lint/RescueException
class Solid::Process
module Caller
def call(arg = nil)
output_already_set! if output?
self.input = arg
run_callbacks(:call) do
::Solid::Result.event_logs(name: self.class.name) do
self.output =
if dependencies&.invalid?
Failure(:invalid_dependencies, dependencies: dependencies)
elsif input.invalid?
Failure(:invalid_input, input: input)
else
super(input.attributes.symbolize_keys)
end
rescue ::Exception => exception
rescue_with_handler(exception) || raise
output
end
end
run_callbacks(:success) if output.success?
run_callbacks(:failure) if output.failure?
output
end
end
end
# rubocop:enable Lint/RescueException
solid-process-0.5.0/lib/solid/process/class_methods.rb 0000664 0000000 0000000 00000002215 15136200163 0023012 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Process
module ClassMethods
def input=(klass)
const_defined?(:Input, false) and raise Error, "#{const_get(:Input, false)} class already defined"
const_set(:Input, Config::SolidModel[klass])
end
def input(&block)
return const_get(:Input, false) if const_defined?(:Input, false)
block.nil? and raise Error, "#{self}::Input is undefined. Use #{self}.input { ... } to define it."
klass = ::Class.new(Config.instance.input_class)
klass.class_eval(&block)
self.input = klass
end
def dependencies=(klass)
const_defined?(:Dependencies, false) and raise Error, "#{const_get(:Dependencies, false)} class already defined"
const_set(:Dependencies, Config::SolidModel[klass])
end
def dependencies(&block)
return const_get(:Dependencies, false) if const_defined?(:Dependencies, false)
return if block.nil?
klass = ::Class.new(Config.instance.dependencies_class)
klass.class_eval(&block)
self.dependencies = klass
end
alias_method :deps, :dependencies
alias_method :deps=, :dependencies=
end
end
solid-process-0.5.0/lib/solid/process/config.rb 0000664 0000000 0000000 00000001426 15136200163 0021432 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Process
class Config
SolidModel = ->(klass) do
return klass if klass.is_a?(::Class) && klass < ::Solid::Model
raise ArgumentError, "#{klass.inspect} must be a class that includes #{::Solid::Model}"
end
attr_reader :input_class, :dependencies_class
def initialize
self.input_class = ::Solid::Input
self.dependencies_class = ::Solid::Input
end
def input_class=(klass)
@input_class = SolidModel[klass]
end
def dependencies_class=(klass)
@dependencies_class = SolidModel[klass]
end
alias_method :deps_class, :dependencies_class
alias_method :deps_class=, :dependencies_class=
class << self
attr_reader :instance
end
@instance = new
end
end
solid-process-0.5.0/lib/solid/process/error.rb 0000664 0000000 0000000 00000000137 15136200163 0021314 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Process
Error = ::Class.new(::StandardError)
end
solid-process-0.5.0/lib/solid/process/event_logs.rb 0000664 0000000 0000000 00000000211 15136200163 0022321 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Process
module EventLogs
require_relative "event_logs/basic_logger_listener"
end
end
solid-process-0.5.0/lib/solid/process/event_logs/ 0000775 0000000 0000000 00000000000 15136200163 0022002 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/lib/solid/process/event_logs/basic_logger_listener.rb 0000664 0000000 0000000 00000004244 15136200163 0026660 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Process::EventLogs::BasicLoggerListener
include Solid::Result::EventLogs::Listener
class_attribute :logger, :backtrace_cleaner
self.logger = ActiveSupport::Logger.new($stdout)
self.backtrace_cleaner = Solid::Process::BacktraceCleaner.new
module MessagesNesting
MAP_STEP_METHOD = lambda do |record_result|
kind, type, value = record_result.values_at(:kind, :type, :value)
value_keys = "#{value.keys.join(":, ")}:"
value_keys = "" if value_keys == ":"
case type
when :_given_ then "Given(#{value_keys})"
when :_continue_ then "Continue(#{value_keys})"
else "#{kind.capitalize}(:#{type}, #{value_keys})"
end
end
MAP_STEP_MESSAGE = lambda do |record|
step = MAP_STEP_METHOD[record[:result]]
method_name = record.dig(:and_then, :method_name)
" * #{step} from method: #{method_name}".chomp("from method: ").chomp(" ")
end
MAP_IDS_WITH_MESSAGES = lambda do |records|
process_ids = []
records.each_with_object([]) do |record, messages|
current = record[:current]
current_id = current[:id]
unless process_ids.include?(current_id)
process_ids << current_id
id, name, desc = current.values_at(:id, :name, :desc)
messages << [current_id, "##{id} #{name} - #{desc}".chomp("- ").chomp(" ")]
end
messages << [current_id, MAP_STEP_MESSAGE[record]]
end
end
def self.map(event_logs)
ids_level_parent = event_logs.dig(:metadata, :ids, :level_parent)
messages = MAP_IDS_WITH_MESSAGES[event_logs[:records]]
messages.map { |(id, msg)| "#{" " * ids_level_parent[id].first}#{msg}" }
end
end
def on_finish(event_logs:)
messages = MessagesNesting.map(event_logs)
logger.info messages.join("\n")
end
def before_interruption(exception:, event_logs:)
messages = MessagesNesting.map(event_logs)
logger.info messages.join("\n")
cleaned_backtrace = backtrace_cleaner.clean(exception.backtrace).join("\n ")
logger.error "\nException:\n #{exception.message} (#{exception.class})\n\nBacktrace:\n #{cleaned_backtrace}"
end
end
solid-process-0.5.0/lib/solid/process/version.rb 0000664 0000000 0000000 00000000134 15136200163 0021645 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid
class Process
VERSION = "0.5.0"
end
end
solid-process-0.5.0/lib/solid/validators.rb 0000664 0000000 0000000 00000000533 15136200163 0020655 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid
module Validators
def self.add_error(model, attribute, message, options)
if ActiveModel.const_defined?(:Error)
model.errors.add(attribute, **options.merge(message: message))
else
model.errors.add(attribute, options.fetch(:message, message))
end
end
end
end
solid-process-0.5.0/lib/solid/validators/ 0000775 0000000 0000000 00000000000 15136200163 0020327 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/lib/solid/validators/email_validator.rb 0000664 0000000 0000000 00000000526 15136200163 0024013 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class EmailValidator < ActiveModel::EachValidator
def validate_each(model, attribute, value)
return model.errors.add(attribute, :blank, **options) if value.blank?
return if value.is_a?(String) && URI::MailTo::EMAIL_REGEXP.match?(value)
model.errors.add(attribute, :invalid, **options)
end
end
solid-process-0.5.0/lib/solid/validators/id_validator.rb 0000664 0000000 0000000 00000000673 15136200163 0023323 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "solid/validators"
class IdValidator < ActiveModel::EachValidator
OPTIONS = {only_integer: true, greater_than: 0}.freeze
def validate_each(model, attribute, value)
opts = OPTIONS.merge(options.except(*OPTIONS.keys))
opts[:attributes] = attribute
::ActiveModel::Validations::NumericalityValidator.new(opts).validate_each(model, attribute, value)
end
private_constant :OPTIONS
end
solid-process-0.5.0/lib/solid/validators/instance_of_validator.rb 0000664 0000000 0000000 00000000675 15136200163 0025221 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "solid/validators"
class InstanceOfValidator < ActiveModel::EachValidator
def validate_each(model, attribute, value)
with_option = Array.wrap(options[:with] || options[:in])
return if with_option.any? { |type| value.instance_of?(type) }
message = "is not an instance of #{with_option.map(&:name).join(" | ")}"
Solid::Validators.add_error(model, attribute, message, options)
end
end
solid-process-0.5.0/lib/solid/validators/is_validator.rb 0000664 0000000 0000000 00000001123 15136200163 0023331 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "solid/validators"
class IsValidator < ActiveModel::EachValidator
def validate_each(model, attribute, value)
with_option = Array.wrap(options[:with] || options[:in])
return if with_option.all? do |predicate|
raise ArgumentError, "expected a predicate method, got #{predicate.inspect}" unless predicate.end_with?("?")
value.try(predicate)
end
message = "does not satisfy the predicate#{"s" if with_option.size > 1}: #{with_option.join(" & ")}"
Solid::Validators.add_error(model, attribute, message, options)
end
end
solid-process-0.5.0/lib/solid/validators/kind_of_validator.rb 0000664 0000000 0000000 00000000645 15136200163 0024337 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "solid/validators"
class KindOfValidator < ActiveModel::EachValidator
def validate_each(model, attribute, value)
with_option = Array.wrap(options[:with] || options[:in])
return if with_option.any? { |type| value.is_a?(type) }
message = "is not a #{with_option.map(&:name).join(" | ")}"
Solid::Validators.add_error(model, attribute, message, options)
end
end
solid-process-0.5.0/lib/solid/validators/respond_to_validator.rb 0000664 0000000 0000000 00000000663 15136200163 0025102 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "solid/validators"
class RespondToValidator < ActiveModel::EachValidator
def validate_each(model, attribute, value)
with_option = Array.wrap(options[:with] || options[:in])
return if with_option.all? { value.respond_to?(_1) }
message = "does not respond to #{with_option.map(&:inspect).join(" & ")}"
Solid::Validators.add_error(model, attribute, message, options)
end
end
solid-process-0.5.0/lib/solid/validators/singleton_validator.rb 0000664 0000000 0000000 00000001253 15136200163 0024724 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "solid/validators"
class SingletonValidator < ActiveModel::EachValidator
def validate_each(model, attribute, value)
with_option = Array.wrap(options[:with] || options[:in])
return model.errors.add(attribute, options[:message] || "is not a class or module") unless value.is_a?(Module)
return if with_option.any? do |type|
raise ArgumentError, "#{type.inspect} is not a class or module" unless type.is_a?(Module)
value == type || (value < type || value.is_a?(type))
end
message = "is not #{with_option.map(&:name).join(" | ")}"
Solid::Validators.add_error(model, attribute, message, options)
end
end
solid-process-0.5.0/lib/solid/validators/uuid_validator.rb 0000664 0000000 0000000 00000001200 15136200163 0023660 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class UuidValidator < ActiveModel::EachValidator
PATTERN = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
CASE_SENSITIVE = /\A#{PATTERN}\z/.freeze
CASE_INSENSITIVE = /\A#{PATTERN}\z/i.freeze
def validate_each(model, attribute, value)
case_sensitive = options.fetch(:case_sensitive, true)
return model.errors.add(attribute, :blank, **options) if value.blank?
regexp = case_sensitive ? CASE_SENSITIVE : CASE_INSENSITIVE
return if value.is_a?(String) && value.match?(regexp)
model.errors.add(attribute, :invalid, **options)
end
private_constant :PATTERN
end
solid-process-0.5.0/lib/solid/value.rb 0000664 0000000 0000000 00000001230 15136200163 0017614 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Value
module ClassMethods
UNDEFINED = ::Object.new
def new(value = UNDEFINED)
return value if value.is_a?(self)
UNDEFINED.equal?(value) ? super() : super(value: value)
end
def attribute(...)
super(:value, ...)
end
def validates(...)
super(:value, ...)
end
end
def self.included(subclass)
subclass.include Solid::Model
subclass.extend ClassMethods
subclass.attribute
end
def ==(other)
other.is_a?(self.class) && other.value == value
end
def hash
value.hash
end
def to_s
value.to_s
end
alias_method :eql?, :==
end
solid-process-0.5.0/solid-process.gemspec 0000664 0000000 0000000 00000003500 15136200163 0020430 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require_relative "lib/solid/process/version"
Gem::Specification.new do |spec|
spec.name = "solid-process"
spec.version = Solid::Process::VERSION
spec.authors = ["Rodrigo Serradura"]
spec.email = ["rodrigo.serradura@gmail.com"]
spec.summary = "Write business logic for Ruby/Rails that scales."
spec.description = "Write business logic for Ruby/Rails that scales."
spec.homepage = "https://github.com/serradura/solid-process"
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/serradura/solid-process"
spec.metadata["changelog_uri"] = "https://github.com/solid-process/solid-process/blob/main/CHANGELOG.md"
spec.metadata["rubygems_mfa_required"] = "true"
# Specify which files should be added to the gem when it is released.
# The `git ls-files -z` loads the files in the RubyGem that have been added into git.
spec.files = Dir.chdir(__dir__) do
`git ls-files -z`.split("\x0").reject do |f|
(File.expand_path(f) == __FILE__) ||
f.start_with?(*%w[
.git .github appveyor
bin/ test/ spec/ features/ coverage/ gemfiles/
Gemfile Appraisals
.rubocop.yml .standard.yml
])
end
end
spec.bindir = "exe"
spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
spec.require_paths = ["lib"]
# Uncomment to register a new dependency of your gem
spec.add_dependency "solid-result", "~> 2.0"
spec.add_dependency "activemodel", ">= 6.0"
spec.add_development_dependency "appraisal", "~> 2.5"
# For more information and examples about making a new gem, check out our
# guide at: https://bundler.io/guides/creating_gem.html
end
solid-process-0.5.0/test/ 0000775 0000000 0000000 00000000000 15136200163 0015256 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/solid/ 0000775 0000000 0000000 00000000000 15136200163 0016370 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/solid/input_test.rb 0000664 0000000 0000000 00000000340 15136200163 0021110 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::InputTest < ActiveSupport::TestCase
test "is a Solid::Model" do
assert_kind_of ::Class, Solid::Input
assert Solid::Input < Solid::Model
end
end
solid-process-0.5.0/test/solid/model/ 0000775 0000000 0000000 00000000000 15136200163 0017470 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/solid/model/access_test.rb 0000664 0000000 0000000 00000004010 15136200163 0022310 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::ModelAccessTest < ActiveSupport::TestCase
class Person
include Solid::Model
attribute :uuid, :string
attribute :name, :string
attribute :email, :string
end
test "#[]" do
person = Person.new(
uuid: SecureRandom.uuid,
name: "John Doe",
email: "john.doe@example.com"
)
assert_equal(person.uuid, person[:uuid])
assert_equal(person.name, person[:name])
assert_equal(person.email, person[:email])
assert_equal(person.uuid, person["uuid"])
assert_equal(person.name, person["name"])
assert_equal(person.email, person["email"])
end
test "#slice" do
person = Person.new(
uuid: SecureRandom.uuid,
name: "John Doe",
email: "john.doe@example.com"
)
slice1 = person.slice(:uuid, :name, :email)
slice2 = person.slice(:uuid, :email)
slice3 = person.slice(:name)
assert_equal(
{"uuid" => person.uuid, "name" => person.name, "email" => person.email},
slice1
)
assert_instance_of(ActiveSupport::HashWithIndifferentAccess, slice1)
assert_equal({"uuid" => person.uuid, "email" => person.email}, slice2)
assert_instance_of(ActiveSupport::HashWithIndifferentAccess, slice2)
assert_equal({"name" => person.name}, slice3)
assert_instance_of(ActiveSupport::HashWithIndifferentAccess, slice3)
assert_empty(person.slice)
assert_instance_of(ActiveSupport::HashWithIndifferentAccess, person.slice)
end
test "#values_at" do
person = Person.new(
uuid: SecureRandom.uuid,
name: "John Doe",
email: "john.doe@example.com"
)
values1 = person.values_at(:uuid, :name, :email)
values2 = person.values_at(:uuid, :email)
values3 = person.values_at(:name)
assert_equal([person.uuid, person.name, person.email], values1)
assert_equal([person.uuid, person.email], values2)
assert_equal([person.name], values3)
assert_empty(person.values_at)
assert_instance_of(Array, person.values_at)
end
end
solid-process-0.5.0/test/solid/model/callbacks_test.rb 0000664 0000000 0000000 00000002002 15136200163 0022765 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::ModelCallbacksTest < ActiveSupport::TestCase
class MyModel
include Solid::Model
attribute :after_initialize_value1
attribute :after_initialize_value2
attribute :before_validation_value
attribute :after_validation_value
after_initialize do
self.after_initialize_value1 = "foo"
end
before_validation do
self.before_validation_value = "bar"
end
after_validation do
self.after_validation_value = "baz"
end
end
test "the callbacks" do
model = MyModel.new
assert_equal("foo", model.after_initialize_value1)
assert_nil(model.after_initialize_value2)
assert_nil(model.before_validation_value)
assert_nil(model.after_validation_value)
model.valid?
assert_equal("foo", model.after_initialize_value1)
assert_nil(model.after_initialize_value2)
assert_equal("bar", model.before_validation_value)
assert_equal("baz", model.after_validation_value)
end
end
solid-process-0.5.0/test/solid/model/class_test.rb 0000664 0000000 0000000 00000004157 15136200163 0022170 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::ModelClassTest < ActiveSupport::TestCase
class ModelWithDefaults
include Solid::Model
attribute :uuid, :string, default: -> { SecureRandom.uuid }
end
test "model with default values" do
uuid = SecureRandom.uuid
model1 = ModelWithDefaults.new
model2 = ModelWithDefaults.new(uuid: uuid)
assert_match TestUtils::UUID_REGEX, model1.uuid
assert_equal uuid, model2.uuid
end
class ModelWithNormalization
include Solid::Model
attribute :uuid, :string
before_validation do |model|
model.uuid = model.uuid.strip.downcase
end
end
test "model with normalization (before_validation)" do
uuid = SecureRandom.uuid
model = ModelWithNormalization.new(uuid: " #{uuid.upcase} ")
model.valid?
assert_equal uuid, model.uuid
end
class ModelWithValidation
include Solid::Model
attribute :uuid, :string
validates :uuid, presence: true, format: {with: TestUtils::UUID_REGEX}
end
test "model with validation" do
model1 = ModelWithValidation.new
model2 = ModelWithValidation.new(uuid: " ")
model3 = ModelWithValidation.new(uuid: "invalid")
model4 = ModelWithValidation.new(uuid: SecureRandom.uuid)
assert_predicate model1, :invalid?
assert_predicate model2, :invalid?
assert_predicate model3, :invalid?
assert_predicate model4, :valid?
end
test "model ancestors" do
model_class = [ModelWithDefaults, ModelWithNormalization, ModelWithValidation].sample
ancestors = model_class.ancestors
assert_includes ancestors, Solid::Model
if ActiveModel.const_defined?(:Api, false)
assert_includes ancestors, ActiveModel::Api
else
assert_includes ancestors, ActiveModel::Model
end
if ActiveModel.const_defined?(:Access, false)
assert_includes ancestors, ActiveModel::Access
else
assert_includes ancestors, Solid::Model::Access
end
assert_includes ancestors, ActiveModel::Attributes
assert_includes ancestors, ActiveModel::Dirty
assert_includes ancestors, ActiveModel::Validations::Callbacks
end
end
solid-process-0.5.0/test/solid/model/instantiation_test.rb 0000664 0000000 0000000 00000000654 15136200163 0023745 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::ModelInstantiationTest < ActiveSupport::TestCase
class MyModel < Solid::Input
attribute :uuid, :string, default: -> { SecureRandom.uuid }
end
test "the new alias" do
uuid = SecureRandom.uuid
model1 = MyModel[]
model2 = MyModel[uuid: uuid]
assert_match TestUtils::UUID_REGEX, model1.uuid
assert_equal uuid, model2.uuid
end
end
solid-process-0.5.0/test/solid/output/ 0000775 0000000 0000000 00000000000 15136200163 0017730 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/solid/output/methods_test.rb 0000664 0000000 0000000 00000002323 15136200163 0022757 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::OutputMethodsTest < ActiveSupport::TestCase
test "Solid::Success() with type" do
result = Solid::Success(:ok)
assert_instance_of(Solid::Output::Success, result)
assert_kind_of(Solid::Success, result)
assert result.success?(:ok)
assert_empty result.value
assert_instance_of Hash, result.value
end
test "Solid::Success() with type and value" do
result = Solid::Success(:ok, one: 1)
assert_instance_of(Solid::Output::Success, result)
assert_kind_of(Solid::Success, result)
assert result.success?(:ok)
assert_equal({one: 1}, result.value)
end
test "Solid::Failure() with type" do
result = Solid::Failure(:err)
assert_instance_of(Solid::Output::Failure, result)
assert_kind_of(Solid::Failure, result)
assert result.failure?(:err)
assert_empty result.value
assert_instance_of Hash, result.value
end
test "Solid::Failure() with type and value" do
result = Solid::Failure(:err, zero: 0)
assert_instance_of(Solid::Output::Failure, result)
assert_kind_of(Solid::Failure, result)
assert result.failure?(:err)
assert_equal({zero: 0}, result.value)
end
end
solid-process-0.5.0/test/solid/output/pattern_matching_test.rb 0000664 0000000 0000000 00000012401 15136200163 0024641 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::OutputPatterMatchingTest < ActiveSupport::TestCase
def setup
::User.delete_all
end
def user_creation
[
-> { UserCreationWithoutDeps.call(_1) },
-> { UserCreationWithoutDeps.new.call(_1) }
].sample
end
test "success" do
input = {name: "\tJohn Doe \n", email: " JOHN.doe@email.com", password: "123123123"}
result = assert_difference(
-> { User.count } => 1
) do
user_creation.call(input)
end
# --- Solid::Success ---
case result
in Solid::Success[:user_created, {user: user}]
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
case result
in Solid::Success(type: type, value: {user: user})
assert_equal(:user_created, type)
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
case result
in Solid::Success(type: type)
assert_equal(:user_created, type)
end
case result
in Solid::Success(value: {user: user})
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
case result
in Solid::Success(user: user)
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
# --- Solid::Result ---
case result
in Solid::Result[:user_created, {user: user}]
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
case result
in Solid::Result(type: type, value: {user: user})
assert_equal(:user_created, type)
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
case result
in Solid::Result(type: type)
assert_equal(:user_created, type)
end
case result
in Solid::Result(value: {user: user})
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
case result
in Solid::Result(user: user)
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
# --- Solid::Output ---
case result
in Solid::Output[:user_created, {user: user}]
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
case result
in Solid::Output(type: type, value: {user: user})
assert_equal(:user_created, type)
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
case result
in Solid::Output(type: type)
assert_equal(:user_created, type)
end
case result
in Solid::Output(value: {user: user})
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
case result
in Solid::Output(user: user)
assert_match(TestUtils::UUID_REGEX, user.uuid)
end
end
test "failure (invalid_input)" do
input = {name: " ", email: "John", password: "123123"}
result = assert_no_difference(
-> { User.count }
) do
UserCreationWithoutDeps.call(input)
end
# --- Solid::Failure ---
case result
in Solid::Failure[:invalid_input, {input: input}]
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
case result
in Solid::Failure(type: type, value: {input: input})
assert_equal(:invalid_input, type)
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
case result
in Solid::Failure(type: type)
assert_equal(:invalid_input, type)
end
case result
in Solid::Failure(value: {input: input})
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
case result
in Solid::Failure(input: input)
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
# --- Solid::Result ---
case result
in Solid::Result[:invalid_input, {input: input}]
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
case result
in Solid::Result(type: type, value: {input: input})
assert_equal(:invalid_input, type)
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
case result
in Solid::Result(type: type)
assert_equal(:invalid_input, type)
end
case result
in Solid::Result(value: {input: input})
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
case result
in Solid::Result(input: input)
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
# --- Solid::Output ---
case result
in Solid::Output[:invalid_input, {input: input}]
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
case result
in Solid::Output(type: type, value: {input: input})
assert_equal(:invalid_input, type)
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
case result
in Solid::Output(type: type)
assert_equal(:invalid_input, type)
end
case result
in Solid::Output(value: {input: input})
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
case result
in Solid::Output(input: input)
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
end
end
end
solid-process-0.5.0/test/solid/process/ 0000775 0000000 0000000 00000000000 15136200163 0020046 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/solid/process/backtrace_cleaner_test.rb 0000664 0000000 0000000 00000003172 15136200163 0025045 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::BacktraceCleanerTest < ActiveSupport::TestCase
setup do
@backtrace_cleaner = Solid::Process::BacktraceCleaner.new
# This silencer is unnecessary in an application as solid-process will be a gem.
@backtrace_cleaner.add_silencer { |line| line.include?("lib/solid/process") }
end
teardown do
RuntimeBreaker.reset!
Account::Member.delete_all
User::Token.delete_all
Account.delete_all
User.delete_all
end
test "should clean backtrace" do
RuntimeBreaker.interruption = "USER_TOKEN_CREATION"
exception = nil
assert_no_difference([
-> { Account::Member.count },
-> { User::Token.count },
-> { Account.count },
-> { User.count }
]) do
exception = assert_raises(RuntimeBreaker::Interruption) do
Account::OwnerCreation.call(
owner: {
name: "John Doe",
email: "email@johndoe.com",
password: "password",
password_confirmation: "password"
}
)
end
end
cleaned_backtrace = @backtrace_cleaner.clean(exception.backtrace)
[
/runtime_breaker.rb:16:in .*try_to_interrupt'/,
/user_token_creation.rb:28:in .*create_token_if_not_exists'/,
/user_token_creation.rb:15:in .*call'/,
/user_creation.rb:61:in .*create_user_token'/,
/user_creation.rb:30:in .*call'/,
/account_owner_creation.rb:32:in .*create_owner'/,
/account_owner_creation.rb:21:in .*call'/
].each_with_index do |pattern, index|
assert_match pattern, cleaned_backtrace[index]
end
end
end
solid-process-0.5.0/test/solid/process/callbacks/ 0000775 0000000 0000000 00000000000 15136200163 0021765 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/solid/process/callbacks/after_test.rb 0000664 0000000 0000000 00000005244 15136200163 0024457 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::CallbacksAfterTest < ActiveSupport::TestCase
class PersonCreation < Solid::Process
input do
attribute :uuid, :string, default: -> { SecureRandom.uuid }
attribute :name, :string
attribute :email, :string
before_validation do |input|
input.name = input.name.strip
input.email = input.email.strip.downcase
end
validates :name, presence: true
validates :uuid, presence: true, format: {with: TestUtils::UUID_REGEX}
validates :email, presence: true, format: {with: TestUtils::EMAIL_REGEX}
end
attr_reader :callback_numbers
def initialize(...)
super
@callback_numbers = Hash.new { |hash, key| hash[key] = [] }
end
after_success do |process|
callback_numbers[:after_success] << 1
end
after_success if: -> { output.is?(:person_created) } do
callback_numbers[:after_success] << 2
end
after_success if: :person_created? do
callback_numbers[:after_success] << 3
end
after_success if: :user_created? do
callback_numbers[:after_success] << 4
end
after_failure do |process|
callback_numbers[:after_failure] << -1
end
after_failure if: -> { output.is?(:invalid_input) } do
callback_numbers[:after_failure] << -2
end
after_failure if: :invalid_input? do
callback_numbers[:after_failure] << -3
end
after_failure if: :invalid_person? do
callback_numbers[:after_failure] << -4
end
after_call do
callback_numbers[:after_call] << 0.0
end
after_call if: :success? do
callback_numbers[:after_call] << 0.1
end
after_call if: :failure? do
callback_numbers[:after_call] << -0.1
end
def call(attributes)
person = attributes.fetch_values(:uuid, :name, :email)
Success(:person_created, person: person)
end
end
test "after success" do
person_creation = PersonCreation.new
result = person_creation.call(
uuid: SecureRandom.uuid,
name: "John Doe",
email: "john.doe@email.com"
)
assert result.is?(:person_created)
assert_equal(
{
after_call: [0.1, 0.0],
after_success: [3, 2, 1]
},
person_creation.callback_numbers
)
end
test "after failure" do
person_creation = PersonCreation.new
result = person_creation.call(
uuid: SecureRandom.uuid,
name: "",
email: "invalid-email"
)
assert result.is?(:invalid_input)
assert_equal(
{
after_call: [-0.1, 0.0],
after_failure: [-3, -2, -1]
},
person_creation.callback_numbers
)
end
end
solid-process-0.5.0/test/solid/process/callbacks/around_call_test.rb 0000664 0000000 0000000 00000003221 15136200163 0025632 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::CallbacksAroundCallTest < ActiveSupport::TestCase
class PersonCreation < Solid::Process
input do
attribute :name, :string
attribute :email, :string
before_validation do |input|
input.name = input.name.strip
input.email = input.email.strip.downcase
end
validates :name, presence: true
validates :email, presence: true, format: {with: TestUtils::EMAIL_REGEX}
end
attr_reader :callback_data
def initialize(...)
super
@callback_data = {before: {}, after: {}}
end
around_call do |process, block|
raise unless equal?(process)
@callback_data[:before][:name] = input.name
@callback_data[:before][:email] = input.email
block.call
@callback_data[:after][:name] = input.name
@callback_data[:after][:email] = input.email
end
def call(attributes)
person = attributes.fetch_values(:name, :email)
Success(:person_created, person: person)
end
end
test "around call" do
person_creation = PersonCreation.new
person_creation.call(name: " John Doe\n", email: " JOHN.doE@email.com ")
assert_equal(" John Doe\n", person_creation.callback_data[:before][:name])
assert_equal(" JOHN.doE@email.com ", person_creation.callback_data[:before][:email])
assert_equal("John Doe", person_creation.callback_data[:after][:name])
assert_equal("john.doe@email.com", person_creation.callback_data[:after][:email])
assert_equal("John Doe", person_creation.input.name)
assert_equal("john.doe@email.com", person_creation.input.email)
end
end
solid-process-0.5.0/test/solid/process/callbacks/before_call_test.rb 0000664 0000000 0000000 00000002412 15136200163 0025605 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::CallbacksBeforeCallTest < ActiveSupport::TestCase
class PersonCreation < Solid::Process
input do
attribute :name, :string
attribute :email, :string
before_validation do |input|
input.name = input.name.strip
input.email = input.email.strip.downcase
end
validates :name, presence: true
validates :email, presence: true, format: {with: TestUtils::EMAIL_REGEX}
end
attr_reader :callback_data
def initialize(...)
super
@callback_data = {}
end
before_call do
@callback_data[:name] = input.name
@callback_data[:email] = input.email
end
def call(attributes)
person = attributes.fetch_values(:name, :email)
Success(:person_created, person: person)
end
end
test "before call" do
person_creation = PersonCreation.new
person_creation.call(name: " John Doe\n", email: " JOHN.doE@email.com ")
assert_equal(" John Doe\n", person_creation.callback_data[:name])
assert_equal(" JOHN.doE@email.com ", person_creation.callback_data[:email])
assert_equal("John Doe", person_creation.input.name)
assert_equal("john.doe@email.com", person_creation.input.email)
end
end
solid-process-0.5.0/test/solid/process/config_test.rb 0000664 0000000 0000000 00000004306 15136200163 0022702 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::ConfigTest < ActiveSupport::TestCase
class MyInput
include Solid::Model
end
class MyDeps
include Solid::Model
end
test ".configuration" do
original_config_instance = Solid::Process::Config.instance
new_config = Solid::Process::Config.new
Solid::Process::Config.instance_variable_set(:@instance, new_config)
assert_same new_config, Solid::Process.config
Solid::Process.configuration do |config|
assert_same new_config, config
refute_predicate config, :frozen?
end
assert_predicate new_config, :frozen?
ensure
Solid::Process::Config.instance_variable_set(:@instance, original_config_instance)
end
test ".cofigure" do
assert_equal Solid::Process.method(:configuration), Solid::Process.method(:configure)
end
test ".config" do
assert_instance_of Solid::Process::Config, Solid::Process.config
assert_same Solid::Process::Config.instance, Solid::Process.config
end
test "config.input_class=" do
original_input_class = Solid::Process.config.input_class
Solid::Process.config.input_class = MyInput
assert_equal MyInput, Solid::Process.config.input_class
klass = Class.new(Solid::Process) do
deps do
attribute :bar
end
input do
attribute :foo
end
def self.name
"MyProcess"
end
end
assert_operator klass.input, :<, MyInput
assert_operator klass.dependencies, :<, ::Solid::Input
ensure
Solid::Process.config.input_class = original_input_class
end
test "config.dependencies_class=" do
original_dependencies_class = Solid::Process.config.dependencies_class
Solid::Process.config.dependencies_class = MyDeps
assert_equal MyDeps, Solid::Process.config.dependencies_class
klass = Class.new(Solid::Process) do
deps do
attribute :bar
end
input do
attribute :foo
end
def self.name
"MyProcess"
end
end
assert_operator klass.input, :<, ::Solid::Input
assert_operator klass.dependencies, :<, MyDeps
ensure
Solid::Process.config.dependencies_class = original_dependencies_class
end
end
solid-process-0.5.0/test/solid/process/dependencies/ 0000775 0000000 0000000 00000000000 15136200163 0022474 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/solid/process/dependencies/assignment_alias_test.rb 0000664 0000000 0000000 00000003277 15136200163 0027412 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::DependenciesAssignmentAliasTest < ActiveSupport::TestCase
class PersonDependencies < Solid::Input
attribute :struct, default: Struct.new(:uuid, :name)
end
class PersonCreation < Solid::Process
self.deps = PersonDependencies
input do
attribute :uuid, :string, default: -> { SecureRandom.uuid }
attribute :name, :string
end
def call(attributes)
person = deps.struct.new(*attributes.fetch_values(:uuid, :name))
Success(:person_created, person: person)
end
end
test "the process dependencies" do
assert_same PersonCreation::Dependencies, PersonCreation.deps
assert_operator PersonCreation::Dependencies, :<, Solid::Input
struct = PersonCreation.deps.new.struct.new("uuid", "name")
assert_equal "uuid", struct.uuid
assert_equal "name", struct.name
end
test "the process calling" do
uuid = SecureRandom.uuid
result = PersonCreation.call(
uuid: uuid,
name: "John Doe"
)
assert result.success?(:person_created)
person = result.value.fetch(:person)
assert_match uuid, person.uuid
assert_equal "John Doe", person.name
end
test "the assignment of an invalid class" do
err = assert_raises ArgumentError do
Class.new(Solid::Process) do
self.deps = String
end
end
assert_equal "String must be a class that includes Solid::Model", err.message
end
test "the assignment after the class definition" do
err = assert_raises Solid::Process::Error do
PersonCreation.deps = String
end
assert_equal "#{PersonCreation::Dependencies} class already defined", err.message
end
end
solid-process-0.5.0/test/solid/process/dependencies/assignment_test.rb 0000664 0000000 0000000 00000003352 15136200163 0026233 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::DependenciesAssignmentTest < ActiveSupport::TestCase
class PersonDependencies < Solid::Input
attribute :struct, default: Struct.new(:uuid, :name)
end
class PersonCreation < Solid::Process
self.dependencies = PersonDependencies
input do
attribute :uuid, :string, default: -> { SecureRandom.uuid }
attribute :name, :string
end
def call(attributes)
person = dependencies.struct.new(*attributes.fetch_values(:uuid, :name))
Success(:person_created, person: person)
end
end
test "the process dependencies" do
assert_same PersonCreation::Dependencies, PersonCreation.dependencies
assert_operator PersonCreation::Dependencies, :<, Solid::Input
struct = PersonCreation.dependencies.new.struct.new("uuid", "name")
assert_equal "uuid", struct.uuid
assert_equal "name", struct.name
end
test "the process calling" do
uuid = SecureRandom.uuid
result = PersonCreation.call(
uuid: uuid,
name: "John Doe"
)
assert result.success?(:person_created)
person = result.value.fetch(:person)
assert_match uuid, person.uuid
assert_equal "John Doe", person.name
end
test "the assignment of an invalid class" do
err = assert_raises ArgumentError do
Class.new(Solid::Process) do
self.dependencies = String
end
end
assert_equal "String must be a class that includes Solid::Model", err.message
end
test "the assignment after the class definition" do
err = assert_raises Solid::Process::Error do
PersonCreation.dependencies = String
end
assert_equal "#{PersonCreation::Dependencies} class already defined", err.message
end
end
solid-process-0.5.0/test/solid/process/dependencies/result_test.rb 0000664 0000000 0000000 00000006104 15136200163 0025377 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::DependenciesResultTest < ActiveSupport::TestCase
def setup
::User.delete_all
end
def user_creation
[
-> { UserCreationWithDeps.call(_1) },
-> { UserCreationWithDeps.new.call(_1) }
].sample
end
def map_input(data)
[data, UserCreationWithDeps::Input.new(data)].sample
end
test "failure (invalid_dependencies)" do
result = UserCreationWithDeps.new(repository: Object).call(name: "John", email: "john@email.com", password: "321321321")
assert_kind_of Solid::Result, result
assert_kind_of Solid::Failure, result
assert_predicate result, :invalid_dependencies?
assert result.is?(:invalid_dependencies)
assert result.type?(:invalid_dependencies)
assert result.failure?(:invalid_dependencies)
assert_equal [:dependencies], result.value.keys
dependencies = result.value.fetch(:dependencies)
assert_kind_of UserCreationWithDeps::Dependencies, dependencies
dependencies.errors.added? :repository, :invalid
end
test "success" do
password = "123123123"
input = map_input(name: "\tJohn Doe \n", email: " JOHN.doe@email.com", password: password)
result = assert_difference(-> { User.count } => 1) do
UserCreationWithDeps.new(repository: User).call(input)
end
assert_kind_of Solid::Result, result
assert_kind_of Solid::Success, result
assert_predicate result, :user_created?
assert result.is?(:user_created)
assert result.type?(:user_created)
assert result.success?(:user_created)
assert_equal [:user], result.value.keys
user = result.value.fetch(:user)
assert_match(TestUtils::UUID_REGEX, user.uuid)
assert_equal("John Doe", user.name)
assert_equal("john.doe@email.com", user.email)
assert BCrypt::Password.new(user.password_digest).is_password?(password)
end
test "failure (invalid_input)" do
input = map_input(name: nil, email: nil, password: nil)
result = assert_no_difference(-> { User.count }) { user_creation.call(input) }
assert_kind_of Solid::Result, result
assert_kind_of Solid::Failure, result
assert_predicate result, :invalid_input?
assert result.is?(:invalid_input)
assert result.type?(:invalid_input)
assert result.failure?(:invalid_input)
assert_equal [:input], result.value.keys
input = result.value[:input]
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithDeps::Input, input
input.errors.added? :name, :blank
input.errors.added? :email, :invalid
end
test "failure (email_already_taken)" do
input = map_input(name: "John Doe", email: "john.doe@email.com", password: "123123123")
user_creation.call(input)
result = assert_no_difference(-> { User.count }) do
UserCreationWithDeps.new(UserCreationWithDeps::Dependencies.new(repository: User)).call(input)
end
assert_predicate result, :email_already_taken?
assert result.is?(:email_already_taken)
assert result.type?(:email_already_taken)
assert result.failure?(:email_already_taken)
end
end
solid-process-0.5.0/test/solid/process/event_logs/ 0000775 0000000 0000000 00000000000 15136200163 0022213 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/solid/process/event_logs/basic_logger_listener_test.rb 0000664 0000000 0000000 00000010154 15136200163 0030125 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::EventLogs::BasicLoggerListenerTest < ActiveSupport::TestCase
# This silencer is unnecessary in an application as solid-process will be a gem.
Solid::Process::EventLogs::BasicLoggerListener
.backtrace_cleaner
.add_silencer { |line| line.match?(/lib\/solid\/process/) }
setup do
@original_listener = Solid::Result.config.event_logs.listener
@original_logger = Solid::Process::EventLogs::BasicLoggerListener.logger
@stdout = StringIO.new
Solid::Result.config.event_logs.listener = Solid::Process::EventLogs::BasicLoggerListener
Solid::Process::EventLogs::BasicLoggerListener.logger = ActiveSupport::Logger.new(@stdout)
end
teardown do
Solid::Result.config.event_logs.listener = @original_listener
Solid::Process::EventLogs::BasicLoggerListener.logger = @original_logger
RuntimeBreaker.reset!
Account::Member.delete_all
User::Token.delete_all
Account.delete_all
User.delete_all
end
test ".backtrace_cleaner" do
assert_instance_of(
Solid::Process::BacktraceCleaner,
Solid::Process::EventLogs::BasicLoggerListener.backtrace_cleaner
)
end
test ".logger" do
assert_instance_of(
ActiveSupport::Logger,
Solid::Process::EventLogs::BasicLoggerListener.logger
)
end
test "should log events" do
Account::OwnerCreation.call(
owner: {
name: "John Doe",
email: "email@johndoe.com",
password: "password",
password_confirmation: "password"
}
)
stdout_lines = @stdout.string.split("\n")
[
"#0 Account::OwnerCreation",
" * Given(uuid:, owner:)",
" #1 User::Creation",
" * Given(uuid:, name:, email:, password:, password_confirmation:)",
" * Continue() from method: validate_email_uniqueness",
" * Continue(user:) from method: create_user",
" #2 User::Token::Creation",
" * Given(user:, executed_at:)",
" * Continue() from method: validate_token_existence",
" * Continue(token:) from method: create_token_if_not_exists",
" * Success(:token_created, token:)",
" * Continue(token:) from method: create_user_token",
" * Success(:user_created, user:, token:)",
" * Continue(user:, user_token:) from method: create_owner",
" * Continue(account:) from method: create_account",
" * Continue() from method: link_owner_to_account",
" * Success(:account_owner_created, user:, account:)"
].each_with_index do |message, index|
assert_equal message, stdout_lines[index]
end
end
test "should log events with a backtrace when an exception is raised" do
RuntimeBreaker.interruption = "USER_TOKEN_CREATION"
assert_raises(RuntimeBreaker::Interruption) do
Account::OwnerCreation.call(
owner: {
name: "John Doe",
email: "email@johndoe.com",
password: "password",
password_confirmation: "password"
}
)
end
stdout_lines = @stdout.string.split("\n")
[
"#0 Account::OwnerCreation",
" * Given(uuid:, owner:)",
" #1 User::Creation",
" * Given(uuid:, name:, email:, password:, password_confirmation:)",
" * Continue() from method: validate_email_uniqueness",
" * Continue(user:) from method: create_user",
" #2 User::Token::Creation",
" * Given(user:, executed_at:)",
" * Continue() from method: validate_token_existence",
"",
"Exception:",
" Runtime breaker activated (USER_TOKEN_CREATION) (RuntimeBreaker::Interruption)",
"",
"Backtrace:",
/runtime_breaker.rb:16:in .*try_to_interrupt'/,
/user_token_creation.rb:28:in .*create_token_if_not_exists'/,
/user_token_creation.rb:15:in .*call'/,
/user_creation.rb:61:in .*create_user_token'/,
/user_creation.rb:30:in .*call'/,
/account_owner_creation.rb:32:in .*create_owner'/,
/account_owner_creation.rb:21:in .*call'/
].each_with_index do |message, index|
assert_match message, stdout_lines[index]
end
end
end
solid-process-0.5.0/test/solid/process/inheritance_test.rb 0000664 0000000 0000000 00000000637 15136200163 0023731 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::InheritanceTest < ActiveSupport::TestCase
class Foo < Solid::Process
input do
attribute :bar, :string
end
end
test "the error when the #call is not implemented" do
error = assert_raises(Solid::Process::Error) do
Foo.call
end
assert_match(/.+Foo#call must be implemented\./, error.message)
end
end
solid-process-0.5.0/test/solid/process/input/ 0000775 0000000 0000000 00000000000 15136200163 0021205 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/solid/process/input/access_test.rb 0000664 0000000 0000000 00000003473 15136200163 0024041 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::InputAccessTest < ActiveSupport::TestCase
PersonStruct = Struct.new(:uuid, :name, :email, keyword_init: true)
PersonStruct.include(Solid::Model::Access)
class PersonInput < Solid::Input
attribute :uuid, :string
attribute :name, :string
attribute :email, :string
end
test "#slice" do
uuid = SecureRandom.uuid
name = "John"
email = "john@example.com"
input = PersonInput.new(uuid: uuid, name: name, email: email)
struct = PersonStruct.new(uuid: uuid, name: name, email: email)
assert_equal({"uuid" => uuid}, input.slice(:uuid))
assert_equal({"uuid" => uuid}, struct.slice(:uuid))
assert_equal({"uuid" => uuid, "name" => name}, input.slice(:uuid, :name))
assert_equal({"uuid" => uuid, "name" => name}, struct.slice(:uuid, :name))
assert_equal({"uuid" => uuid, "name" => name, "email" => email}, input.slice(:uuid, :name, :email))
assert_equal({"uuid" => uuid, "name" => name, "email" => email}, struct.slice(:uuid, :name, :email))
assert_equal({}, input.slice)
assert_equal({}, struct.slice)
end
test "#values_at" do
uuid = SecureRandom.uuid
name = "John"
email = "john@example.com"
input = PersonInput.new(uuid: uuid, name: name, email: email)
struct = PersonStruct.new(uuid: uuid, name: name, email: email)
assert_equal [uuid], input.values_at(:uuid)
assert_equal [uuid], struct.values_at(:uuid)
assert_equal [uuid, name], input.values_at(:uuid, :name)
assert_equal [uuid, name], struct.values_at(:uuid, :name)
assert_equal [uuid, name, email], input.values_at(:uuid, :name, :email)
assert_equal [uuid, name, email], struct.values_at(:uuid, :name, :email)
assert_equal [], input.values_at
assert_equal [], struct.values_at
end
end
solid-process-0.5.0/test/solid/process/input/assignment_test.rb 0000664 0000000 0000000 00000004155 15136200163 0024746 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::InputAssignmentTest < ActiveSupport::TestCase
Person = Struct.new(:uuid, :name, :email)
class PersonInput < Solid::Input
attribute :uuid, :string, default: -> { SecureRandom.uuid }
attribute :name, :string
attribute :email, :string
before_validation do |input|
input.name = input.name.strip
input.email = input.email.strip.downcase
end
validates :name, presence: true
validates :uuid, presence: true, format: {with: TestUtils::UUID_REGEX}
validates :email, presence: true, format: {with: TestUtils::EMAIL_REGEX}
end
class PersonCreation < Solid::Process
self.input = PersonInput
def call(attributes)
person = Person.new(*attributes.fetch_values(:uuid, :name, :email))
Success(:person_created, person: person)
end
end
test "the process input" do
assert_same PersonCreation::Input, PersonCreation.input
input = PersonCreation::Input.new(
name: " John Doe\t",
email: " joHn.dOE@example.COM "
)
input.valid?
assert_match TestUtils::UUID_REGEX, input.uuid
assert_equal "John Doe", input.name
assert_equal "john.doe@example.com", input.email
end
test "the process calling" do
uuid = SecureRandom.uuid
result = PersonCreation.call(
uuid: uuid,
name: " John Doe\t",
email: " joHn.dOE@example.COM "
)
assert result.success?(:person_created)
person = result.value.fetch(:person)
assert_match uuid, person.uuid
assert_equal "John Doe", person.name
assert_equal "john.doe@example.com", person.email
end
test "the assignment of an invalid class" do
err = assert_raises ArgumentError do
Class.new(Solid::Process) do
self.input = String
end
end
assert_equal "String must be a class that includes Solid::Model", err.message
end
test "the assignment after the class definition" do
err = assert_raises Solid::Process::Error do
PersonCreation.input = String
end
assert_equal "#{PersonCreation::Input} class already defined", err.message
end
end
solid-process-0.5.0/test/solid/process/input/block_test.rb 0000664 0000000 0000000 00000003135 15136200163 0023665 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::InputBlockTest < ActiveSupport::TestCase
Person = Struct.new(:uuid, :name, :email)
class PersonCreation < Solid::Process
input do
attribute :uuid, :string, default: -> { SecureRandom.uuid }
attribute :name, :string
attribute :email, :string
before_validation do |input|
input.name = input.name.strip
input.email = input.email.strip.downcase
end
validates :name, presence: true
validates :uuid, presence: true, format: {with: TestUtils::UUID_REGEX}
validates :email, presence: true, format: {with: TestUtils::EMAIL_REGEX}
end
def call(attributes)
person = Person.new(*attributes.fetch_values(:uuid, :name, :email))
Success(:person_created, person: person)
end
end
test "the process input" do
assert_same PersonCreation::Input, PersonCreation.input
input = PersonCreation::Input.new(
name: " John Doe\t",
email: " joHn.dOE@example.COM "
)
input.valid?
assert_match TestUtils::UUID_REGEX, input.uuid
assert_equal "John Doe", input.name
assert_equal "john.doe@example.com", input.email
end
test "the process calling" do
uuid = SecureRandom.uuid
result = PersonCreation.call(
uuid: uuid,
name: " John Doe\t",
email: " joHn.dOE@example.COM "
)
assert result.success?(:person_created)
person = result.value.fetch(:person)
assert_match uuid, person.uuid
assert_equal "John Doe", person.name
assert_equal "john.doe@example.com", person.email
end
end
solid-process-0.5.0/test/solid/process/input/inspect_test.rb 0000664 0000000 0000000 00000001037 15136200163 0024237 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::InputInspectTest < ActiveSupport::TestCase
class PersonInput < Solid::Input
attribute :uuid, :string
attribute :name, :string
attribute :email, :string
end
test "#inspect" do
uuid = SecureRandom.uuid
name = "John"
email = "john@example.com"
input = PersonInput.new(uuid: uuid, name: name, email: email)
assert_match(/#<.+PersonInput uuid=#{uuid.inspect} name=#{name.inspect} email=#{email.inspect}>/, input.inspect)
end
end
solid-process-0.5.0/test/solid/process/input/undefined_test.rb 0000664 0000000 0000000 00000000632 15136200163 0024533 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::InputUndefinedTest < ActiveSupport::TestCase
Foo = Class.new(Solid::Process)
test "the error when the input is undefined" do
error = assert_raises(Solid::Process::Error) do
Foo.call
end
assert_match(
/.+Foo::Input is undefined. Use .+Foo.input { ... } to define it./,
error.message
)
end
end
solid-process-0.5.0/test/solid/process/instance_test.rb 0000664 0000000 0000000 00000022307 15136200163 0023242 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::ProcessInstanceTest < ActiveSupport::TestCase
def setup
::User.delete_all
end
test "#call when the output is already set" do
user_creation = UserCreationWithoutDeps.new
user_creation.call(name: nil, email: nil)
err = assert_raises(Solid::Process::Error) do
user_creation.call(name: nil, email: nil)
end
assert_equal(
"The `UserCreationWithoutDeps#output` is already set. " \
"Use `.output` to access the result or create a new instance to call again.",
err.message
)
end
test "#new" do
user_creation = UserCreationWithoutDeps.new
user_creation.call(name: nil, email: nil)
assert_raises(Solid::Process::Error) { user_creation.call(name: nil, email: nil) }
new_user_creation = user_creation.new
assert new_user_creation.call(name: nil, email: nil).failure?(:invalid_input)
assert_difference(-> { User.count } => 1) do
new_user_creation.new.call(name: "Foo", email: "foo@foo.com", password: "123123123")
end
# ---
create_user = UserCreationWithDeps.new
create_user.call(name: nil, email: nil)
assert_raises(Solid::Process::Error) { create_user.call(name: nil, email: nil) }
new_create_user = create_user.new(repository: ::Object)
assert new_create_user.call(name: nil, email: nil).failure?(:invalid_dependencies)
assert_difference(-> { User.count } => 1) do
create_user.new.call(name: "Bar", email: "bar@bar.com", password: "123123123")
end
end
test "#input" do
user_creation1 = UserCreationWithoutDeps.new
assert_nil user_creation1.input
user_creation1.call(name: "\tJohn Doe \n", email: " JOHN.doe@email.com", password: "123123123")
assert_match(TestUtils::UUID_REGEX, user_creation1.input.uuid)
assert_equal("John Doe", user_creation1.input.name)
assert_equal("john.doe@email.com", user_creation1.input.email)
# ---
user_creation2 = UserCreationWithoutDeps.new
assert_nil user_creation2.input
user_creation2.call(uuid: "", name: nil, email: nil)
refute_match(TestUtils::UUID_REGEX, user_creation2.input.uuid)
assert_nil user_creation2.input.name
assert_nil user_creation2.input.email
end
test "#input?" do
user_creation1 = UserCreationWithoutDeps.new
refute_predicate user_creation1, :input?
user_creation1.call(name: "\tJohn Doe \n", email: " JOHN.doe@email.com", password: "123123123")
assert_predicate user_creation1, :input?
# ---
user_creation2 = UserCreationWithoutDeps.new
refute_predicate user_creation2, :input?
user_creation2.call(uuid: "", name: nil, email: nil)
assert_predicate user_creation2, :input?
end
test "#output" do
user_creation1 = UserCreationWithoutDeps.new
assert_nil user_creation1.output
assert_nil user_creation1.result
result = user_creation1.call(name: "John Doe", email: " JOHN.doe@email.com", password: "123123123")
assert_same result, user_creation1.output
assert_same result, user_creation1.result
# ---
user_creation2 = UserCreationWithoutDeps.new
assert_nil user_creation2.output
assert_nil user_creation2.result
result = user_creation2.call(uuid: "", name: nil, email: nil)
assert_same result, user_creation2.output
assert_same result, user_creation2.result
end
test "#output?" do
user_creation1 = UserCreationWithoutDeps.new
refute_predicate user_creation1, :output?
refute_predicate user_creation1, :result?
refute user_creation1.output?(:user_created)
refute user_creation1.result?(:user_created)
user_creation1.call(name: "John Doe", email: "john.doe@email.com", password: "123123123")
assert_predicate user_creation1, :output?
assert_predicate user_creation1, :result?
assert user_creation1.output?(:user_created)
assert user_creation1.result?(:user_created)
# ---
user_creation2 = UserCreationWithoutDeps.new
refute_predicate user_creation2, :output?
refute_predicate user_creation2, :result?
refute user_creation2.output?(:invalid_input)
refute user_creation2.result?(:invalid_input)
user_creation2.call(uuid: "", name: nil, email: nil)
assert_predicate user_creation2, :output?
assert_predicate user_creation2, :result?
assert user_creation2.output?(:invalid_input)
assert user_creation2.result?(:invalid_input)
end
test "#dependencies" do
user_creation1 = UserCreationWithoutDeps.new
assert_nil(user_creation1.dependencies)
assert_nil(user_creation1.deps)
# ---
user_creation2 = UserCreationWithDeps.new
assert_same(User, user_creation2.dependencies.repository)
assert_same(user_creation2.dependencies, user_creation2.deps)
# ---
user_creation3 = UserCreationWithDeps.new(repository: ::Object)
assert_same(::Object, user_creation3.dependencies.repository)
assert_same(user_creation3.dependencies, user_creation3.deps)
end
test "#dependencies?" do
user_creation1 = UserCreationWithoutDeps.new
refute_predicate user_creation1, :dependencies?
refute_predicate user_creation1, :deps?
# ---
user_creation2 = UserCreationWithDeps.new
assert_predicate user_creation2, :dependencies?
assert_predicate user_creation2, :deps?
end
test "#success?" do
user_creation = UserCreationWithoutDeps.new
refute_predicate user_creation, :success?
refute user_creation.success?(:user_created)
refute user_creation.success?(:person_created)
user_creation.call(name: "John Doe", email: " JOHN.doe@email.com", password: "123123123")
assert_predicate user_creation, :success?
assert user_creation.success?(:user_created)
refute user_creation.success?(:person_created)
end
test "#failure?" do
user_creation = UserCreationWithoutDeps.new
refute_predicate user_creation, :failure?
refute user_creation.failure?(:invalid_input)
refute user_creation.failure?(:invalid_output)
user_creation.call(uuid: "", name: nil, email: nil)
assert_predicate user_creation, :failure?
assert user_creation.failure?(:invalid_input)
refute user_creation.failure?(:invalid_output)
end
test "#inspect" do
user_creation = UserCreationWithoutDeps.new
assert_equal("#", user_creation.inspect)
end
test "#method_missing" do
user_creation1 = UserCreationWithoutDeps.new
user_creation1.call(name: "John Doe", email: "john.doe@email.com", password: "123123123")
assert_predicate user_creation1, :user_created?
# ---
user_creation2 = UserCreationWithoutDeps.new
user_creation2.call(uuid: "", name: nil, email: nil)
assert_predicate user_creation2, :invalid_input?
# ---
assert_raises(NoMethodError) { user_creation1.foo }
assert_raises(NoMethodError) { user_creation2.foo }
end
test "#respond_to_missing?" do
user_creation1 = UserCreationWithoutDeps.new
refute user_creation1.method(:foo?).call
end
test "#dependencies=" do
create_user = UserCreationWithDeps.allocate
assert_nil create_user.dependencies
assert_raises(NoMethodError) do
create_user.dependencies = {repository: ::User}
end
create_user.send(:dependencies=, {repository: ::User})
assert_predicate create_user, :dependencies?
assert_same(::User, create_user.dependencies.repository)
err = assert_raises(Solid::Process::Error) do
create_user.send(:dependencies=, {repository: ::User})
end
assert_equal("The `UserCreationWithDeps#dependencies` is already set.", err.message)
end
test "#input=" do
user_creation = UserCreationWithoutDeps.new
assert_nil user_creation.input
assert_raises(NoMethodError) do
user_creation.input = {name: "John Doe", email: "john@email.com"}
end
user_creation.send(:input=, {name: "John Doe", email: "john@email.com"})
assert_predicate user_creation, :input?
assert_equal("John Doe", user_creation.input.name)
assert_equal("john@email.com", user_creation.input.email)
err = assert_raises(Solid::Process::Error) do
user_creation.send(:input=, {name: "John Doe", email: "john@email.com"})
end
assert_equal("The `UserCreationWithoutDeps#input` is already set.", err.message)
end
test "#output=" do
user_creation = UserCreationWithoutDeps.new
assert_nil user_creation.output
assert_raises(NoMethodError) do
user_creation.output = Solid::Success(:user_created, user: ::User.new)
end
err1 = assert_raises(Solid::Process::Error) do
user_creation.send(:output=, 1)
end
assert_equal("The result 1 must be a Solid::Output.", err1.message)
user_creation.send(:output=, Solid::Success(:user_created, user: ::User.new))
assert_predicate user_creation, :output?
assert user_creation.output?(:user_created)
assert_instance_of ::User, user_creation.output.value[:user]
err2 = assert_raises(Solid::Process::Error) do
user_creation.send(:output=, Solid::Success(:user_created, user: ::User.new))
end
assert_equal(
"The `UserCreationWithoutDeps#output` is already set. " \
"Use `.output` to access the result or create a new instance to call again.",
err2.message
)
end
end
solid-process-0.5.0/test/solid/process/rescue_from_test.rb 0000664 0000000 0000000 00000005107 15136200163 0023746 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::RescueFromTest < ActiveSupport::TestCase
class Division < Solid::Process
NanNumberError = Class.new(StandardError)
InfiniteNumberError = Class.new(StandardError)
NumeratorIsZeroError = Class.new(StandardError)
input do
attribute :number1
attribute :number2
end
rescue_from ZeroDivisionError do |error|
Failure!(:zero_division_error, error: error)
end
rescue_from NumeratorIsZeroError do
Success!(:division_completed, result: 0)
end
rescue_from NanNumberError, with: :nan_number_error
rescue_from InfiniteNumberError, with: :infinite_number_error
def call(attributes)
number1 = attributes.fetch(:number1)
number2 = attributes.fetch(:number2)
raise NanNumberError if nan?(number1) || nan?(number2)
raise InfiniteNumberError if infinite?(number1) || infinite?(number2)
raise NumeratorIsZeroError if number1.zero? && number2.zero?
Success(:division_completed, result: number1 / number2)
end
private
def nan?(number)
number.respond_to?(:nan?) && number.nan?
end
def infinite?(number)
!number.respond_to?(:infinite?) || number.infinite?
end
def nan_number_error(error)
# This is a contrived example to test the error when Failure! is called twice or more.
2.times { Failure!(:nan_number_error, error: error) }
end
def infinite_number_error(error)
# This is a contrived example to test the error when Success! is called twice or more.
2.times { Success!(:infinite_number_error, error: error) }
end
end
test "rescue from ZeroDivisionError" do
result = Division.call(number1: 1, number2: 0)
assert result.failure?(:zero_division_error)
assert_instance_of ZeroDivisionError, result.value[:error]
end
test "rescue from NumeratorIsZeroError" do
result = Division.call(number1: 0, number2: 0)
assert result.success?(:division_completed)
assert_equal 0, result.value[:result]
end
test "rescue from NanNumberError" do
err = assert_raises(Solid::Process::Error) do
Division.call(number1: Float::NAN, number2: 1)
end
assert_equal "`Failure!()` cannot be called because the `#{Division}#output` is already set.", err.message
end
test "rescue from InfiniteNumberError" do
err = assert_raises(Solid::Process::Error) do
Division.call(number1: Float::INFINITY, number2: 1)
end
assert_equal "`Success!()` cannot be called because the `#{Division}#output` is already set.", err.message
end
end
solid-process-0.5.0/test/solid/process/result_test.rb 0000664 0000000 0000000 00000005645 15136200163 0022762 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::ResultTest < ActiveSupport::TestCase
def setup
::User.delete_all
end
def user_creation
[
-> { UserCreationWithoutDeps.call(_1) },
-> { UserCreationWithoutDeps.new.call(_1) }
].sample
end
def map_input(data)
[data, UserCreationWithoutDeps::Input.new(data)].sample
end
test "success" do
password = "123123123"
input = map_input(name: "\tJohn Doe \n", email: " JOHN.doe@email.com", password: password)
result = assert_difference(-> { User.count } => 1) { user_creation.call(input) }
assert_kind_of Solid::Result, result
assert_kind_of Solid::Success, result
assert_predicate result, :user_created?
assert result.is?(:user_created)
assert result.type?(:user_created)
assert result.success?(:user_created)
assert_equal [:user], result.value.keys
user = result.value.fetch(:user)
assert_match(TestUtils::UUID_REGEX, user.uuid)
assert_equal("John Doe", user.name)
assert_equal("john.doe@email.com", user.email)
assert BCrypt::Password.new(user.password_digest).is_password?(password)
end
test "failure (invalid_input)" do
input = map_input(name: " ", email: "John", password: "123123")
result = assert_no_difference(-> { User.count }) { user_creation.call(input) }
assert_kind_of Solid::Result, result
assert_kind_of Solid::Failure, result
assert_predicate result, :invalid_input?
assert result.is?(:invalid_input)
assert result.type?(:invalid_input)
assert result.failure?(:invalid_input)
assert_equal [:input], result.value.keys
input = result.value[:input]
assert_kind_of Solid::Input, input
assert_instance_of UserCreationWithoutDeps::Input, input
input.errors.added? :name, :blank
input.errors.added? :email, :invalid
end
test "failure (email_already_taken)" do
input = map_input(name: "John Doe", email: "john.doe@email.com", password: "123123123")
user_creation.call(input)
result = assert_no_difference(-> { User.count }) { user_creation.call(input) }
assert_predicate result, :email_already_taken?
assert result.is?(:email_already_taken)
assert result.type?(:email_already_taken)
assert result.failure?(:email_already_taken)
end
test "#method_missing" do
result1 = UserCreationWithoutDeps.call(name: nil, email: nil, password: nil)
result2 = UserCreationWithoutDeps.call(name: "John Doe", email: "john.doe@email.com", password: "123123123")
assert_raises(NoMethodError) { result1.foo }
assert_raises(NoMethodError) { result2.foo }
end
test "#respond_to_missing?" do
result1 = UserCreationWithoutDeps.call(name: nil, email: nil, password: nil)
result2 = UserCreationWithoutDeps.call(name: "John Doe", email: "john.doe@email.com", password: "123123123")
refute result1.method(:foo?).call
refute result2.method(:bar?).call
end
end
solid-process-0.5.0/test/solid/process/version_test.rb 0000664 0000000 0000000 00000000314 15136200163 0023115 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::ProcessVersionTest < ActiveSupport::TestCase
test "that it has a version number" do
refute_nil ::Solid::Process::VERSION
end
end
solid-process-0.5.0/test/solid/validators/ 0000775 0000000 0000000 00000000000 15136200163 0020540 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/solid/validators/email_validator_test.rb 0000664 0000000 0000000 00000002704 15136200163 0025263 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
require "solid/validators/email_validator"
class Solid::EmailValidatorTest < ActiveSupport::TestCase
class Input < Solid::Input
attribute :email1
attribute :email2
attribute :email3
validates :email1, email: true
validates :email2, email: true, allow_nil: true
validates :email3, email: true, allow_blank: true
end
test "email validator" do
input = Input.new
input.email1 = "foo@foo.com"
input.email2 = "bar@bar.com"
input.email3 = "biz@biz.com"
assert_predicate input, :valid?
input.email1 = "foo"
input.email2 = "bar"
input.email3 = "biz"
refute_predicate input, :valid?
assert_equal ["is invalid"], input.errors[:email1]
assert_equal ["is invalid"], input.errors[:email2]
assert_equal ["is invalid"], input.errors[:email3]
input.email1 = nil
input.email2 = nil
input.email3 = nil
refute_predicate input, :valid?
assert_equal ["can't be blank"], input.errors[:email1]
assert_empty input.errors[:email2]
assert_empty input.errors[:email3]
input.email1 = ""
input.email2 = ""
input.email3 = ""
refute_predicate input, :valid?
assert_equal ["can't be blank"], input.errors[:email1]
assert_equal ["can't be blank"], input.errors[:email2]
assert_empty input.errors[:email3]
input.email1 = "foo@foo.com"
input.email2 = nil
assert_predicate input, :valid?
end
end
solid-process-0.5.0/test/solid/validators/id_validator_test.rb 0000664 0000000 0000000 00000004566 15136200163 0024600 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
require "solid/validators/id_validator"
class Solid::IdValidatorTest < ActiveSupport::TestCase
class Input < Solid::Input
attribute :id1
attribute :id2
attribute :id3
attribute :id4
validates :id1, id: true
validates :id2, id: true
validates :id3, id: true, allow_nil: true
validates :id4, id: true, allow_blank: true
end
test "id validator" do
input = Input.new
input.id1 = 1
input.id2 = 2
input.id3 = 3
input.id4 = 4
assert_predicate input, :valid?
input.id1 = "1"
input.id2 = "2"
input.id3 = "3"
input.id4 = "4"
assert_predicate input, :valid?
input.id1 = 0
input.id2 = -1
input.id3 = -2
input.id4 = -3
refute_predicate input, :valid?
assert_equal ["must be greater than 0"], input.errors[:id1]
assert_equal ["must be greater than 0"], input.errors[:id2]
assert_equal ["must be greater than 0"], input.errors[:id3]
assert_equal ["must be greater than 0"], input.errors[:id4]
input.id1 = 1.0
input.id2 = 2.0
input.id3 = 3.0
input.id4 = 4.0
refute_predicate input, :valid?
assert_equal ["must be an integer"], input.errors[:id1]
assert_equal ["must be an integer"], input.errors[:id2]
assert_equal ["must be an integer"], input.errors[:id3]
assert_equal ["must be an integer"], input.errors[:id4]
input.id1 = "1.0"
input.id2 = "2.0"
input.id3 = "3.0"
input.id4 = "4.0"
refute_predicate input, :valid?
assert_equal ["must be an integer"], input.errors[:id1]
assert_equal ["must be an integer"], input.errors[:id2]
assert_equal ["must be an integer"], input.errors[:id3]
assert_equal ["must be an integer"], input.errors[:id4]
input.id1 = nil
input.id2 = nil
input.id3 = nil
input.id4 = nil
refute_predicate input, :valid?
assert_equal ["is not a number"], input.errors[:id1]
assert_equal ["is not a number"], input.errors[:id2]
assert_empty input.errors[:id3]
assert_empty input.errors[:id4]
input.id1 = ""
input.id2 = ""
input.id3 = ""
input.id4 = ""
refute_predicate input, :valid?
assert_equal ["is not a number"], input.errors[:id1]
assert_equal ["is not a number"], input.errors[:id2]
assert_equal ["is not a number"], input.errors[:id3]
assert_empty input.errors[:id4]
end
end
solid-process-0.5.0/test/solid/validators/instance_of_validator_test.rb 0000664 0000000 0000000 00000002507 15136200163 0026465 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
require "solid/validators/instance_of_validator"
class Solid::InstanceOfValidatorTest < ActiveSupport::TestCase
class Input < Solid::Input
attribute :symbol
attribute :string
attribute :to_sym
validates :string, instance_of: String, allow_nil: true
validates :symbol, instance_of: [Symbol]
validates :to_sym, instance_of: [String, Symbol]
end
test "instance_of validator" do
input = Input.new
input.symbol = :symbol
input.string = "string"
input.to_sym = "to_sym"
assert_predicate input, :valid?
input.string = :symbol
input.symbol = "string"
input.to_sym = 1
refute_predicate input, :valid?
assert_equal ["is not an instance of String"], input.errors[:string]
assert_equal ["is not an instance of Symbol"], input.errors[:symbol]
assert_equal ["is not an instance of String | Symbol"], input.errors[:to_sym]
input.string = nil
input.symbol = nil
input.to_sym = nil
refute_predicate input, :valid?
assert_empty input.errors[:string]
assert_equal ["is not an instance of Symbol"], input.errors[:symbol]
assert_equal ["is not an instance of String | Symbol"], input.errors[:to_sym]
input.symbol = :symbol
input.to_sym = :symbol
assert_predicate input, :valid?
end
end
solid-process-0.5.0/test/solid/validators/is_validator_test.rb 0000664 0000000 0000000 00000003703 15136200163 0024607 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
require "solid/validators/is_validator"
class Solid::IsValidatorTest < ActiveSupport::TestCase
class Input < Solid::Input
attribute :obj1
attribute :obj2
attribute :obj3
validates :obj1, is: [:present?, :persisted?]
validates :obj2, is: :persisted?
validates :obj3, is: :persisted?, allow_nil: true
end
class InvalidValidationArg < Solid::Input
attribute :obj
validates :obj, is: :persisted
end
test "is validator" do
input = Input.new
input.obj1 = OpenStruct.new(present?: true, persisted?: true)
input.obj2 = OpenStruct.new(present?: false, persisted?: true)
input.obj3 = OpenStruct.new(present?: false, persisted?: true)
assert_predicate input, :valid?
input.obj1 = OpenStruct.new(present?: true, persisted?: false)
input.obj2 = OpenStruct.new(persisted?: false)
input.obj3 = OpenStruct.new(persisted?: false)
refute_predicate input, :valid?
assert_equal ["does not satisfy the predicates: present? & persisted?"], input.errors[:obj1]
assert_equal ["does not satisfy the predicate: persisted?"], input.errors[:obj2]
assert_equal ["does not satisfy the predicate: persisted?"], input.errors[:obj3]
input.obj1 = nil
input.obj2 = nil
input.obj3 = nil
refute_predicate input, :valid?
assert_equal ["does not satisfy the predicates: present? & persisted?"], input.errors[:obj1]
assert_equal ["does not satisfy the predicate: persisted?"], input.errors[:obj2]
assert_empty input.errors[:obj3]
input.obj1 = OpenStruct.new(present?: true, persisted?: true)
input.obj2 = OpenStruct.new(persisted?: true)
assert_predicate input, :valid?
end
test "raises error when receive invalid validation argument" do
exception = assert_raises ArgumentError do
InvalidValidationArg.new.valid?
end
assert_equal "expected a predicate method, got :persisted", exception.message
end
end
solid-process-0.5.0/test/solid/validators/kind_of_validator_test.rb 0000664 0000000 0000000 00000002431 15136200163 0025602 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
require "solid/validators/kind_of_validator"
class Solid::KindOfValidatorTest < ActiveSupport::TestCase
class Input < Solid::Input
attribute :to_sym
attribute :number
attribute :collection
validates :to_sym, kind_of: [String, Symbol]
validates :number, kind_of: Numeric
validates :collection, kind_of: Enumerable, allow_nil: true
end
test "kind_of validator" do
input = Input.new
input.to_sym = "to_sym"
input.number = 1
input.collection = [1, 2, 3]
assert_predicate input, :valid?
input.to_sym = 1
input.number = "1"
input.collection = 1
refute_predicate input, :valid?
assert_equal ["is not a String | Symbol"], input.errors[:to_sym]
assert_equal ["is not a Numeric"], input.errors[:number]
assert_equal ["is not a Enumerable"], input.errors[:collection]
input.to_sym = nil
input.number = nil
input.collection = nil
refute_predicate input, :valid?
assert_equal ["is not a String | Symbol"], input.errors[:to_sym]
assert_equal ["is not a Numeric"], input.errors[:number]
assert_empty input.errors[:collection]
input.to_sym = :to_sym
input.number = 1.0
input.collection = {}
assert_predicate input, :valid?
end
end
solid-process-0.5.0/test/solid/validators/respond_to_validator_test.rb 0000664 0000000 0000000 00000002026 15136200163 0026345 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
require "solid/validators/respond_to_validator"
class Solid::RespondToValidatorTest < ActiveSupport::TestCase
class Input < Solid::Input
attribute :object1
attribute :object2
validates :object1, respond_to: :to_sym, allow_nil: true
validates :object2, respond_to: [:to_sym, :to_str]
end
test "respond_to validator" do
input = Input.new
input.object1 = "to_sym"
input.object2 = "to_str"
assert_predicate input, :valid?
input.object1 = 1
input.object2 = :to_sym
refute_predicate input, :valid?
assert_equal ["does not respond to :to_sym"], input.errors[:object1]
assert_equal ["does not respond to :to_sym & :to_str"], input.errors[:object2]
input.object1 = nil
input.object2 = nil
refute_predicate input, :valid?
assert_empty input.errors[:object1]
assert_equal ["does not respond to :to_sym & :to_str"], input.errors[:object2]
input.object2 = "to_str"
assert_predicate input, :valid?
end
end
solid-process-0.5.0/test/solid/validators/singleton_validator_test.rb 0000664 0000000 0000000 00000003552 15136200163 0026200 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
require "solid/validators/singleton_validator"
class Solid::SingletonValidatorTest < ActiveSupport::TestCase
class MyString < String
end
module MyEnumerable
include Enumerable
end
class Input < Solid::Input
attribute :mod_or_class1
attribute :mod_or_class2
attribute :mod_or_class3
validates :mod_or_class1, singleton: String
validates :mod_or_class2, singleton: [String, Symbol]
validates :mod_or_class3, singleton: [Enumerable], allow_nil: true
end
test "singleton validator" do
input = Input.new
input.mod_or_class1 = MyString
input.mod_or_class2 = MyString
input.mod_or_class3 = MyEnumerable
assert_predicate input, :valid?
input.mod_or_class1 = Integer
input.mod_or_class2 = Integer
input.mod_or_class3 = Integer
refute_predicate input, :valid?
assert_equal ["is not String"], input.errors[:mod_or_class1]
assert_equal ["is not String | Symbol"], input.errors[:mod_or_class2]
assert_equal ["is not Enumerable"], input.errors[:mod_or_class3]
input.mod_or_class1 = nil
input.mod_or_class2 = nil
input.mod_or_class3 = nil
refute_predicate input, :valid?
assert_equal ["is not a class or module"], input.errors[:mod_or_class1]
assert_equal ["is not a class or module"], input.errors[:mod_or_class2]
assert_empty input.errors[:mod_or_class3]
input.mod_or_class1 = String
input.mod_or_class2 = Symbol
assert_predicate input, :valid?
err2 = assert_raises(ArgumentError) do
klass = Class.new(Solid::Input) do
attribute :mod_or_class
validates :mod_or_class, singleton: "String"
def self.name
"Input"
end
end
klass.new(mod_or_class: String).valid?
end
assert_equal "\"String\" is not a class or module", err2.message
end
end
solid-process-0.5.0/test/solid/validators/uuid_validator_test.rb 0000664 0000000 0000000 00000006107 15136200163 0025143 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
require "solid/validators/uuid_validator"
class Solid::UuidValidatorTest < ActiveSupport::TestCase
class InputCaseSensitive < Solid::Input
attribute :uuid1
attribute :uuid2
attribute :uuid3
validates :uuid1, uuid: true
validates :uuid2, uuid: true, allow_nil: true
validates :uuid3, uuid: true, allow_blank: true
end
class InputCaseInsensitive < Solid::Input
attribute :uuid1
attribute :uuid2
attribute :uuid3
validates :uuid1, uuid: {case_sensitive: false}
validates :uuid2, uuid: {case_sensitive: false}, allow_nil: true
validates :uuid3, uuid: {case_sensitive: false}, allow_blank: true
end
test "uuid validator (case sensitive)" do
input = InputCaseSensitive.new
input.uuid1 = SecureRandom.uuid
input.uuid2 = SecureRandom.uuid
input.uuid3 = SecureRandom.uuid
assert_predicate input, :valid?
input.uuid1 = SecureRandom.uuid.upcase
input.uuid2 = SecureRandom.uuid.upcase
input.uuid3 = SecureRandom.uuid.upcase
refute_predicate input, :valid?
assert_equal ["is invalid"], input.errors[:uuid1]
assert_equal ["is invalid"], input.errors[:uuid2]
assert_equal ["is invalid"], input.errors[:uuid3]
input.uuid1 = nil
input.uuid2 = nil
input.uuid3 = nil
refute_predicate input, :valid?
assert_equal ["can't be blank"], input.errors[:uuid1]
assert_empty input.errors[:uuid2]
assert_empty input.errors[:uuid3]
input.uuid1 = ""
input.uuid2 = ""
input.uuid3 = ""
refute_predicate input, :valid?
assert_equal ["can't be blank"], input.errors[:uuid1]
assert_equal ["can't be blank"], input.errors[:uuid2]
assert_empty input.errors[:uuid3]
input.uuid1 = SecureRandom.uuid
input.uuid2 = nil
assert_predicate input, :valid?
end
test "uuid validator (case insensitive)" do
input = InputCaseInsensitive.new
input.uuid1 = SecureRandom.uuid
input.uuid2 = SecureRandom.uuid
input.uuid3 = SecureRandom.uuid
assert_predicate input, :valid?
input.uuid1 = SecureRandom.uuid.upcase
input.uuid2 = SecureRandom.uuid.upcase
input.uuid3 = SecureRandom.uuid.upcase
assert_predicate input, :valid?
input.uuid1 = "0374c4f"
input.uuid2 = "0374c4f"
input.uuid3 = "0374c4f"
refute_predicate input, :valid?
assert_equal ["is invalid"], input.errors[:uuid1]
assert_equal ["is invalid"], input.errors[:uuid2]
assert_equal ["is invalid"], input.errors[:uuid3]
input.uuid1 = nil
input.uuid2 = nil
input.uuid3 = nil
refute_predicate input, :valid?
assert_equal ["can't be blank"], input.errors[:uuid1]
assert_empty input.errors[:uuid2]
assert_empty input.errors[:uuid3]
input.uuid1 = ""
input.uuid2 = ""
input.uuid3 = ""
refute_predicate input, :valid?
assert_equal ["can't be blank"], input.errors[:uuid1]
assert_equal ["can't be blank"], input.errors[:uuid2]
assert_empty input.errors[:uuid3]
input.uuid1 = SecureRandom.uuid
input.uuid2 = nil
assert_predicate input, :valid?
end
end
solid-process-0.5.0/test/solid/value/ 0000775 0000000 0000000 00000000000 15136200163 0017504 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/solid/value/access_test.rb 0000664 0000000 0000000 00000001437 15136200163 0022336 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::ValueAccessTest < ActiveSupport::TestCase
class UUID
include Solid::Value
attribute default: -> { SecureRandom.uuid }
attribute :string
end
test "#[]" do
uuid = UUID.new
assert_match(TestUtils::UUID_REGEX, uuid[:value])
assert_match(TestUtils::UUID_REGEX, uuid["value"])
end
test "#value" do
uuid = UUID.new("some-string")
slice = uuid.slice(:value)
assert_equal({"value" => uuid.value}, slice)
assert_instance_of(ActiveSupport::HashWithIndifferentAccess, slice)
end
test "#values_at" do
uuid = UUID.new("some-string")
assert_equal([uuid.value], uuid.values_at(:value))
assert_empty(uuid.values_at)
assert_instance_of(Array, uuid.values_at)
end
end
solid-process-0.5.0/test/solid/value/callbacks_test.rb 0000664 0000000 0000000 00000001663 15136200163 0023015 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::ValueCallbacksTest < ActiveSupport::TestCase
class MyValue
include Solid::Value
after_initialize do
value[:after_initialize_value1] = "foo"
end
before_validation do
value[:before_validation_value] = "bar"
end
after_validation do
value[:after_validation_value] = "baz"
end
end
test "the callbacks" do
model = MyValue.new({})
assert_equal("foo", model.value[:after_initialize_value1])
assert_nil(model.value[:after_initialize_value2])
assert_nil(model.value[:before_validation_value])
assert_nil(model.value[:after_validation_value])
model.valid?
assert_equal("foo", model.value[:after_initialize_value1])
assert_nil(model.value[:after_initialize_value2])
assert_equal("bar", model.value[:before_validation_value])
assert_equal("baz", model.value[:after_validation_value])
end
end
solid-process-0.5.0/test/solid/value/class_test.rb 0000664 0000000 0000000 00000002547 15136200163 0022205 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::ValueClassTest < ActiveSupport::TestCase
class ValueWithDefaults
include Solid::Value
attribute :string, default: -> { SecureRandom.uuid }
end
test "value with default values" do
uuid_str = SecureRandom.uuid
uuid1 = ValueWithDefaults.new
uuid2 = ValueWithDefaults.new(uuid_str)
assert_match TestUtils::UUID_REGEX, uuid1.value
assert_equal uuid_str, uuid2.value
end
class ValueWithNormalization
include Solid::Value
attribute :string
before_validation do |model|
self.value = model.value.strip.downcase
end
end
test "value with normalization (before_validation)" do
uuid_str = SecureRandom.uuid
uuid = ValueWithNormalization.new(" #{uuid_str} ")
uuid.valid?
assert_equal uuid_str, uuid.value
end
class ValueWithValidation
include Solid::Value
attribute :string
validates presence: true, format: {with: TestUtils::UUID_REGEX}
end
test "value with validation" do
uuid1 = ValueWithValidation.new
uuid2 = ValueWithValidation.new(" ")
uuid3 = ValueWithValidation.new("invalid")
uuid4 = ValueWithValidation.new(SecureRandom.uuid)
assert_predicate uuid1, :invalid?
assert_predicate uuid2, :invalid?
assert_predicate uuid3, :invalid?
assert_predicate uuid4, :valid?
end
end
solid-process-0.5.0/test/solid/value/instantiation_test.rb 0000664 0000000 0000000 00000000664 15136200163 0023762 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::ValueInstantiationTest < ActiveSupport::TestCase
class MyValue
include Solid::Value
attribute :string, default: -> { SecureRandom.uuid }
end
test "the new alias" do
uuid_str = SecureRandom.uuid
uuid1 = MyValue[]
uuid2 = MyValue[uuid_str]
assert_match TestUtils::UUID_REGEX, uuid1.value
assert_equal uuid_str, uuid2.value
end
end
solid-process-0.5.0/test/solid/value_test.rb 0000664 0000000 0000000 00000001642 15136200163 0021073 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::ValueTest < ActiveSupport::TestCase
class MyUUID
include Solid::Value
attribute :string
end
test "is a Solid::Value" do
assert MyUUID < Solid::Value
end
test "is a Solid::Model" do
assert MyUUID < Solid::Model
end
test "#==" do
uuid_str = SecureRandom.uuid
assert_equal MyUUID.new(uuid_str), MyUUID.new(uuid_str)
refute_equal uuid_str, MyUUID.new(uuid_str)
refute_equal MyUUID.new(uuid_str), uuid_str
end
test "#eql?" do
uuid_str = SecureRandom.uuid
assert MyUUID.new(uuid_str).eql?(MyUUID.new(uuid_str))
refute MyUUID.new(uuid_str).eql?(uuid_str)
end
test "#hash" do
uuid_str = SecureRandom.uuid
assert_equal uuid_str.hash, MyUUID.new(uuid_str).hash
end
test "#to_s" do
uuid_str = SecureRandom.uuid
assert_equal uuid_str.to_s, MyUUID.new(uuid_str).to_s
end
end
solid-process-0.5.0/test/support/ 0000775 0000000 0000000 00000000000 15136200163 0016772 5 ustar 00root root 0000000 0000000 solid-process-0.5.0/test/support/000_test_utils.rb 0000664 0000000 0000000 00000000247 15136200163 0022100 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module TestUtils
UUID_REGEX = /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/.freeze
EMAIL_REGEX = /\A[^@\s]+@[^@\s]+\z/.freeze
end
solid-process-0.5.0/test/support/001_runtime_breaker.rb 0000664 0000000 0000000 00000000577 15136200163 0023066 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module RuntimeBreaker
Interruption = Class.new(StandardError)
class << self
attr_accessor :interruption
def reset!
self.interruption = nil
end
def try_to_interrupt(interruption)
return unless interruption == self.interruption
raise Interruption, "Runtime breaker activated (#{interruption})"
end
end
end
solid-process-0.5.0/test/support/010_setup_sqlite.rb 0000664 0000000 0000000 00000002501 15136200163 0022416 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "active_support/all"
require "active_record"
ActiveRecord::Base.establish_connection(
host: "localhost",
adapter: "sqlite3",
database: ":memory:"
)
ActiveRecord::Schema.define do
suppress_messages do
create_table :accounts do |t|
t.string :uuid, null: false, index: {unique: true}
t.timestamps
end
create_table :users do |t|
t.string :uuid, null: false, index: {unique: true}
t.string :name, null: false
t.string :email, null: false, index: {unique: true}
t.string :password_digest, null: false
t.timestamps
end
create_table :user_tokens do |t|
t.belongs_to :user, null: false, foreign_key: true, index: true
t.string :access_token, null: false
t.string :refresh_token, null: false
t.datetime :access_token_expires_at, null: false
t.datetime :refresh_token_expires_at, null: false
t.timestamps
end
create_table :account_members do |t|
t.integer :role, null: false, default: 0
t.belongs_to :user, null: false, foreign_key: true, index: true
t.belongs_to :account, null: false, foreign_key: true, index: true
t.timestamps
t.index %i[account_id role], unique: true, where: "(role = 0)"
t.index %i[account_id user_id], unique: true
end
end
end
solid-process-0.5.0/test/support/020_active_record_models.rb 0000664 0000000 0000000 00000002645 15136200163 0024063 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account < ActiveRecord::Base
has_many :memberships, inverse_of: :account, dependent: :destroy, class_name: "::Account::Member"
has_many :users, through: :memberships, inverse_of: :accounts
where_ownership = -> { where(account_members: {role: :owner}) }
has_one :ownership, where_ownership, dependent: nil, inverse_of: :account, class_name: "::Account::Member"
has_one :owner, through: :ownership, source: :user
end
class User < ActiveRecord::Base
has_secure_password
has_many :memberships, inverse_of: :user, dependent: :destroy, class_name: "::Account::Member"
has_many :accounts, through: :memberships, inverse_of: :users
where_ownership = -> { where(account_members: {role: :owner}) }
has_one :ownership, where_ownership, inverse_of: :user, class_name: "::Account::Member"
has_one :account, through: :ownership, inverse_of: :owner
has_one :token, inverse_of: :user, dependent: :destroy, class_name: "::User::Token"
end
class User::Token < ActiveRecord::Base
self.table_name = "user_tokens"
belongs_to :user, inverse_of: :token
end
class Account::Member < ActiveRecord::Base
self.table_name = "account_members"
if ActiveRecord.version.to_s >= "8.0"
enum :role, owner: 0, admin: 1, contributor: 2
else
enum role: {owner: 0, admin: 1, contributor: 2}
end
belongs_to :user, inverse_of: :memberships
belongs_to :account, inverse_of: :memberships
end
solid-process-0.5.0/test/support/030_user_creation_without_deps.rb 0000664 0000000 0000000 00000002551 15136200163 0025344 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class UserCreationWithoutDeps < Solid::Process
input do
attribute :uuid, :string, default: -> { ::SecureRandom.uuid }
attribute :name, :string
attribute :email, :string
attribute :password, :string
attribute :executed_at, :time, default: -> { ::Time.current }
before_validation do |input|
input.uuid = input.uuid.strip.downcase
input.name = input.name&.strip&.gsub(/\s+/, " ")
input.email = input.email&.strip&.downcase
end
validates :name, presence: true
validates :uuid, presence: true, format: {with: TestUtils::UUID_REGEX}
validates :email, presence: true, format: {with: TestUtils::EMAIL_REGEX}
validates :password, presence: true
end
def call(attributes)
rollback_on_failure do
Given(attributes)
.and_then(:validate_email_has_not_been_taken)
.and_then(:create_user)
.and_expose(:user_created, %i[user])
end
end
private
def validate_email_has_not_been_taken(email:, **)
::User.exists?(email: email) ? Failure(:email_already_taken) : Continue()
end
def create_user(uuid:, name:, email:, password:, executed_at:)
user = ::User.create!(
uuid: uuid,
name: name,
email: email,
password: password,
created_at: executed_at,
updated_at: executed_at
)
Continue(user: user)
end
end
solid-process-0.5.0/test/support/040_user_creation_with_dependencies.rb 0000664 0000000 0000000 00000003344 15136200163 0026311 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class UserCreationWithDeps < Solid::Process
dependencies do
attribute :repository, default: ::User
validate :repository_interface
def repository_interface
repository.respond_to?(:create!) or errors.add(:repository, message: "must respond to :create!")
repository.respond_to?(:exists?) or errors.add(:repository, message: "must respond to :exists?")
end
end
input do
attribute :uuid, :string, default: -> { ::SecureRandom.uuid }
attribute :name, :string
attribute :email, :string
attribute :password, :string
attribute :executed_at, :time, default: -> { ::Time.current }
before_validation do |input|
input.uuid = input.uuid.strip.downcase
input.name = input.name&.strip&.gsub(/\s+/, " ")
input.email = input.email&.strip&.downcase
end
validates :name, presence: true
validates :uuid, presence: true, format: {with: TestUtils::UUID_REGEX}
validates :email, presence: true, format: {with: TestUtils::EMAIL_REGEX}
validates :password, presence: true
end
def call(attributes)
rollback_on_failure do
Given(attributes)
.and_then(:validate_email_has_not_been_taken)
.and_then(:create_user)
.and_expose(:user_created, %i[user])
end
end
private
def validate_email_has_not_been_taken(email:, **)
dependencies.repository.exists?(email: email) ? Failure(:email_already_taken) : Continue()
end
def create_user(uuid:, name:, email:, password:, executed_at:)
user = dependencies.repository.create!(
uuid: uuid,
name: name,
email: email,
password: password,
created_at: executed_at,
updated_at: executed_at
)
Continue(user: user)
end
end
solid-process-0.5.0/test/support/051_user_token_creation.rb 0000664 0000000 0000000 00000002071 15136200163 0023746 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User::Token::Creation < Solid::Process
input do
attribute :user
attribute :executed_at, :time, default: -> { ::Time.current }
validates :user, presence: true
validates :executed_at, presence: true
end
def call(attributes)
Given(attributes)
.and_then(:validate_token_existence)
.and_then(:create_token_if_not_exists)
.and_expose(:token_created, %i[token])
end
private
def validate_token_existence(user:, **)
token = user.token
token&.persisted? ? Success(:token_already_exists, token: token) : Continue()
end
def create_token_if_not_exists(user:, executed_at:, **)
::RuntimeBreaker.try_to_interrupt("USER_TOKEN_CREATION")
token = user.create_token(
access_token: ::SecureRandom.hex(24),
refresh_token: ::SecureRandom.hex(24),
access_token_expires_at: executed_at + 15.days,
refresh_token_expires_at: executed_at + 30.days
)
token.persisted? ? Continue(token: token) : Failure(:token_creation_failed, **token.errors.messages)
end
end
solid-process-0.5.0/test/support/052_user_creation.rb 0000664 0000000 0000000 00000003573 15136200163 0022557 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User::Creation < Solid::Process
deps do
attribute :token_creation, default: ::User::Token::Creation
end
input do
attribute :uuid, :string, default: -> { ::SecureRandom.uuid }
attribute :name, :string
attribute :email, :string
attribute :password, :string
attribute :password_confirmation, :string
before_validation do |input|
input.uuid = input.uuid.strip.downcase
input.name = input.name.strip.gsub(/\s+/, " ")
input.email = input.email.strip.downcase
end
validates :uuid, presence: true, format: {with: /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i}
validates :name, presence: true
validates :email, presence: true, format: {with: ::URI::MailTo::EMAIL_REGEXP}
validates :password, :password_confirmation, presence: true
end
def call(attributes)
Given(attributes)
.and_then(:validate_email_uniqueness)
.then { |result|
rollback_on_failure {
result
.and_then(:create_user)
.and_then(:create_user_token)
}
}
.and_expose(:user_created, %i[user token])
end
private
def validate_email_uniqueness(email:, **)
::User.exists?(email: email) ? Failure(:email_already_taken) : Continue()
end
def create_user(uuid:, name:, email:, password:, password_confirmation:)
::RuntimeBreaker.try_to_interrupt("USER_CREATION")
user = ::User.create(
uuid: uuid,
name: name,
email: email,
password: password,
password_confirmation: password_confirmation
)
user.persisted? ? Continue(user: user) : Failure(:invalid_record, **user.errors.messages)
end
def create_user_token(user:, **)
case deps.token_creation.call(user: user)
in Solid::Success(token: token)
Continue(token: token)
in Solid::Failure
raise "Token creation failed"
end
end
end
solid-process-0.5.0/test/support/053_account_owner_creation.rb 0000664 0000000 0000000 00000002576 15136200163 0024452 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Account::OwnerCreation < Solid::Process
deps do
attribute :user_creation, default: ::User::Creation
end
input do
attribute :uuid, :string, default: -> { ::SecureRandom.uuid }
attribute :owner
before_validation do |input|
input.uuid = input.uuid.strip.downcase
end
validates :uuid, presence: true, format: {with: /\A[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\z/i}
validates :owner, presence: true
end
def call(attributes)
rollback_on_failure {
Given(attributes)
.and_then(:create_owner)
.and_then(:create_account)
.and_then(:link_owner_to_account)
}.and_expose(:account_owner_created, %i[user account])
end
private
def create_owner(owner:, **)
case deps.user_creation.call(owner)
in Solid::Success(user: user, token: token)
Continue(user: user, user_token: token)
in Solid::Failure(type: type, value: value)
Failure(:invalid_owner, **{type => value})
end
end
def create_account(uuid:, **)
::RuntimeBreaker.try_to_interrupt("ACCOUNT_CREATION")
account = ::Account.create(uuid: uuid)
account.persisted? ? Continue(account: account) : Failure(:invalid_account, account: account)
end
def link_owner_to_account(account:, user:, **)
Account::Member.create!(account: account, user: user, role: :owner)
Continue()
end
end
solid-process-0.5.0/test/test_helper.rb 0000664 0000000 0000000 00000001042 15136200163 0020116 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "ostruct"
require "simplecov"
SimpleCov.start do
enable_coverage :branch
add_filter "/test/"
end
Bundler.require(:default, :test)
SimpleCov.command_name "test-rails-#{ActiveSupport.version.to_s.tr(".", "_")}"
$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
Dir[File.expand_path("support/**/*.rb", __dir__)].sort.each { |file| require file }
require "solid/process"
require "minitest/autorun"
require "active_support/test_case"
class ActiveSupport::TestCase
parallelize(workers: 1)
end