subroutine 0.10.0.beta → 0.10.0.beta2

data/test/subroutine/auth_test.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 module Subroutine
   class AuthTest < TestCase
 
     def user
-      @user ||= ::User.new(email_address: 'doug@example.com')
+      @user ||= ::User.new(id: 4, email_address: "doug@example.com")
     end
 
     def test_it_throws_an_error_if_authorization_is_not_defined
@@ -25,6 +25,12 @@ module Subroutine
       RequireUserOp.submit! user
     end
 
+    def test_it_allows_an_id_to_be_passed
+      ::User.expects(:find).with(user.id).returns(user)
+      op = RequireUserOp.submit! user.id
+      assert_equal op.current_user, user
+    end
+
     def test_it_throws_an_error_if_require_no_user_but_one_is_present
       assert_raises ::Subroutine::Auth::NotAuthorizedError do
         RequireNoUserOp.submit! user
@@ -47,7 +53,7 @@ module Subroutine
       CustomAuthorizeOp.submit! user
 
       assert_raises ::Subroutine::Auth::NotAuthorizedError do
-        CustomAuthorizeOp.submit! User.new(email_address: 'foo@bar.com')
+        CustomAuthorizeOp.submit! User.new(email_address: "foo@bar.com")
       end
     end
 
@@ -71,7 +77,7 @@ module Subroutine
     end
 
     def test_it_does_not_run_authorizations_if_explicitly_bypassed
-      op = CustomAuthorizeOp.new User.new(email_address: 'foo@bar.com')
+      op = CustomAuthorizeOp.new User.new(email_address: "foo@bar.com")
       op.skip_auth_checks!
       op.submit!
     end
@@ -106,5 +112,6 @@ module Subroutine
         op.submit!
       end
     end
+
   end
 end

data/test/subroutine/base_test.rb

@@ -1,24 +1,25 @@
 # frozen_string_literal: true
 
-require 'test_helper'
+require "test_helper"
 
 module Subroutine
   class OpTest < TestCase
+
     def test_simple_fields_definition
       op = ::SignupOp.new
-      assert_equal [:email, :password], op._fields.keys.sort
+      assert_equal %i[email password], op.field_configurations.keys.sort
     end
 
     def test_inherited_fields
       op = ::AdminSignupOp.new
-      assert_equal [:email, :password, :privileges], op._fields.keys.sort
+      assert_equal %i[email password privileges], op.field_configurations.keys.sort
     end
 
     def test_class_attribute_usage
       assert ::AdminSignupOp < ::SignupOp
 
-      sid = ::SignupOp._fields.object_id
-      bid = ::AdminSignupOp._fields.object_id
+      sid = ::SignupOp.field_configurations.object_id
+      bid = ::AdminSignupOp.field_configurations.object_id
 
       refute_equal sid, bid
     end
@@ -26,8 +27,8 @@ module Subroutine
     def test_inputs_from_inherited_fields_without_inheriting_from_the_class
       refute ::BusinessSignupOp < ::SignupOp
 
-      user_fields = ::SignupOp._fields.keys
-      biz_fields = ::BusinessSignupOp._fields.keys
+      user_fields = ::SignupOp.field_configurations.keys
+      biz_fields = ::BusinessSignupOp.field_configurations.keys
 
       user_fields.each do |field|
         assert_includes biz_fields, field
@@ -36,28 +37,28 @@ module Subroutine
 
     def test_inputs_from_ignores_except_fields
       op = ::ExceptFooBarOp.new
-      refute op._fields.key?(:foo)
-      refute op._fields.key?(:bar)
-      assert_equal [:baz], op._fields.keys.sort
+      refute op.field_configurations.key?(:foo)
+      refute op.field_configurations.key?(:bar)
+      assert_equal [:baz], op.field_configurations.keys.sort
     end
 
     def test_inputs_from_only_fields
       op = ::OnlyFooBarOp.new
-      assert op._fields.key?(:foo)
-      assert op._fields.key?(:bar)
-      refute_equal [:baz], op._fields.keys.sort
+      assert op.field_configurations.key?(:foo)
+      assert op.field_configurations.key?(:bar)
+      refute_equal [:baz], op.field_configurations.keys.sort
     end
 
     def test_defaults_declaration_options
       op = ::DefaultsOp.new
-      assert_equal 'foo', op.foo
-      assert_equal 'bar', op.bar
+      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
+      assert_equal "barstool", op.bar
     end
 
     def test_accessors_are_created
@@ -85,10 +86,10 @@ module Subroutine
 
       assert_nil op.email
       assert_nil op.password
-      assert_equal 'min', op.privileges
+      assert_equal "min", op.privileges
 
-      op.privileges = 'max'
-      assert_equal 'max', op.privileges
+      op.privileges = "max"
+      assert_equal "max", op.privileges
     end
 
     def test_validations_are_evaluated_before_perform_is_invoked
@@ -102,18 +103,18 @@ module Subroutine
     end
 
     def test_validation_errors_can_be_inherited_and_transformed
-      op = ::AdminSignupOp.new(email: 'foo@bar.com', password: 'password123')
+      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]
+      assert_equal ["has gotta be @admin.com"], op.errors[:email]
     end
 
     def test_when_valid_perform_completes_it_returns_control
-      op = ::SignupOp.new(email: 'foo@bar.com', password: 'password123')
+      op = ::SignupOp.new(email: "foo@bar.com", password: "password123")
       op.submit!
 
       assert op.perform_called
@@ -121,11 +122,11 @@ module Subroutine
 
       u = op.created_user
 
-      assert_equal 'foo@bar.com', u.email_address
+      assert_equal "foo@bar.com", u.email_address
     end
 
     def test_it_raises_an_error_when_used_with_a_bang_and_performing_or_validation_fails
-      op = ::SignupOp.new(email: 'foo@bar.com')
+      op = ::SignupOp.new(email: "foo@bar.com")
 
       err = assert_raises ::Subroutine::Failure do
         op.submit!
@@ -134,6 +135,16 @@ module Subroutine
       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!
@@ -147,82 +158,82 @@ module Subroutine
         SignupOp.submit!
       end
 
-      op = SignupOp.submit! email: 'foo@bar.com', password: 'password123'
-      assert_equal 'foo@bar.com', op.created_user.email_address
+      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')
+      op = ::AdminSignupOp.new(email: "foo")
       assert_equal({
-                     'email' => 'foo',
-                     'privileges' => 'min',
-                   }, op.params)
+        "email" => "foo",
+        "privileges" => "min",
+      }, op.params)
 
       assert_equal({
-                     'privileges' => 'min'
-                   }, op.defaults)
+        "privileges" => "min",
+      }, op.defaults)
     end
 
     def test_it_allows_defaults_to_be_overridden
-      op = ::AdminSignupOp.new(email: 'foo', privileges: nil)
+      op = ::AdminSignupOp.new(email: "foo", privileges: nil)
 
       assert_equal({
-                     'email' => 'foo',
-                     'privileges' => nil
-                   }, op.params)
+        "email" => "foo",
+        "privileges" => nil,
+      }, op.params)
 
-      assert_equal({"privileges" => "min"}, op.defaults)
+      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")
+      op.privileges << "bangbang"
 
-      op = ::AdminSignupOp.new(email: 'foo', privileges: nil)
+      op = ::AdminSignupOp.new(email: "foo", privileges: nil)
 
       assert_equal({
-                     'email' => 'foo',
-                     'privileges' => nil
-                   }, op.params)
+        "email" => "foo",
+        "privileges" => nil,
+      }, op.params)
 
       assert_equal({
-                     'privileges' => 'min'
-                   }, op.defaults)
+        "privileges" => "min",
+      }, op.defaults)
     end
 
     def test_it_overrides_defaults_with_nils
-      op = ::AdminSignupOp.new(email: 'foo', privileges: nil)
+      op = ::AdminSignupOp.new(email: "foo", privileges: nil)
       assert_equal({
-                     'privileges' => nil,
-                     'email' => 'foo'
-                   }, op.params)
+        "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 = ::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'])
+      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')
+      op = ::SignupOp.submit!(email: "foo@bar.com", password: "password123")
       u = op.created_user
 
-      assert_equal 'foo@bar.com', u.email_address
+      assert_equal "foo@bar.com", u.email_address
     end
 
     def test_it_raises_an_error_if_an_output_is_not_defined_but_is_set
       op = ::MissingOutputOp.new
-      assert_raises ::Subroutine::UnknownOutputError do
+      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::OutputNotSetError do
+      assert_raises ::Subroutine::Outputs::OutputNotSetError do
         op.submit
       end
     end
@@ -246,7 +257,7 @@ module Subroutine
           msg =~ %r{test/support/ops\.rb:[\d]+.+foo}
         end
 
-        refute_nil found, 'Expected backtrace to include original caller of foo'
+        refute_nil found, "Expected backtrace to include original caller of foo"
       end
     end
 
@@ -278,5 +289,6 @@ module Subroutine
         end
       end
     end
+
   end
 end

data/test/subroutine/fields_test.rb

@@ -11,11 +11,14 @@ module Subroutine
       include Subroutine::Fields
 
       string :foo, default: "foo"
-      integer :bar, default: -> { 3 }
-      date :baz
-
+      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
@@ -23,11 +26,13 @@ module Subroutine
     end
 
     def test_fields_are_configured
-      assert_equal 4, Whatever._fields.size
-      assert_equal :string, Whatever._fields[:foo][:type]
-      assert_equal :integer, Whatever._fields[:bar][:type]
-      assert_equal :date, Whatever._fields[:baz][:type]
-      assert_equal :string, Whatever._fields[:protekted][:type]
+      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
@@ -50,7 +55,7 @@ module Subroutine
       instance = DefaultsOp.new
       assert_equal false, instance.field_provided?(:foo)
 
-      instance = DefaultsOp.new(foo: 'foo')
+      instance = DefaultsOp.new(foo: "foo")
       assert_equal true, instance.field_provided?(:foo)
     end
 
@@ -70,12 +75,18 @@ module Subroutine
 
     def test_params_include_defaults
       instance = Whatever.new(foo: "abc")
-      assert_equal({ "foo" => "abc", "bar" => 3 }, instance.params)
-      assert_equal({ "foo" => "foo", "bar" => 3 }, instance.defaults)
+      assert_equal({ "foo" => "foo", "bar" => 3, "qux" => "qux" }, instance.defaults)
+      assert_equal({ "foo" => "abc", "qux" => "qux" }, instance.params)
+      assert_equal({ "foo" => "abc", "bar" => 3, "qux" => "qux" }, instance.all_params)
+    end
+
+    def test_named_params_include_defaults
+      instance = Whatever.new(foo: "abc")
+      assert_equal({ "bar" => 3 }, instance.sekret_params)
     end
 
     def test_fields_can_opt_out_of_mass_assignment
-      assert_raises "`protekted` is not mass assignable" do
+      assert_raises Subroutine::Fields::MassAssignmentError do
         Whatever.new(foo: "abc", protekted: "foo")
       end
     end
@@ -88,5 +99,31 @@ module Subroutine
       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_group_fields_are_accessible_at_the_class
+      results = Whatever.fields_in_group(:sekret)
+      assert_equal true, results.key?(:protekted_group_input)
+      assert_equal true, results.key?(:bar)
+      assert_equal false, results.key?(:protekted)
+    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({ foo: "bar", qux: "qux" }.with_indifferent_access, op.params)
+    end
+
   end
 end