pax_global_header 0000666 0000000 0000000 00000000064 14636022670 0014520 g ustar 00root root 0000000 0000000 52 comment=82f57aec9223719415f963d56de481fad68d9604
solid-process-0.4.0/ 0000775 0000000 0000000 00000000000 14636022670 0014307 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/.github/ 0000775 0000000 0000000 00000000000 14636022670 0015647 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/.github/workflows/ 0000775 0000000 0000000 00000000000 14636022670 0017704 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/.github/workflows/main.yml 0000664 0000000 0000000 00000003067 14636022670 0021361 0 ustar 00root root 0000000 0000000 name: Ruby
on:
push:
branches:
- main
pull_request:
jobs:
test:
runs-on: ubuntu-latest
name: Ruby ${{ matrix.ruby }}
strategy:
matrix:
ruby: [2.7, 3.0, 3.1, 3.2, 3.3, head]
env:
CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
steps:
- uses: actions/checkout@v4
- name: Set up Ruby
uses: ruby/setup-ruby@v1
with:
ruby-version: ${{ matrix.ruby }}
- name: Bundle install
run: bundle install
- name: Setup project
run: bundle exec rake appraisal:install
- name: Run tests for Rails 6.0
if: ${{ matrix.ruby <= 3.3 }}
run: bundle exec appraisal rails-6-0 rake test
- name: Run tests for Rails 6.1
if: ${{ matrix.ruby <= 3.3 }}
run: bundle exec appraisal rails-6-1 rake test
- name: Run tests for Rails 7.0
if: ${{ matrix.ruby <= 3.3 }}
run: bundle exec appraisal rails-7-0 rake test
- name: Run tests for Rails 7.1
run: bundle exec appraisal rails-7-1 rake test
- name: Run tests for Rails edge
run: bundle exec appraisal rails-edge rake test
if: ${{ matrix.ruby >= 3.1 || matrix.ruby == 'head' }}
- uses: paambaati/codeclimate-action@v5
if: ${{ matrix.ruby == 3.2 && !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.2"
- name: Setup project
run: bundle install
- name: Rake standard
run: bundle exec rake standard
solid-process-0.4.0/.gitignore 0000664 0000000 0000000 00000000211 14636022670 0016271 0 ustar 00root root 0000000 0000000 /.bundle/
/.yardoc
/_yardoc/
/coverage/
/doc/
/pkg/
/spec/reports/
/tmp/
.ruby-version
Gemfile.lock
gemfiles/*.lock
gemfiles/.bundle/
solid-process-0.4.0/.rubocop.yml 0000664 0000000 0000000 00000000063 14636022670 0016560 0 ustar 00root root 0000000 0000000 inherit_gem:
standard:
- config/ruby-2.7.yml
solid-process-0.4.0/.standard.yml 0000664 0000000 0000000 00000000127 14636022670 0016710 0 ustar 00root root 0000000 0000000 ruby_version: 2.7
ignore:
- ./examples/**/*
- ./**/*.gemfile.lock
- Gemfile.lock
solid-process-0.4.0/Appraisals 0000664 0000000 0000000 00000001063 14636022670 0016331 0 ustar 00root root 0000000 0000000 if RUBY_VERSION < "3.4.0"
appraise "rails-6-0" do
group :test do
gem "activerecord", "~> 6.0.0"
end
end
appraise "rails-6-1" do
group :test do
gem "activerecord", "~> 6.1.0"
end
end
appraise "rails-7-0" do
group :test do
gem "activerecord", "~> 7.0.0"
end
end
end
appraise "rails-7-1" do
group :test do
gem "activerecord", "~> 7.1.0"
end
end
if RUBY_VERSION >= "3.1.0"
appraise "rails-edge" do
group :test do
gem "activerecord", github: "rails/rails", branch: "main"
end
end
end
solid-process-0.4.0/CHANGELOG.md 0000664 0000000 0000000 00000005672 14636022670 0016132 0 ustar 00root root 0000000 0000000 ## [Unreleased]
## [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.4.0/CODE_OF_CONDUCT.md 0000664 0000000 0000000 00000012151 14636022670 0017106 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.4.0/Gemfile 0000664 0000000 0000000 00000000526 14636022670 0015605 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.2", ">= 13.2.1"
gem "standard", "~> 1.37"
group :test do
gem "bcrypt", "~> 3.1.20"
gem "sqlite3", "~> 1.7"
gem "minitest", "~> 5.24"
gem "simplecov", "~> 0.22.0", require: false
end
solid-process-0.4.0/LICENSE.txt 0000664 0000000 0000000 00000002074 14636022670 0016135 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.4.0/README.md 0000664 0000000 0000000 00000010363 14636022670 0015571 0 ustar 00root root 0000000 0000000
⚛️ Solid::Process
Write business logic for Ruby/Rails that scales.
## Supported Ruby and Rails
This library is tested against:
| Ruby / Rails | 6.0 | 6.1 | 7.0 | 7.1 | Edge |
|--------------|-----|-----|-----|-----|------|
| 2.7 | ✅ | ✅ | ✅ | ✅ | |
| 3.0 | ✅ | ✅ | ✅ | ✅ | |
| 3.1 | ✅ | ✅ | ✅ | ✅ | ✅ |
| 3.2 | ✅ | ✅ | ✅ | ✅ | ✅ |
| 3.3 | ✅ | ✅ | ✅ | ✅ | ✅ |
| Head | | | | ✅ | ✅ |
## 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.
**Key Objectives:**
1. **Seamless Rails integration:** Designed to fully complement the Ruby on Rails framework, this library integrates smoothly without conflicting with existing Rails conventions and capabilities.
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.
4. **Minimize technical debt:** Facilitate smoother transitions and updates as your application expands and your team size increases.
5. **Enhanced observability:** Equipped with sophisticated instrumentation mechanisms, the library enables detailed logging and tracing without compromising clarity, even when processes are nested. This ensures the code is both easy to understand and to observe.
### Examples
Checkout the [solid-rails-app](https://github.com/solid-process/solid-rails-app) for a full example of how to use `solid-process` in a Rails application. Or take a look at the [examples](examples) folder in this repository.
## Installation
Add this line to your application's Gemfile:
```ruby
gem 'solid-process'
```
And then execute:
```bash
$ bundle install
```
Or install it yourself as:
```bash
$ gem install solid-process
```
## Usage
TODO: Write usage instructions here
## Development
After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake dev` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
## 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).
## License
The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
## 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).
solid-process-0.4.0/Rakefile 0000664 0000000 0000000 00000000613 14636022670 0015754 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"
task :dev do
exec "bundle exec appraisal rails-7-1 rake test"
Rake::Task[:standard].invoke
end
task default: %i[test]
solid-process-0.4.0/bin/ 0000775 0000000 0000000 00000000000 14636022670 0015057 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/bin/console 0000775 0000000 0000000 00000000437 14636022670 0016453 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.4.0/bin/setup 0000775 0000000 0000000 00000000203 14636022670 0016140 0 ustar 00root root 0000000 0000000 #!/usr/bin/env bash
set -euo pipefail
IFS=$'\n\t'
set -vx
bundle install
# Do any other automated setup that you need to do here
solid-process-0.4.0/examples/ 0000775 0000000 0000000 00000000000 14636022670 0016125 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/examples/business_processes/ 0000775 0000000 0000000 00000000000 14636022670 0022046 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/examples/business_processes/.rubocop.yml 0000664 0000000 0000000 00000000063 14636022670 0024317 0 ustar 00root root 0000000 0000000 inherit_gem:
standard:
- config/ruby-3.1.yml
solid-process-0.4.0/examples/business_processes/.ruby-version 0000664 0000000 0000000 00000000006 14636022670 0024507 0 ustar 00root root 0000000 0000000 3.2.2
solid-process-0.4.0/examples/business_processes/.standard.yml 0000664 0000000 0000000 00000000022 14636022670 0024441 0 ustar 00root root 0000000 0000000 ruby_version: 3.1
solid-process-0.4.0/examples/business_processes/Gemfile 0000664 0000000 0000000 00000000475 14636022670 0023347 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.4.0/examples/business_processes/Rakefile 0000664 0000000 0000000 00000005207 14636022670 0023517 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.4.0/examples/business_processes/app/ 0000775 0000000 0000000 00000000000 14636022670 0022626 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/examples/business_processes/app/models/ 0000775 0000000 0000000 00000000000 14636022670 0024111 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/examples/business_processes/app/models/account.rb 0000664 0000000 0000000 00000000720 14636022670 0026071 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.4.0/examples/business_processes/app/models/account/ 0000775 0000000 0000000 00000000000 14636022670 0025545 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/examples/business_processes/app/models/account/member.rb 0000664 0000000 0000000 00000000405 14636022670 0027340 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.4.0/examples/business_processes/app/models/account/owner_creation.rb 0000664 0000000 0000000 00000002524 14636022670 0031113 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.4.0/examples/business_processes/app/models/user.rb 0000664 0000000 0000000 00000001054 14636022670 0025414 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.4.0/examples/business_processes/app/models/user/ 0000775 0000000 0000000 00000000000 14636022670 0025067 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/examples/business_processes/app/models/user/creation.rb 0000664 0000000 0000000 00000003504 14636022670 0027222 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.4.0/examples/business_processes/app/models/user/token.rb 0000664 0000000 0000000 00000000224 14636022670 0026532 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.4.0/examples/business_processes/app/models/user/token/ 0000775 0000000 0000000 00000000000 14636022670 0026207 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/examples/business_processes/app/models/user/token/creation.rb 0000664 0000000 0000000 00000002060 14636022670 0030336 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.4.0/examples/business_processes/config.rb 0000664 0000000 0000000 00000000504 14636022670 0023637 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.4.0/examples/business_processes/db/ 0000775 0000000 0000000 00000000000 14636022670 0022433 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/examples/business_processes/db/setup.rb 0000664 0000000 0000000 00000002451 14636022670 0024122 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.4.0/gemfiles/ 0000775 0000000 0000000 00000000000 14636022670 0016102 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/gemfiles/rails_6_0.gemfile 0000664 0000000 0000000 00000000502 14636022670 0021207 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.0"
gem "standard", "~> 1.34"
group :test do
gem "bcrypt", "~> 3.1.20"
gem "sqlite3", "~> 1.7"
gem "minitest", "~> 5.16"
gem "simplecov", "~> 0.22.0", require: false
gem "activerecord", "~> 6.0.0"
end
gemspec path: "../"
solid-process-0.4.0/gemfiles/rails_6_1.gemfile 0000664 0000000 0000000 00000000502 14636022670 0021210 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.0"
gem "standard", "~> 1.34"
group :test do
gem "bcrypt", "~> 3.1.20"
gem "sqlite3", "~> 1.7"
gem "minitest", "~> 5.16"
gem "simplecov", "~> 0.22.0", require: false
gem "activerecord", "~> 6.1.0"
end
gemspec path: "../"
solid-process-0.4.0/gemfiles/rails_7_0.gemfile 0000664 0000000 0000000 00000000502 14636022670 0021210 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.0"
gem "standard", "~> 1.34"
group :test do
gem "bcrypt", "~> 3.1.20"
gem "sqlite3", "~> 1.7"
gem "minitest", "~> 5.16"
gem "simplecov", "~> 0.22.0", require: false
gem "activerecord", "~> 7.0.0"
end
gemspec path: "../"
solid-process-0.4.0/gemfiles/rails_7_1.gemfile 0000664 0000000 0000000 00000000502 14636022670 0021211 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.0"
gem "standard", "~> 1.34"
group :test do
gem "bcrypt", "~> 3.1.20"
gem "sqlite3", "~> 1.7"
gem "minitest", "~> 5.16"
gem "simplecov", "~> 0.22.0", require: false
gem "activerecord", "~> 7.1.0"
end
gemspec path: "../"
solid-process-0.4.0/gemfiles/rails_edge.gemfile 0000664 0000000 0000000 00000000535 14636022670 0021535 0 ustar 00root root 0000000 0000000 # This file was generated by Appraisal
source "https://rubygems.org"
gem "rake", "~> 13.0"
gem "standard", "~> 1.34"
group :test do
gem "bcrypt", "~> 3.1.20"
gem "sqlite3", "~> 1.7"
gem "minitest", "~> 5.16"
gem "simplecov", "~> 0.22.0", require: false
gem "activerecord", github: "rails/rails", branch: "main"
end
gemspec path: "../"
solid-process-0.4.0/lib/ 0000775 0000000 0000000 00000000000 14636022670 0015055 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/lib/solid/ 0000775 0000000 0000000 00000000000 14636022670 0016167 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/lib/solid/input.rb 0000664 0000000 0000000 00000000117 14636022670 0017652 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Input
include ::Solid::Model
end
solid-process-0.4.0/lib/solid/model.rb 0000664 0000000 0000000 00000001623 14636022670 0017616 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.4.0/lib/solid/model/ 0000775 0000000 0000000 00000000000 14636022670 0017267 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/lib/solid/model/access.rb 0000664 0000000 0000000 00000001520 14636022670 0021053 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.4.0/lib/solid/output.rb 0000664 0000000 0000000 00000000311 14636022670 0020047 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.4.0/lib/solid/process.rb 0000664 0000000 0000000 00000007000 14636022670 0020167 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.4.0/lib/solid/process/ 0000775 0000000 0000000 00000000000 14636022670 0017645 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/lib/solid/process/active_record.rb 0000664 0000000 0000000 00000000633 14636022670 0023005 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.4.0/lib/solid/process/backtrace_cleaner.rb 0000664 0000000 0000000 00000000552 14636022670 0023604 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 `then'|internal:kernel|block \(\d+ levels?\) in/.freeze
def add_blocks_silencer
add_silencer { |line| line.match?(BLOCKS_PATTERN) }
end
end
solid-process-0.4.0/lib/solid/process/callbacks.rb 0000664 0000000 0000000 00000001501 14636022670 0022106 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.4.0/lib/solid/process/caller.rb 0000664 0000000 0000000 00000001571 14636022670 0021440 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.4.0/lib/solid/process/class_methods.rb 0000664 0000000 0000000 00000002215 14636022670 0023022 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.4.0/lib/solid/process/config.rb 0000664 0000000 0000000 00000001426 14636022670 0021442 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.4.0/lib/solid/process/error.rb 0000664 0000000 0000000 00000000137 14636022670 0021324 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Process
Error = ::Class.new(::StandardError)
end
solid-process-0.4.0/lib/solid/process/event_logs.rb 0000664 0000000 0000000 00000000211 14636022670 0022331 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.4.0/lib/solid/process/event_logs/ 0000775 0000000 0000000 00000000000 14636022670 0022012 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/lib/solid/process/event_logs/basic_logger_listener.rb 0000664 0000000 0000000 00000004313 14636022670 0026665 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Process::EventLogs::BasicLoggerListener
include ActiveSupport::Configurable
include Solid::Result::EventLogs::Listener
config_accessor(: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.4.0/lib/solid/process/version.rb 0000664 0000000 0000000 00000000134 14636022670 0021655 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid
class Process
VERSION = "0.4.0"
end
end
solid-process-0.4.0/lib/solid/validators.rb 0000664 0000000 0000000 00000000533 14636022670 0020665 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.4.0/lib/solid/validators/ 0000775 0000000 0000000 00000000000 14636022670 0020337 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/lib/solid/validators/email_validator.rb 0000664 0000000 0000000 00000000526 14636022670 0024023 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.4.0/lib/solid/validators/id_validator.rb 0000664 0000000 0000000 00000000673 14636022670 0023333 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.4.0/lib/solid/validators/instance_of_validator.rb 0000664 0000000 0000000 00000000675 14636022670 0025231 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.4.0/lib/solid/validators/is_validator.rb 0000664 0000000 0000000 00000001123 14636022670 0023341 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.4.0/lib/solid/validators/kind_of_validator.rb 0000664 0000000 0000000 00000000645 14636022670 0024347 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.4.0/lib/solid/validators/respond_to_validator.rb 0000664 0000000 0000000 00000000663 14636022670 0025112 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.4.0/lib/solid/validators/singleton_validator.rb 0000664 0000000 0000000 00000001253 14636022670 0024734 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.4.0/lib/solid/validators/uuid_validator.rb 0000664 0000000 0000000 00000001200 14636022670 0023670 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.4.0/lib/solid/value.rb 0000664 0000000 0000000 00000001230 14636022670 0017624 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.4.0/solid-process.gemspec 0000664 0000000 0000000 00000003400 14636022670 0020437 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/serradura/solid-process/CHANGELOG.md"
# Specify which files should be added to the gem when it is released.
# The `git ls-files -z` loads the files in the RubyGem that have been added into git.
spec.files = Dir.chdir(__dir__) do
`git ls-files -z`.split("\x0").reject do |f|
(File.expand_path(f) == __FILE__) ||
f.start_with?(*%w[
.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.4.0/test/ 0000775 0000000 0000000 00000000000 14636022670 0015266 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/solid/ 0000775 0000000 0000000 00000000000 14636022670 0016400 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/solid/input_test.rb 0000664 0000000 0000000 00000000340 14636022670 0021120 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.4.0/test/solid/model/ 0000775 0000000 0000000 00000000000 14636022670 0017500 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/solid/model/access_test.rb 0000664 0000000 0000000 00000004010 14636022670 0022320 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.4.0/test/solid/model/callbacks_test.rb 0000664 0000000 0000000 00000002002 14636022670 0022775 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.4.0/test/solid/model/class_test.rb 0000664 0000000 0000000 00000004157 14636022670 0022200 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.4.0/test/solid/model/instantiation_test.rb 0000664 0000000 0000000 00000000654 14636022670 0023755 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.4.0/test/solid/output/ 0000775 0000000 0000000 00000000000 14636022670 0017740 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/solid/output/methods_test.rb 0000664 0000000 0000000 00000002323 14636022670 0022767 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.4.0/test/solid/output/pattern_matching_test.rb 0000664 0000000 0000000 00000012401 14636022670 0024651 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.4.0/test/solid/process/ 0000775 0000000 0000000 00000000000 14636022670 0020056 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/solid/process/backtrace_cleaner_test.rb 0000664 0000000 0000000 00000003172 14636022670 0025055 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.match?(/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.4.0/test/solid/process/callbacks/ 0000775 0000000 0000000 00000000000 14636022670 0021775 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/solid/process/callbacks/after_test.rb 0000664 0000000 0000000 00000005244 14636022670 0024467 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.4.0/test/solid/process/callbacks/around_call_test.rb 0000664 0000000 0000000 00000003221 14636022670 0025642 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.4.0/test/solid/process/callbacks/before_call_test.rb 0000664 0000000 0000000 00000002412 14636022670 0025615 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.4.0/test/solid/process/config_test.rb 0000664 0000000 0000000 00000004306 14636022670 0022712 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.4.0/test/solid/process/dependencies/ 0000775 0000000 0000000 00000000000 14636022670 0022504 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/solid/process/dependencies/assignment_alias_test.rb 0000664 0000000 0000000 00000003277 14636022670 0027422 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.4.0/test/solid/process/dependencies/assignment_test.rb 0000664 0000000 0000000 00000003352 14636022670 0026243 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.4.0/test/solid/process/dependencies/result_test.rb 0000664 0000000 0000000 00000006104 14636022670 0025407 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.4.0/test/solid/process/event_logs/ 0000775 0000000 0000000 00000000000 14636022670 0022223 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/solid/process/event_logs/basic_logger_listener_test.rb 0000664 0000000 0000000 00000010154 14636022670 0030135 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.4.0/test/solid/process/inheritance_test.rb 0000664 0000000 0000000 00000000637 14636022670 0023741 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.4.0/test/solid/process/input/ 0000775 0000000 0000000 00000000000 14636022670 0021215 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/solid/process/input/access_test.rb 0000664 0000000 0000000 00000003473 14636022670 0024051 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.4.0/test/solid/process/input/assignment_test.rb 0000664 0000000 0000000 00000004155 14636022670 0024756 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.4.0/test/solid/process/input/block_test.rb 0000664 0000000 0000000 00000003135 14636022670 0023675 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.4.0/test/solid/process/input/inspect_test.rb 0000664 0000000 0000000 00000001037 14636022670 0024247 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.4.0/test/solid/process/input/undefined_test.rb 0000664 0000000 0000000 00000000632 14636022670 0024543 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.4.0/test/solid/process/instance_test.rb 0000664 0000000 0000000 00000022307 14636022670 0023252 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.4.0/test/solid/process/rescue_from_test.rb 0000664 0000000 0000000 00000005107 14636022670 0023756 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.4.0/test/solid/process/result_test.rb 0000664 0000000 0000000 00000005645 14636022670 0022772 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.4.0/test/solid/process/version_test.rb 0000664 0000000 0000000 00000000314 14636022670 0023125 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.4.0/test/solid/validators/ 0000775 0000000 0000000 00000000000 14636022670 0020550 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/solid/validators/email_validator_test.rb 0000664 0000000 0000000 00000002704 14636022670 0025273 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.4.0/test/solid/validators/id_validator_test.rb 0000664 0000000 0000000 00000004566 14636022670 0024610 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.4.0/test/solid/validators/instance_of_validator_test.rb 0000664 0000000 0000000 00000002507 14636022670 0026475 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.4.0/test/solid/validators/is_validator_test.rb 0000664 0000000 0000000 00000003703 14636022670 0024617 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.4.0/test/solid/validators/kind_of_validator_test.rb 0000664 0000000 0000000 00000002431 14636022670 0025612 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.4.0/test/solid/validators/respond_to_validator_test.rb 0000664 0000000 0000000 00000002026 14636022670 0026355 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.4.0/test/solid/validators/singleton_validator_test.rb 0000664 0000000 0000000 00000003552 14636022670 0026210 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.4.0/test/solid/validators/uuid_validator_test.rb 0000664 0000000 0000000 00000006107 14636022670 0025153 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.4.0/test/solid/value/ 0000775 0000000 0000000 00000000000 14636022670 0017514 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/solid/value/access_test.rb 0000664 0000000 0000000 00000001437 14636022670 0022346 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.4.0/test/solid/value/callbacks_test.rb 0000664 0000000 0000000 00000001663 14636022670 0023025 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.4.0/test/solid/value/class_test.rb 0000664 0000000 0000000 00000002547 14636022670 0022215 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.4.0/test/solid/value/instantiation_test.rb 0000664 0000000 0000000 00000000664 14636022670 0023772 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.4.0/test/solid/value_test.rb 0000664 0000000 0000000 00000001642 14636022670 0021103 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.4.0/test/support/ 0000775 0000000 0000000 00000000000 14636022670 0017002 5 ustar 00root root 0000000 0000000 solid-process-0.4.0/test/support/000_test_utils.rb 0000664 0000000 0000000 00000000247 14636022670 0022110 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.4.0/test/support/001_runtime_breaker.rb 0000664 0000000 0000000 00000000577 14636022670 0023076 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.4.0/test/support/010_setup_sqlite.rb 0000664 0000000 0000000 00000002501 14636022670 0022426 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.4.0/test/support/020_active_record_models.rb 0000664 0000000 0000000 00000002473 14636022670 0024072 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"
enum role: {owner: 0, admin: 1, contributor: 2}
belongs_to :user, inverse_of: :memberships
belongs_to :account, inverse_of: :memberships
end
solid-process-0.4.0/test/support/030_user_creation_without_deps.rb 0000664 0000000 0000000 00000002537 14636022670 0025360 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(input)
rollback_on_failure do
Given(input)
.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.4.0/test/support/040_user_creation_with_dependencies.rb 0000664 0000000 0000000 00000003332 14636022670 0026316 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(input)
rollback_on_failure do
Given(input)
.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.4.0/test/support/051_user_token_creation.rb 0000664 0000000 0000000 00000002071 14636022670 0023756 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.4.0/test/support/052_user_creation.rb 0000664 0000000 0000000 00000003573 14636022670 0022567 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.4.0/test/support/053_account_owner_creation.rb 0000664 0000000 0000000 00000002576 14636022670 0024462 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.4.0/test/test_helper.rb 0000664 0000000 0000000 00000001042 14636022670 0020126 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