subroutine 4.4.0 → 4.5.0

data/test/subroutine/base_test.rb

@@ -1,328 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-module Subroutine
-  class OpTest < TestCase
-
-    def test_simple_fields_definition
-      op = ::SignupOp.new
-      assert_equal %i[email password], op.field_configurations.keys.sort
-    end
-
-    def test_inherited_fields
-      op = ::AdminSignupOp.new
-      assert_equal %i[email password privileges], op.field_configurations.keys.sort
-    end
-
-    def test_class_attribute_usage
-      assert ::AdminSignupOp < ::SignupOp
-
-      sid = ::SignupOp.field_configurations.object_id
-      bid = ::AdminSignupOp.field_configurations.object_id
-
-      refute_equal sid, bid
-    end
-
-    def test_fields_from_inherited_fields_without_inheriting_from_the_class
-      refute ::BusinessSignupOp < ::SignupOp
-
-      user_fields = ::SignupOp.field_configurations.keys
-      biz_fields = ::BusinessSignupOp.field_configurations.keys
-
-      user_fields.each do |field|
-        assert_includes biz_fields, field
-      end
-    end
-
-    def test_fields_from_ignores_except_fields
-      op = ::ExceptFooBarOp.new
-      refute op.field_configurations.key?(:foo)
-      refute op.field_configurations.key?(:bar)
-      assert_equal [:baz], op.field_configurations.keys.sort
-    end
-
-    def test_fields_from_ignores_except_association_fields
-      op = ::ExceptAssociationOp.new
-      refute op.field_configurations.key?(:admin)
-      refute op.field_configurations.key?(:admin_id)
-      refute op.field_configurations.key?(:admin_type)
-    end
-
-    def test_fields_from_only_fields
-      op = ::OnlyFooBarOp.new
-      assert op.field_configurations.key?(:foo)
-      assert op.field_configurations.key?(:bar)
-      refute_equal [:baz], op.field_configurations.keys.sort
-    end
-
-    def test_fields_from_only_association_fields
-      op = ::OnlyAssociationOp.new
-      assert op.field_configurations.key?(:admin)
-      assert op.field_configurations.key?(:admin_type)
-      assert op.field_configurations.key?(:admin_id)
-    end
-
-    def test_defaults_declaration_options
-      op = ::DefaultsOp.new
-      assert_equal "foo", op.foo
-      assert_equal "bar", op.bar
-      assert_equal false, op.baz
-    end
-
-    def test_inherited_defaults_override_correctly
-      op = ::InheritedDefaultsOp.new
-      assert_equal "barstool", op.bar
-    end
-
-    def test_accessors_are_created
-      op = ::SignupOp.new
-
-      assert_respond_to op, :email
-      assert_respond_to op, :email=
-
-      assert_respond_to op, :password
-      assert_respond_to op, :password=
-
-      refute_respond_to ::SignupOp, :email
-      refute_respond_to ::SignupOp, :email=
-      refute_respond_to ::SignupOp, :password
-      refute_respond_to ::SignupOp, :password=
-    end
-
-    def test_defaults_are_applied_to_new_instances
-      op = ::SignupOp.new
-
-      assert_nil op.email
-      assert_nil op.password
-
-      op = ::AdminSignupOp.new
-
-      assert_nil op.email
-      assert_nil op.password
-      assert_equal "min", op.privileges
-
-      op.privileges = "max"
-      assert_equal "max", op.privileges
-    end
-
-    def test_validations_are_evaluated_before_perform_is_invoked
-      op = ::SignupOp.new
-
-      refute op.submit
-
-      refute op.perform_called
-
-      assert_equal ["can't be blank"], op.errors[:email]
-    end
-
-    def test_validation_errors_can_be_inherited_and_transformed
-      op = ::AdminSignupOp.new(email: "foo@bar.com", password: "password123")
-
-      refute op.submit
-
-      assert op.perform_called
-      refute op.perform_finished
-
-      assert_equal ["has gotta be @admin.com"], op.errors[:email]
-    end
-
-    def test_validation_errors_can_be_inherited_and_prefixed
-      op = PrefixedInputsOp.new(user_email_address: "foo@bar.com")
-      refute op.submit
-
-      assert_equal ["has gotta be @admin.com"], op.errors[:user_email_address]
-    end
-
-    def test_when_valid_perform_completes_it_returns_control
-      op = ::SignupOp.new(email: "foo@bar.com", password: "password123")
-      op.submit!
-
-      assert op.perform_called
-      assert op.perform_finished
-
-      u = op.created_user
-
-      assert_equal "foo@bar.com", u.email_address
-    end
-
-    def test_instance_and_class_submit_bang_return_instance
-      assert ::SignupOp.new(email: "foo@bar.com", password: "password123").submit!.is_a?(::SignupOp)
-      assert ::SignupOp.submit!(email: "foo@bar.com", password: "password123").is_a?(::SignupOp)
-    end
-
-    def test_it_raises_an_error_when_used_with_a_bang_and_performing_or_validation_fails
-      op = ::SignupOp.new(email: "foo@bar.com")
-
-      err = assert_raises ::Subroutine::Failure do
-        op.submit!
-      end
-
-      assert_equal "Password can't be blank", err.message
-    end
-
-    def test_uses_failure_class_to_raise_error
-      op = ::CustomFailureClassOp.new
-
-      err = assert_raises ::CustomFailureClassOp::Failure do
-        op.submit!
-      end
-
-      assert_equal "Will never work", err.message
-    end
-
-    def test_the_result_of_perform_doesnt_matter
-      op = ::FalsePerformOp.new
-      assert op.submit!
-    end
-
-    def test_it_allows_submission_from_the_class
-      op = SignupOp.submit
-      assert_equal ["can't be blank"], op.errors[:email]
-
-      assert_raises ::Subroutine::Failure do
-        SignupOp.submit!
-      end
-
-      op = SignupOp.submit! email: "foo@bar.com", password: "password123"
-      assert_equal "foo@bar.com", op.created_user.email_address
-    end
-
-    def test_it_sets_the_params_and_defaults_immediately
-      op = ::AdminSignupOp.new(email: "foo")
-      assert_equal({
-        "email" => "foo",
-      }, op.params)
-
-      assert_equal({
-        "privileges" => "min",
-      }, op.defaults)
-
-      assert_equal({
-        "email" => "foo",
-        "privileges" => "min",
-      }, op.params_with_defaults)
-    end
-
-    def test_it_allows_defaults_to_be_overridden
-      op = ::AdminSignupOp.new(email: "foo", privileges: nil)
-
-      assert_equal({
-        "email" => "foo",
-        "privileges" => nil,
-      }, op.params)
-
-      assert_equal({ "privileges" => "min" }, op.defaults)
-    end
-
-    def test_it_overriding_default_does_not_alter_default
-      op = ::AdminSignupOp.new(email: "foo")
-      op.privileges << "bangbang"
-
-      op = ::AdminSignupOp.new(email: "foo", privileges: nil)
-
-      assert_equal({
-        "email" => "foo",
-        "privileges" => nil,
-      }, op.params)
-
-      assert_equal({
-        "privileges" => "min",
-      }, op.defaults)
-    end
-
-    def test_it_overrides_defaults_with_nils
-      op = ::AdminSignupOp.new(email: "foo", privileges: nil)
-      assert_equal({
-        "privileges" => nil,
-        "email" => "foo",
-      }, op.params)
-    end
-
-    def test_it_casts_params_on_the_way_in
-      op = ::TypeCastOp.new(integer_input: "25")
-      assert_equal(25, op.params["integer_input"])
-
-      op.decimal_input = "25.3"
-      assert_equal(BigDecimal("25.3"), op.params["decimal_input"])
-    end
-
-    def test_it_allow_retrival_of_outputs
-      op = ::SignupOp.submit!(email: "foo@bar.com", password: "password123")
-      u = op.created_user
-
-      assert_equal "foo@bar.com", u.email_address
-    end
-
-    # Hash#with_indifferent_access was changing output objects
-    def test_outputs_are_not_mutated
-      out = { "foo" => "bar" }
-      op = ::SignupOp.new
-      op.send :output, :perform_called, out
-      value = op.perform_called
-      assert_equal out, value
-      assert_equal Hash, value.class
-    end
-
-    def test_it_does_not_omit_the_backtrace_from_the_original_error
-      op = ::ErrorTraceOp.new
-      begin
-        op.submit!
-      rescue Exception => e
-        found = e.backtrace.detect do |msg|
-          msg =~ %r{test/support/ops\.rb:[\d]+.+foo}
-        end
-
-        refute_nil found, "Expected backtrace to include original caller of foo"
-      end
-    end
-
-    def test_a_block_is_accepted_on_instantiation
-      op = ::SignupOp.new do |o|
-        o.email = "foo@bar.com"
-        o.password = "password123!"
-      end
-
-      assert_equal "foo@bar.com", op.email
-      assert_equal "password123!", op.password
-
-      assert_equal true, op.field_provided?(:email)
-      assert_equal true, op.field_provided?(:password)
-    end
-
-    def test_a_block_is_not_accepted_with_submit
-      assert_raises ::ArgumentError do
-        ::SignupOp.submit! do |o|
-          o.email = "foo@bar.com"
-          o.password = "password123!"
-        end
-      end
-
-      assert_raises ::ArgumentError do
-        ::SignupOp.submit do |o|
-          o.email = "foo@bar.com"
-          o.password = "password123!"
-        end
-      end
-    end
-
-    def test_actioncontroller_parameters_can_be_provided
-      raw_params = { email: "foo@bar.com", password: "password123!" }.with_indifferent_access
-      params = ::ActionController::Parameters.new(raw_params)
-      op = SignupOp.new(params)
-      op.submit!
-
-      assert_equal "foo@bar.com", op.email
-      assert_equal "password123!", op.password
-
-      assert_equal raw_params, op.params
-    end
-
-    def test_inspect_is_pretty
-      op = SignupOp.new({ email: "foo@bar.com", password: "password123!" })
-      oid = format('%x', (op.object_id << 1))
-      assert_equal "#<SignupOp:0x#{oid} email: \"foo@bar.com\", password: \"password123!\">", op.inspect
-    end
-
-  end
-end

data/test/subroutine/fields_test.rb

@@ -1,218 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-require "subroutine/fields"
-
-module Subroutine
-  class FieldsTest < TestCase
-
-    class Whatever
-
-      include Subroutine::Fields
-
-      string :foo, default: "foo"
-      string :qux, default: "qux"
-      string :protekted, mass_assignable: false
-
-      integer :bar, default: -> { 3 }, group: :sekret
-      string :protekted_group_input, group: :sekret
-
-      date :baz, group: :the_bazzes
-
-      def initialize(options = {})
-        setup_fields(options)
-      end
-
-    end
-
-    class WhateverWithDefaultsIncluded < Whatever
-      self.include_defaults_in_params = true
-    end
-
-    class MutationBase
-      include Subroutine::Fields
-
-      field :foo, group: :three_letter
-      field :bar, group: :three_letter
-
-    end
-
-    class MutationChild < MutationBase
-
-      field :qux, group: :three_letter
-      field :food, group: :four_letter
-
-    end
-
-    def test_fields_are_configured
-      assert_equal 6, Whatever.field_configurations.size
-      assert_equal :string, Whatever.field_configurations[:foo][:type]
-      assert_equal :string, Whatever.field_configurations[:qux][:type]
-      assert_equal :integer, Whatever.field_configurations[:bar][:type]
-      assert_equal :date, Whatever.field_configurations[:baz][:type]
-      assert_equal :string, Whatever.field_configurations[:protekted][:type]
-      assert_equal :string, Whatever.field_configurations[:protekted_group_input][:type]
-    end
-
-    def test_field_defaults_are_handled
-      instance = Whatever.new
-      assert_equal "foo", instance.foo
-      assert_equal 3, instance.bar
-    end
-
-    def test_fields_can_be_provided
-      instance = Whatever.new(foo: "abc", bar: nil)
-      assert_equal "abc", instance.foo
-      assert_nil instance.bar
-    end
-
-    def test_field_provided
-      instance = Whatever.new(foo: "abc")
-      assert_equal true, instance.field_provided?(:foo)
-      assert_equal false, instance.field_provided?(:bar)
-
-      instance = DefaultsOp.new
-      assert_equal false, instance.field_provided?(:foo)
-
-      instance = DefaultsOp.new(foo: "foo")
-      assert_equal true, instance.field_provided?(:foo)
-    end
-
-    def test_field_provided_include_manual_assigned_fields
-      instance = Whatever.new
-      instance.foo = "bar"
-
-      assert_equal true, instance.field_provided?(:foo)
-      assert_equal false, instance.field_provided?(:bar)
-    end
-
-    def test_invalid_typecast
-      assert_raises "Error for field `baz`: invalid date" do
-        Whatever.new(baz: "2015-13-01")
-      end
-    end
-
-    def test_params_does_not_include_defaults
-      instance = Whatever.new(foo: "abc")
-      assert_equal({ "foo" => "abc" }, instance.provided_params)
-      assert_equal({ "foo" => "foo", "bar" => 3, "qux" => "qux" }, instance.defaults)
-      assert_equal({ "foo" => "abc" }, instance.params)
-      assert_equal({ "foo" => "abc", "bar" => 3, "qux" => "qux" }, instance.params_with_defaults)
-    end
-
-    def test_params_include_defaults_if_globally_configured
-      Subroutine.stubs(:include_defaults_in_params?).returns(true)
-      instance = Whatever.new(foo: "abc")
-      assert Whatever.include_defaults_in_params?
-      assert_equal({ "foo" => "abc" }, instance.provided_params)
-      assert_equal({ "foo" => "foo", "bar" => 3, "qux" => "qux" }, instance.defaults)
-      assert_equal({ "foo" => "abc", "bar" => 3, "qux" => "qux" }, instance.params)
-      assert_equal({ "foo" => "abc", "bar" => 3, "qux" => "qux" }, instance.params_with_defaults)
-    end
-
-    def test_params_includes_defaults_if_opted_into
-      refute Subroutine.include_defaults_in_params?
-      instance = WhateverWithDefaultsIncluded.new(foo: "abc")
-      assert_equal({ "foo" => "abc" }, instance.provided_params)
-      assert_equal({ "foo" => "foo", "bar" => 3, "qux" => "qux" }, instance.defaults)
-      assert_equal({ "foo" => "abc", "bar" => 3, "qux" => "qux" }, instance.params)
-      assert_equal({ "foo" => "abc", "bar" => 3, "qux" => "qux" }, instance.params_with_defaults)
-    end
-
-    def test_named_params_do_not_include_defaults_unless_asked_for
-      instance = Whatever.new(foo: "abc")
-      assert_equal({}, instance.sekret_provided_params)
-      assert_equal({}, instance.sekret_params)
-      assert_equal({ "bar" => 3 }, instance.sekret_params_with_defaults)
-    end
-
-    def test_named_params_include_defaults_if_configured
-      instance = WhateverWithDefaultsIncluded.new(foo: "abc")
-      assert_equal({}, instance.sekret_provided_params)
-      assert_equal({ "bar" => 3 }, instance.sekret_params)
-      assert_equal({ "bar" => 3 }, instance.sekret_params_with_defaults)
-    end
-
-    def test_fields_can_opt_out_of_mass_assignment
-      assert_raises Subroutine::Fields::MassAssignmentError do
-        Whatever.new(foo: "abc", protekted: "foo")
-      end
-    end
-
-    def test_non_mass_assignment_fields_can_be_individually_assigned
-      instance = Whatever.new(foo: "abc")
-      instance.protekted = "bar"
-
-      assert_equal "bar", instance.protekted
-      assert_equal true, instance.field_provided?(:protekted)
-    end
-
-    def test_get_field
-      instance = Whatever.new
-
-      assert_equal "foo", instance.get_field(:foo)
-    end
-
-    def test_set_field
-      instance = Whatever.new
-      instance.set_field(:foo, "bar")
-
-      assert_equal "bar", instance.foo
-    end
-
-    def test_set_field_adds_to_provided_params
-      instance = Whatever.new
-      instance.set_field(:foo, "bar")
-      assert_equal true, instance.provided_params.key?(:foo)
-    end
-
-    def test_set_field_can_add_to_the_default_params
-      instance = Whatever.new
-      instance.set_field(:foo, "bar", group_type: :default)
-      assert_equal false, instance.provided_params.key?(:foo)
-      assert_equal "bar", instance.default_params[:foo]
-    end
-
-    def test_group_fields_are_accessible_at_the_class
-      fields = Whatever.fields_by_group[:sekret].sort
-      assert_equal %i[bar protekted_group_input], fields
-    end
-
-    def test_groups_fields_are_accessible
-      op = Whatever.new(foo: "bar", protekted_group_input: "pgi", bar: 8)
-      assert_equal({ protekted_group_input: "pgi", bar: 8 }.with_indifferent_access, op.sekret_params)
-      assert_equal({ protekted_group_input: "pgi", foo: "bar", bar: 8 }.with_indifferent_access, op.params)
-    end
-
-    def test_fields_from_allows_merging_of_config
-      op = GroupedDefaultsOp.new(foo: "foo")
-      assert_equal({ foo: "foo" }.with_indifferent_access, op.params)
-      assert_equal({ foo: "foo" }.with_indifferent_access, op.inherited_params)
-      assert_equal({ foo: "foo", bar: "bar", baz: false }.with_indifferent_access, op.params_with_defaults)
-      assert_equal({ foo: "foo", bar: "bar", baz: false }.with_indifferent_access, op.inherited_params_with_defaults)
-      assert_equal({}.with_indifferent_access, op.without_inherited_params)
-    end
-
-    def test_fields_are_inherited_to_subclasses
-      assert_equal(%i[amount_cents], ParentInheritanceOp.field_configurations.keys.sort)
-      assert_equal(%i[debit_cents], ParentInheritanceOp::EarlyInheritanceOp.field_configurations.keys.sort)
-      assert_equal(%i[amount_cents debit_cents], ParentInheritanceOp::LateInheritanceOp.field_configurations.keys.sort)
-      assert_equal(%i[amount_cents credit_cents], OuterInheritanceOp.field_configurations.keys.sort)
-    end
-
-    def test_field_definitions_are_not_mutated_by_subclasses
-      assert_equal(%i[bar foo], MutationBase.field_configurations.keys.sort)
-      assert_equal(%i[bar foo food qux], MutationChild.field_configurations.keys.sort)
-    end
-
-    def test_group_fields_are_not_mutated_by_subclasses
-      assert_equal(%i[three_letter], MutationBase.fields_by_group.keys.sort)
-      assert_equal(%i[four_letter three_letter], MutationChild.fields_by_group.keys.sort)
-
-      assert_equal(%i[bar foo], MutationBase.fields_by_group[:three_letter].sort)
-      assert_equal(%i[bar foo qux], MutationChild.fields_by_group[:three_letter].sort)
-      assert_equal(%i[food], MutationChild.fields_by_group[:four_letter].sort)
-    end
-
-  end
-end

data/test/subroutine/outputs_test.rb

@@ -1,162 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-module Subroutine
-  class OutputsTest < TestCase
-    class MissingOutputOp < ::Subroutine::Op
-      def perform
-        output :foo, 'bar'
-      end
-    end
-
-    class LazyOutputOp < ::Subroutine::Op
-      outputs :foo, lazy: true
-      outputs :baz, lazy: true, type: String
-
-      def perform
-        output :foo, -> { call_me }
-        output :baz, -> { call_baz }
-      end
-
-      def call_me; end
-
-      def call_baz; end
-    end
-
-    class MissingOutputSetOp < ::Subroutine::Op
-      outputs :foo
-      def perform
-        true
-      end
-    end
-
-    class OutputNotRequiredOp < ::Subroutine::Op
-      outputs :foo, required: false
-      def perform
-        true
-      end
-    end
-
-    class NoOutputNoSuccessOp < ::Subroutine::Op
-      outputs :foo
-
-      def perform
-        errors.add(:foo, 'bar')
-      end
-    end
-
-    class OutputWithTypeValidationNotRequired < ::Subroutine::Op
-      outputs :value, type: String, required: false
-
-      def perform; end
-    end
-
-    class OutputWithTypeValidationRequired < ::Subroutine::Op
-      outputs :value, type: String, required: true
-
-      def perform; end
-    end
-
-    def test_it_raises_an_error_if_an_output_is_not_defined_but_is_set
-      op = MissingOutputOp.new
-      assert_raises ::Subroutine::Outputs::UnknownOutputError do
-        op.submit
-      end
-    end
-
-    def test_it_raises_an_error_if_not_all_outputs_were_set
-      op = MissingOutputSetOp.new
-      assert_raises ::Subroutine::Outputs::OutputNotSetError do
-        op.submit
-      end
-    end
-
-    def test_it_does_not_raise_an_error_if_output_is_not_set_and_is_not_required
-      op = OutputNotRequiredOp.new
-      op.submit
-    end
-
-    def test_it_does_not_raise_an_error_if_the_perform_is_not_a_success
-      op = NoOutputNoSuccessOp.new
-      refute op.submit
-    end
-
-    ###################
-    # type validation #
-    ###################
-
-    def test_it_does_not_raise_an_error_if_output_is_set_to_the_right_type
-      op = OutputWithTypeValidationNotRequired.new
-      op.send(:output, :value, 'foo')
-      assert op.submit
-    end
-
-    def test_it_raises_an_error_if_output_is_not_set_to_the_right_type
-      op = OutputWithTypeValidationNotRequired.new
-      op.send(:output, :value, 1)
-      assert_raises ::Subroutine::Outputs::InvalidOutputTypeError do
-        op.submit
-      end
-    end
-
-    def test_it_does_not_raise_an_error_if_output_is_set_to_nil_when_there_is_type_validation_and_not_required
-      op = OutputWithTypeValidationNotRequired.new
-      op.send(:output, :value, nil)
-      op.submit
-    end
-
-    def test_it_raises_an_error_if_output_is_set_to_nil_when_there_is_type_validation_and_is_required
-      op = OutputWithTypeValidationRequired.new
-      op.send(:output, :value, nil)
-      assert_raises ::Subroutine::Outputs::InvalidOutputTypeError do
-        op.submit
-      end
-    end
-
-    ################
-    # lazy outputs #
-    ################
-
-    def test_it_does_not_call_lazy_output_values_if_not_accessed
-      op = LazyOutputOp.new
-      op.expects(:call_me).never
-      op.submit!
-    end
-
-    def test_it_calls_lazy_output_values_if_accessed
-      op = LazyOutputOp.new
-      op.expects(:call_me).once
-      op.submit!
-      op.foo
-    end
-
-    def test_it_validates_type_when_lazy_output_is_accessed
-      op = LazyOutputOp.new
-      op.expects(:call_baz).once.returns("a string")
-      op.submit!
-      assert_silent do
-        op.baz
-      end
-    end
-
-    def test_it_raises_error_on_invalid_type_when_lazy_output_is_accessed
-      op = LazyOutputOp.new
-      op.expects(:call_baz).once.returns(10)
-      op.submit!
-      error = assert_raises(Subroutine::Outputs::InvalidOutputTypeError) do
-        op.baz
-      end
-      assert_match(/Invalid output type for 'baz' expected String but got Integer/, error.message)
-    end
-
-    def test_it_returns_outputs
-      op = LazyOutputOp.new
-      op.expects(:call_me).once.returns(1)
-      op.expects(:call_baz).once.returns("a string")
-      op.submit!
-      assert_equal({ foo: 1, baz: "a string" }, op.outputs)
-    end
-
-  end
-end