pax_global_header 0000666 0000000 0000000 00000000064 14575314650 0014524 g ustar 00root root 0000000 0000000 52 comment=e51f3e9de448721ef6e06bc3dcb5b29c1a039bbe
solid-process-0.1.0/ 0000775 0000000 0000000 00000000000 14575314650 0014310 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/.github/ 0000775 0000000 0000000 00000000000 14575314650 0015650 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/.github/workflows/ 0000775 0000000 0000000 00000000000 14575314650 0017705 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/.github/workflows/main.yml 0000664 0000000 0000000 00000003067 14575314650 0021362 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.1.0/.gitignore 0000664 0000000 0000000 00000000211 14575314650 0016272 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.1.0/.rubocop.yml 0000664 0000000 0000000 00000000063 14575314650 0016561 0 ustar 00root root 0000000 0000000 inherit_gem:
standard:
- config/ruby-2.7.yml
solid-process-0.1.0/.standard.yml 0000664 0000000 0000000 00000000127 14575314650 0016711 0 ustar 00root root 0000000 0000000 ruby_version: 2.7
ignore:
- ./examples/**/*
- ./**/*.gemfile.lock
- Gemfile.lock
solid-process-0.1.0/Appraisals 0000664 0000000 0000000 00000001063 14575314650 0016332 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.1.0/CHANGELOG.md 0000664 0000000 0000000 00000000074 14575314650 0016122 0 ustar 00root root 0000000 0000000 ## [Unreleased]
## [0.1.0] - 2024-03-16
- Initial release
solid-process-0.1.0/CODE_OF_CONDUCT.md 0000664 0000000 0000000 00000012151 14575314650 0017107 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.1.0/Gemfile 0000664 0000000 0000000 00000000511 14575314650 0015600 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.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
end
solid-process-0.1.0/LICENSE.txt 0000664 0000000 0000000 00000002074 14575314650 0016136 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.1.0/README.md 0000664 0000000 0000000 00000005357 14575314650 0015601 0 ustar 00root root 0000000 0000000
🚄 Solid::Process
Ruby on Rails + Business Processes
## 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 | | | | ✅ | ✅ |
## 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/serradura/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/serradura/solid-process/blob/master/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/serradura/solid-process/blob/master/CODE_OF_CONDUCT.md).
solid-process-0.1.0/Rakefile 0000664 0000000 0000000 00000000613 14575314650 0015755 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.1.0/bin/ 0000775 0000000 0000000 00000000000 14575314650 0015060 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/bin/console 0000775 0000000 0000000 00000000437 14575314650 0016454 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.1.0/bin/setup 0000775 0000000 0000000 00000000203 14575314650 0016141 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.1.0/examples/ 0000775 0000000 0000000 00000000000 14575314650 0016126 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/examples/business_processes/ 0000775 0000000 0000000 00000000000 14575314650 0022047 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/examples/business_processes/.rubocop.yml 0000664 0000000 0000000 00000000063 14575314650 0024320 0 ustar 00root root 0000000 0000000 inherit_gem:
standard:
- config/ruby-3.1.yml
solid-process-0.1.0/examples/business_processes/.ruby-version 0000664 0000000 0000000 00000000006 14575314650 0024510 0 ustar 00root root 0000000 0000000 3.2.2
solid-process-0.1.0/examples/business_processes/.standard.yml 0000664 0000000 0000000 00000000022 14575314650 0024442 0 ustar 00root root 0000000 0000000 ruby_version: 3.1
solid-process-0.1.0/examples/business_processes/Gemfile 0000664 0000000 0000000 00000000475 14575314650 0023350 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.1.0/examples/business_processes/Rakefile 0000664 0000000 0000000 00000005207 14575314650 0023520 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.1.0/examples/business_processes/app/ 0000775 0000000 0000000 00000000000 14575314650 0022627 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/examples/business_processes/app/models/ 0000775 0000000 0000000 00000000000 14575314650 0024112 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/examples/business_processes/app/models/account.rb 0000664 0000000 0000000 00000000720 14575314650 0026072 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.1.0/examples/business_processes/app/models/account/ 0000775 0000000 0000000 00000000000 14575314650 0025546 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/examples/business_processes/app/models/account/member.rb 0000664 0000000 0000000 00000000405 14575314650 0027341 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.1.0/examples/business_processes/app/models/account/owner_creation.rb 0000664 0000000 0000000 00000002524 14575314650 0031114 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.1.0/examples/business_processes/app/models/user.rb 0000664 0000000 0000000 00000001054 14575314650 0025415 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.1.0/examples/business_processes/app/models/user/ 0000775 0000000 0000000 00000000000 14575314650 0025070 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/examples/business_processes/app/models/user/creation.rb 0000664 0000000 0000000 00000003504 14575314650 0027223 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.1.0/examples/business_processes/app/models/user/token.rb 0000664 0000000 0000000 00000000224 14575314650 0026533 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.1.0/examples/business_processes/app/models/user/token/ 0000775 0000000 0000000 00000000000 14575314650 0026210 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/examples/business_processes/app/models/user/token/creation.rb 0000664 0000000 0000000 00000002060 14575314650 0030337 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.1.0/examples/business_processes/config.rb 0000664 0000000 0000000 00000000504 14575314650 0023640 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.1.0/examples/business_processes/db/ 0000775 0000000 0000000 00000000000 14575314650 0022434 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/examples/business_processes/db/setup.rb 0000664 0000000 0000000 00000002451 14575314650 0024123 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.1.0/gemfiles/ 0000775 0000000 0000000 00000000000 14575314650 0016103 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/gemfiles/rails_6_0.gemfile 0000664 0000000 0000000 00000000502 14575314650 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.0.0"
end
gemspec path: "../"
solid-process-0.1.0/gemfiles/rails_6_1.gemfile 0000664 0000000 0000000 00000000502 14575314650 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", "~> 6.1.0"
end
gemspec path: "../"
solid-process-0.1.0/gemfiles/rails_7_0.gemfile 0000664 0000000 0000000 00000000502 14575314650 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.0.0"
end
gemspec path: "../"
solid-process-0.1.0/gemfiles/rails_7_1.gemfile 0000664 0000000 0000000 00000000502 14575314650 0021212 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.1.0/gemfiles/rails_edge.gemfile 0000664 0000000 0000000 00000000535 14575314650 0021536 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.1.0/lib/ 0000775 0000000 0000000 00000000000 14575314650 0015056 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/lib/solid/ 0000775 0000000 0000000 00000000000 14575314650 0016170 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/lib/solid/input.rb 0000664 0000000 0000000 00000000303 14575314650 0017650 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Input
require_relative "model"
def self.inherited(subclass)
subclass.include(::Solid::Model)
end
def self.[](...)
new(...)
end
end
solid-process-0.1.0/lib/solid/model.rb 0000664 0000000 0000000 00000001103 14575314650 0017610 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid::Model
require_relative "model/access"
extend ::ActiveSupport::Concern
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
end
def inspect
"#<#{self.class.name} #{attributes.map { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>"
end
end
solid-process-0.1.0/lib/solid/model/ 0000775 0000000 0000000 00000000000 14575314650 0017270 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/lib/solid/model/access.rb 0000664 0000000 0000000 00000001520 14575314650 0021054 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.1.0/lib/solid/process.rb 0000664 0000000 0000000 00000003265 14575314650 0020201 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "active_support/all"
require "active_model"
require "bcdd/result"
module Solid
require "solid/input"
require "solid/result"
class Process
require "solid/process/version"
require "solid/process/error"
require "solid/process/caller"
require "solid/process/callbacks"
require "solid/process/class_methods"
require "solid/process/active_record"
extend ClassMethods
include ::BCDD::Context.mixin(config: {addon: {continue: true}})
def self.inherited(subclass)
subclass.prepend(Caller)
subclass.include(Callbacks)
end
def self.call(arg = nil)
new.call(arg)
end
attr_accessor :input, :output, :dependencies
private :input=, :output=, :dependencies=
def initialize(arg = nil)
self.dependencies = self.class.dependencies&.then { arg.instance_of?(_1) ? arg : _1.new(arg) }
end
def input?
!input.nil?
end
def output?(type = nil)
type.nil? ? !output.nil? : !!output&.is?(type)
end
def dependencies?
!dependencies.nil?
end
def call(_arg = nil)
raise Error, "#{self.class}#call must be implemented."
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?
end
end
solid-process-0.1.0/lib/solid/process/ 0000775 0000000 0000000 00000000000 14575314650 0017646 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/lib/solid/process/active_record.rb 0000664 0000000 0000000 00000000633 14575314650 0023006 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.1.0/lib/solid/process/callbacks.rb 0000664 0000000 0000000 00000001745 14575314650 0022121 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(:success, :failure, :output)
subclass.extend ClassMethods
end
module ClassMethods
def after_success(*args, &block)
options = args.extract_options!
options = options.dup
options[:prepend] = true
set_callback(:success, :after, *args, options, &block)
end
def after_failure(*args, &block)
options = args.extract_options!
options = options.dup
options[:prepend] = true
set_callback(:failure, :after, *args, options, &block)
end
def after_output(*args, &block)
options = args.extract_options!
options = options.dup
options[:prepend] = true
set_callback(:output, :after, *args, options, &block)
end
alias_method :after_result, :after_output
end
end
end
solid-process-0.1.0/lib/solid/process/caller.rb 0000664 0000000 0000000 00000001604 14575314650 0021436 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Process
module Caller
def call(arg = nil)
if output?
raise Error, "#{self.class}#call already called. " \
"Use #{self.class}#output to access the result or create a new instance to call again."
end
self.input = self.class.input.then { arg.instance_of?(_1) ? arg : _1.new(arg) }
::BCDD::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.deep_symbolize_keys)
end
end
run_callbacks(:success) if output.success?
run_callbacks(:failure) if output.failure?
run_callbacks(:output)
output
end
end
end
solid-process-0.1.0/lib/solid/process/class_methods.rb 0000664 0000000 0000000 00000002622 14575314650 0023025 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"
unless klass.is_a?(::Class) && klass < ::Solid::Model
raise ArgumentError, "#{klass.inspect} must be a class that includes #{::Solid::Model}"
end
const_set(:Input, 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(::Solid::Input)
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"
unless klass.is_a?(::Class) && klass < ::Solid::Model
raise ArgumentError, "#{klass.inspect} must be a class that includes #{::Solid::Model}"
end
const_set(:Dependencies, klass)
end
def dependencies(&block)
return const_get(:Dependencies, false) if const_defined?(:Dependencies, false)
return if block.nil?
klass = ::Class.new(::Solid::Input)
klass.class_eval(&block)
self.dependencies = klass
end
alias_method :deps, :dependencies
alias_method :deps=, :dependencies=
end
end
solid-process-0.1.0/lib/solid/process/error.rb 0000664 0000000 0000000 00000000137 14575314650 0021325 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class Solid::Process
Error = ::Class.new(::StandardError)
end
solid-process-0.1.0/lib/solid/process/version.rb 0000664 0000000 0000000 00000000134 14575314650 0021656 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid
class Process
VERSION = "0.1.0"
end
end
solid-process-0.1.0/lib/solid/result.rb 0000664 0000000 0000000 00000000417 14575314650 0020035 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
module Solid
Output = ::BCDD::Context
Result = ::BCDD::Context
Success = Result::Success
Failure = Result::Failure
def self.Success(...)
Result::Success(...)
end
def self.Failure(...)
Result::Failure(...)
end
end
solid-process-0.1.0/lib/solid/validators/ 0000775 0000000 0000000 00000000000 14575314650 0020340 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/lib/solid/validators/all.rb 0000664 0000000 0000000 00000000555 14575314650 0021442 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require_relative "instance_of_validator"
require_relative "is_a_validator"
require_relative "kind_of_validator"
require_relative "respond_to_validator"
require_relative "singleton_validator"
require_relative "bool_validator"
require_relative "email_validator"
require_relative "persisted_validator"
require_relative "uuid_validator"
solid-process-0.1.0/lib/solid/validators/bool_validator.rb 0000664 0000000 0000000 00000000374 14575314650 0023671 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class BoolValidator < ActiveModel::EachValidator
def validate_each(obj, attribute, value)
return if value == true || value == false
obj.errors.add attribute, (options[:message] || "is not a boolean")
end
end
solid-process-0.1.0/lib/solid/validators/email_validator.rb 0000664 0000000 0000000 00000000433 14575314650 0024021 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class EmailValidator < ActiveModel::EachValidator
def validate_each(obj, attribute, value)
return if value.is_a?(String) && URI::MailTo::EMAIL_REGEXP.match?(value)
obj.errors.add attribute, (options[:message] || "is not an email")
end
end
solid-process-0.1.0/lib/solid/validators/instance_of_validator.rb 0000664 0000000 0000000 00000000641 14575314650 0025223 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class InstanceOfValidator < ActiveModel::EachValidator
def validate_each(obj, attribute, value)
with_option = Array.wrap(options[:with] || options[:in])
return if with_option.any? { |type| value.instance_of?(type) }
expectation = with_option.map(&:name).join(" | ")
obj.errors.add(attribute, (options[:message] || "is not an instance of #{expectation}"))
end
end
solid-process-0.1.0/lib/solid/validators/is_a_validator.rb 0000664 0000000 0000000 00000000156 14575314650 0023647 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require_relative "kind_of_validator"
class IsAValidator < KindOfValidator
end
solid-process-0.1.0/lib/solid/validators/kind_of_validator.rb 0000664 0000000 0000000 00000000611 14575314650 0024341 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class KindOfValidator < ActiveModel::EachValidator
def validate_each(obj, attribute, value)
with_option = Array.wrap(options[:with] || options[:in])
return if with_option.any? { |type| value.is_a?(type) }
expectation = with_option.map(&:name).join(" | ")
obj.errors.add(attribute, (options[:message] || "is not a #{expectation}"))
end
end
solid-process-0.1.0/lib/solid/validators/persisted_validator.rb 0000664 0000000 0000000 00000000447 14575314650 0024741 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class PersistedValidator < ActiveModel::EachValidator
def validate_each(record, attribute, value)
return if (options[:allow_nil] && value.nil?) || value.try(:persisted?)
record.errors.add(attribute, (options[:message] || "must be persisted"))
end
end
solid-process-0.1.0/lib/solid/validators/respond_to_validator.rb 0000664 0000000 0000000 00000000627 14575314650 0025113 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class RespondToValidator < ActiveModel::EachValidator
def validate_each(obj, attribute, value)
with_option = Array.wrap(options[:with] || options[:in])
return if with_option.all? { value.respond_to?(_1) }
expectation = with_option.map(&:inspect).join(" & ")
obj.errors.add(attribute, (options[:message] || "does not respond to #{expectation}"))
end
end
solid-process-0.1.0/lib/solid/validators/singleton_validator.rb 0000664 0000000 0000000 00000001244 14575314650 0024735 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class SingletonValidator < ActiveModel::EachValidator
def validate_each(obj, attribute, value)
with_option = Array.wrap(options[:with] || options[:in])
unless value.is_a?(Module)
return obj.errors.add(attribute, options[:message] || "is not a class or module")
end
is_valid = with_option.any? do |type|
type.is_a?(Module) or raise ArgumentError, "#{type.inspect} is not a class or module"
value == type || (value < type || value.is_a?(type))
end
expectation = with_option.map(&:name).join(" | ")
is_valid or obj.errors.add(attribute, (options[:message] || "is not #{expectation}"))
end
end
solid-process-0.1.0/lib/solid/validators/uuid_validator.rb 0000664 0000000 0000000 00000001226 14575314650 0023701 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(obj, attribute, value)
case_sensitive = options.fetch(:case_sensitive, true)
regexp = case_sensitive ? CASE_SENSITIVE : CASE_INSENSITIVE
return if value.is_a?(String) && value.match?(regexp)
message = options[:message] || "is not a valid UUID (case #{case_sensitive ? "sensitive" : "insensitive"})"
obj.errors.add(attribute, message)
end
private_constant :PATTERN
end
solid-process-0.1.0/solid-process.gemspec 0000664 0000000 0000000 00000003354 14575314650 0020450 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 = "Ruby on Rails + Business Processes"
spec.description = "Ruby on Rails + Business Processes"
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 "bcdd-result", "~> 1.0"
spec.add_dependency "activemodel", ">= 6.0", "< 8.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.1.0/test/ 0000775 0000000 0000000 00000000000 14575314650 0015267 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/test/solid/ 0000775 0000000 0000000 00000000000 14575314650 0016401 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/test/solid/input/ 0000775 0000000 0000000 00000000000 14575314650 0017540 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/test/solid/input/access_test.rb 0000664 0000000 0000000 00000003106 14575314650 0022365 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::InputAccessTest < ActiveSupport::TestCase
class PersonInput < Solid::Input
attribute :uuid, :string
attribute :name, :string
attribute :email, :string
end
test "#slice" do
input = PersonInput.new(
uuid: SecureRandom.uuid,
name: "John Doe",
email: "john.doe@example.com"
)
slice1 = input.slice(:uuid, :name, :email)
slice2 = input.slice(:uuid, :email)
slice3 = input.slice(:name)
assert_equal(
{"uuid" => input.uuid, "name" => input.name, "email" => input.email},
slice1
)
assert_instance_of(ActiveSupport::HashWithIndifferentAccess, slice1)
assert_equal({"uuid" => input.uuid, "email" => input.email}, slice2)
assert_instance_of(ActiveSupport::HashWithIndifferentAccess, slice2)
assert_equal({"name" => input.name}, slice3)
assert_instance_of(ActiveSupport::HashWithIndifferentAccess, slice3)
assert_empty(input.slice)
assert_instance_of(ActiveSupport::HashWithIndifferentAccess, input.slice)
end
test "#values_at" do
input = PersonInput.new(
uuid: SecureRandom.uuid,
name: "John Doe",
email: "john.doe@example.com"
)
slice1 = input.values_at(:uuid, :name, :email)
slice2 = input.values_at(:uuid, :email)
slice3 = input.values_at(:name)
assert_equal([input.uuid, input.name, input.email], slice1)
assert_equal([input.uuid, input.email], slice2)
assert_equal([input.name], slice3)
assert_empty(input.values_at)
assert_instance_of(Array, input.values_at)
end
end
solid-process-0.1.0/test/solid/input/class_test.rb 0000664 0000000 0000000 00000004116 14575314650 0022233 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::InputClassTest < ActiveSupport::TestCase
class InputWithDefaults < Solid::Input
attribute :uuid, :string, default: -> { SecureRandom.uuid }
end
test "input with default values" do
uuid = SecureRandom.uuid
input1 = InputWithDefaults.new
input2 = InputWithDefaults.new(uuid: uuid)
assert_match TestUtils::UUID_REGEX, input1.uuid
assert_equal uuid, input2.uuid
end
class InputWithNormalization < Solid::Input
attribute :uuid, :string
before_validation do |input|
input.uuid = input.uuid.strip.downcase
end
end
test "input with normalization (before_validation)" do
uuid = SecureRandom.uuid
input = InputWithNormalization.new(uuid: " #{uuid.upcase} ")
input.valid?
assert_equal uuid, input.uuid
end
class InputWithValidation < Solid::Input
attribute :uuid, :string
validates :uuid, presence: true, format: {with: TestUtils::UUID_REGEX}
end
test "input with validation" do
input1 = InputWithValidation.new
input2 = InputWithValidation.new(uuid: " ")
input3 = InputWithValidation.new(uuid: "invalid")
input4 = InputWithValidation.new(uuid: SecureRandom.uuid)
assert_predicate input1, :invalid?
assert_predicate input2, :invalid?
assert_predicate input3, :invalid?
assert_predicate input4, :valid?
end
test "input ancestors" do
input_class = [InputWithDefaults, InputWithNormalization, InputWithValidation].sample
ancestors = input_class.ancestors
assert_includes ancestors, Solid::Input
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.1.0/test/solid/input/instantiation_test.rb 0000664 0000000 0000000 00000000654 14575314650 0024015 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::InputInstantiationTest < ActiveSupport::TestCase
class MyInput < Solid::Input
attribute :uuid, :string, default: -> { SecureRandom.uuid }
end
test "the new alias" do
uuid = SecureRandom.uuid
input1 = MyInput[]
input2 = MyInput[uuid: uuid]
assert_match TestUtils::UUID_REGEX, input1.uuid
assert_equal uuid, input2.uuid
end
end
solid-process-0.1.0/test/solid/process/ 0000775 0000000 0000000 00000000000 14575314650 0020057 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/test/solid/process/callbacks_test.rb 0000664 0000000 0000000 00000007224 14575314650 0023367 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::CallbacksTest < 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_output if: -> { output.is?(:person_created) } do
callback_numbers[:after_output] << 5
end
after_output if: :person_created? do
callback_numbers[:after_output] << 6
end
after_output if: :user_created? do
callback_numbers[:after_output] << 7
end
after_result if: -> { result.is?(:person_created) } do
callback_numbers[:after_result] << 8
end
after_result if: :person_created? do
callback_numbers[:after_result] << 9
end
after_result if: :user_created? do
callback_numbers[:after_result] << 10
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_output if: -> { output.is?(:invalid_input) } do
callback_numbers[:after_output] << -5
end
after_output if: :invalid_input? do
callback_numbers[:after_output] << -6
end
after_output if: :invalid_person? do
callback_numbers[:after_output] << -7
end
after_result if: -> { result.is?(:invalid_input) } do
callback_numbers[:after_result] << -8
end
after_result if: :invalid_input? do
callback_numbers[:after_result] << -9
end
after_result if: :invalid_person? do
callback_numbers[:after_result] << -10
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_success: [1, 2, 3],
after_output: [5, 6],
after_result: [8, 9]
},
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_failure: [-1, -2, -3],
after_output: [-5, -6],
after_result: [-8, -9]
},
person_creation.callback_numbers
)
end
end
solid-process-0.1.0/test/solid/process/dependencies/ 0000775 0000000 0000000 00000000000 14575314650 0022505 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/test/solid/process/dependencies/assignment_alias_test.rb 0000664 0000000 0000000 00000003277 14575314650 0027423 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.1.0/test/solid/process/dependencies/assignment_test.rb 0000664 0000000 0000000 00000003352 14575314650 0026244 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.1.0/test/solid/process/dependencies/result_test.rb 0000664 0000000 0000000 00000005752 14575314650 0025420 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
[
-> { CreateUser.call(_1) },
-> { CreateUser.new.call(_1) }
].sample
end
def map_input(data)
[data, CreateUser::Input.new(data)].sample
end
test "failure (invalid_dependencies)" do
result = CreateUser.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 CreateUser::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
CreateUser.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 CreateUser::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
CreateUser.new(CreateUser::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.1.0/test/solid/process/inheritance_test.rb 0000664 0000000 0000000 00000000637 14575314650 0023742 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.1.0/test/solid/process/input/ 0000775 0000000 0000000 00000000000 14575314650 0021216 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/test/solid/process/input/access_test.rb 0000664 0000000 0000000 00000003473 14575314650 0024052 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.1.0/test/solid/process/input/assignment_test.rb 0000664 0000000 0000000 00000004155 14575314650 0024757 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.1.0/test/solid/process/input/block_test.rb 0000664 0000000 0000000 00000003135 14575314650 0023676 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.1.0/test/solid/process/input/inspect_test.rb 0000664 0000000 0000000 00000001037 14575314650 0024250 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.1.0/test/solid/process/input/undefined_test.rb 0000664 0000000 0000000 00000000632 14575314650 0024544 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.1.0/test/solid/process/instance_test.rb 0000664 0000000 0000000 00000011704 14575314650 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 "#input" do
user_creation1 = UserCreation.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 = UserCreation.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 = UserCreation.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 = UserCreation.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 = UserCreation.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 = UserCreation.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 = UserCreation.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 = UserCreation.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 = UserCreation.new
assert_nil(user_creation1.dependencies)
assert_nil(user_creation1.deps)
# ---
user_creation2 = CreateUser.new
assert_same(User, user_creation2.dependencies.repository)
assert_same(user_creation2.dependencies, user_creation2.deps)
# ---
user_creation3 = CreateUser.new(repository: ::Object)
assert_same(::Object, user_creation3.dependencies.repository)
assert_same(user_creation3.dependencies, user_creation3.deps)
end
test "#dependencies?" do
user_creation1 = UserCreation.new
refute_predicate user_creation1, :dependencies?
refute_predicate user_creation1, :deps?
# ---
user_creation2 = CreateUser.new
assert_predicate user_creation2, :dependencies?
assert_predicate user_creation2, :deps?
end
test "#call when the output is already set" do
user_creation = UserCreation.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(
"UserCreation#call already called. " \
"Use UserCreation#output to access the result or create a new instance to call again.",
err.message
)
end
test "#inspect" do
user_creation = UserCreation.new
assert_equal("#", user_creation.inspect)
end
test "#method_missing" do
user_creation1 = UserCreation.new
user_creation1.call(name: "John Doe", email: "john.doe@email.com", password: "123123123")
assert_predicate user_creation1, :user_created?
# ---
user_creation2 = UserCreation.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 = UserCreation.new
refute user_creation1.method(:foo?).call
end
end
solid-process-0.1.0/test/solid/process/result/ 0000775 0000000 0000000 00000000000 14575314650 0021375 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/test/solid/process/result/methods_test.rb 0000664 0000000 0000000 00000002323 14575314650 0024424 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::ResultMethodsTest < ActiveSupport::TestCase
test "Solid::Success() with type" do
result = Solid::Success(:ok)
assert_instance_of(BCDD::Context::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(BCDD::Context::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(BCDD::Context::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(BCDD::Context::Failure, result)
assert_kind_of(Solid::Failure, result)
assert result.failure?(:err)
assert_equal({zero: 0}, result.value)
end
end
solid-process-0.1.0/test/solid/process/result/pattern_matching_test.rb 0000664 0000000 0000000 00000012134 14575314650 0026311 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
class Solid::Process::ResultPatterMatchingTest < ActiveSupport::TestCase
def setup
::User.delete_all
end
def user_creation
[
-> { UserCreation.call(_1) },
-> { UserCreation.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
UserCreation.call(input)
end
# --- Solid::Failure ---
case result
in Solid::Failure[:invalid_input, {input: input}]
assert_kind_of Solid::Input, input
assert_instance_of UserCreation::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 UserCreation::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 UserCreation::Input, input
end
case result
in Solid::Failure(input: input)
assert_kind_of Solid::Input, input
assert_instance_of UserCreation::Input, input
end
# --- Solid::Result ---
case result
in Solid::Result[:invalid_input, {input: input}]
assert_kind_of Solid::Input, input
assert_instance_of UserCreation::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 UserCreation::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 UserCreation::Input, input
end
case result
in Solid::Result(input: input)
assert_kind_of Solid::Input, input
assert_instance_of UserCreation::Input, input
end
# --- Solid::Output ---
case result
in Solid::Output[:invalid_input, {input: input}]
assert_kind_of Solid::Input, input
assert_instance_of UserCreation::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 UserCreation::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 UserCreation::Input, input
end
case result
in Solid::Output(input: input)
assert_kind_of Solid::Input, input
assert_instance_of UserCreation::Input, input
end
end
end
solid-process-0.1.0/test/solid/process/result_test.rb 0000664 0000000 0000000 00000005515 14575314650 0022767 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
[
-> { UserCreation.call(_1) },
-> { UserCreation.new.call(_1) }
].sample
end
def map_input(data)
[data, UserCreation::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 UserCreation::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 = UserCreation.call(name: nil, email: nil, password: nil)
result2 = UserCreation.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 = UserCreation.call(name: nil, email: nil, password: nil)
result2 = UserCreation.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.1.0/test/solid/process/version_test.rb 0000664 0000000 0000000 00000000314 14575314650 0023126 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.1.0/test/solid/validators/ 0000775 0000000 0000000 00000000000 14575314650 0020551 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/test/solid/validators/bool_validator_test.rb 0000664 0000000 0000000 00000001636 14575314650 0025143 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
require "solid/validators/bool_validator"
class Solid::BoolValidatorTest < ActiveSupport::TestCase
class Input < Solid::Input
attribute :value1
attribute :value2
validates :value1, bool: true
validates :value2, bool: true, allow_nil: true
end
test "bool validator" do
input = Input.new
input.value1 = true
input.value2 = false
assert_predicate input, :valid?
input.value1 = "true"
input.value2 = "false"
refute_predicate input, :valid?
assert_equal ["is not a boolean"], input.errors[:value1]
assert_equal ["is not a boolean"], input.errors[:value2]
input.value1 = nil
input.value2 = nil
refute_predicate input, :valid?
assert_equal ["is not a boolean"], input.errors[:value1]
assert_empty input.errors[:value2]
input.value1 = true
assert_predicate input, :valid?
end
end
solid-process-0.1.0/test/solid/validators/email_validator_test.rb 0000664 0000000 0000000 00000002726 14575314650 0025300 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 not an email"], input.errors[:email1]
assert_equal ["is not an email"], input.errors[:email2]
assert_equal ["is not an email"], input.errors[:email3]
input.email1 = nil
input.email2 = nil
input.email3 = nil
refute_predicate input, :valid?
assert_equal ["is not an email"], 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 ["is not an email"], input.errors[:email1]
assert_equal ["is not an email"], 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.1.0/test/solid/validators/instance_of_validator_test.rb 0000664 0000000 0000000 00000002507 14575314650 0026476 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.1.0/test/solid/validators/is_a_validator_test.rb 0000664 0000000 0000000 00000002510 14575314650 0025113 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
require "solid/validators/is_a_validator"
class Solid::IsAValidatorTest < ActiveSupport::TestCase
class Input < Solid::Input
attribute :to_sym
attribute :number
attribute :collection
validates :to_sym, is_a: [String, Symbol]
validates :number, is_a: Numeric
validates :collection, is_a: Enumerable, allow_nil: true
end
test "is_a 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?
input.collection = nil
assert_predicate input, :valid?
end
end
solid-process-0.1.0/test/solid/validators/kind_of_validator_test.rb 0000664 0000000 0000000 00000002431 14575314650 0025613 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.1.0/test/solid/validators/persisted_validator_test.rb 0000664 0000000 0000000 00000002601 14575314650 0026203 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "test_helper"
require "solid/validators/persisted_validator"
class Solid::PersistedValidatorTest < ActiveSupport::TestCase
class Input < Solid::Input
attribute :obj1
attribute :obj2
attribute :obj3
validates :obj1, persisted: true
validates :obj2, persisted: true
validates :obj3, persisted: true, allow_nil: true
end
test "persisted validator" do
input = Input.new
input.obj1 = OpenStruct.new(persisted?: true)
input.obj2 = OpenStruct.new(persisted?: true)
input.obj3 = OpenStruct.new(persisted?: true)
assert_predicate input, :valid?
input.obj1 = OpenStruct.new(persisted?: false)
input.obj2 = OpenStruct.new(persisted?: false)
input.obj3 = OpenStruct.new(persisted?: false)
refute_predicate input, :valid?
assert_equal ["must be persisted"], input.errors[:obj1]
assert_equal ["must be persisted"], input.errors[:obj2]
assert_equal ["must be persisted"], input.errors[:obj3]
input.obj1 = nil
input.obj2 = nil
input.obj3 = nil
refute_predicate input, :valid?
assert_equal ["must be persisted"], input.errors[:obj1]
assert_equal ["must be persisted"], input.errors[:obj2]
assert_empty input.errors[:obj3]
input.obj1 = OpenStruct.new(persisted?: true)
input.obj2 = OpenStruct.new(persisted?: true)
assert_predicate input, :valid?
end
end
solid-process-0.1.0/test/solid/validators/respond_to_validator_test.rb 0000664 0000000 0000000 00000002026 14575314650 0026356 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.1.0/test/solid/validators/singleton_validator_test.rb 0000664 0000000 0000000 00000003552 14575314650 0026211 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.1.0/test/solid/validators/uuid_validator_test.rb 0000664 0000000 0000000 00000006563 14575314650 0025162 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 not a valid UUID (case sensitive)"], input.errors[:uuid1]
assert_equal ["is not a valid UUID (case sensitive)"], input.errors[:uuid2]
assert_equal ["is not a valid UUID (case sensitive)"], input.errors[:uuid3]
input.uuid1 = nil
input.uuid2 = nil
input.uuid3 = nil
refute_predicate input, :valid?
assert_equal ["is not a valid UUID (case sensitive)"], 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 ["is not a valid UUID (case sensitive)"], input.errors[:uuid1]
assert_equal ["is not a valid UUID (case sensitive)"], 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 not a valid UUID (case insensitive)"], input.errors[:uuid1]
assert_equal ["is not a valid UUID (case insensitive)"], input.errors[:uuid2]
assert_equal ["is not a valid UUID (case insensitive)"], input.errors[:uuid3]
input.uuid1 = nil
input.uuid2 = nil
input.uuid3 = nil
refute_predicate input, :valid?
assert_equal ["is not a valid UUID (case insensitive)"], 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 ["is not a valid UUID (case insensitive)"], input.errors[:uuid1]
assert_equal ["is not a valid UUID (case insensitive)"], input.errors[:uuid2]
assert_empty input.errors[:uuid3]
input.uuid1 = SecureRandom.uuid
input.uuid2 = nil
assert_predicate input, :valid?
end
end
solid-process-0.1.0/test/support/ 0000775 0000000 0000000 00000000000 14575314650 0017003 5 ustar 00root root 0000000 0000000 solid-process-0.1.0/test/support/00_test_utils.rb 0000664 0000000 0000000 00000000247 14575314650 0022031 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.1.0/test/support/01_setup_sqlite.rb 0000664 0000000 0000000 00000001000 14575314650 0022340 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 :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
end
end
solid-process-0.1.0/test/support/02_user_model.rb 0000664 0000000 0000000 00000000131 14575314650 0021762 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class User < ActiveRecord::Base
has_secure_password
end
solid-process-0.1.0/test/support/03_user_process.rb 0000664 0000000 0000000 00000002524 14575314650 0022351 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class UserCreation < 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.1.0/test/support/04_user_process_with_dependencies.rb 0000664 0000000 0000000 00000003320 14575314650 0026106 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
class CreateUser < 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.1.0/test/test_helper.rb 0000664 0000000 0000000 00000000702 14575314650 0020131 0 ustar 00root root 0000000 0000000 # frozen_string_literal: true
require "simplecov"
SimpleCov.start do
enable_coverage :branch
add_filter "_test.rb"
end
Bundler.require(:default, :test)
$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