subroutine 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f44648d17e8af9de061d865e831e95811de6ff4
-  data.tar.gz: b5347035ebf89c8e17a45b49333fb9b1a0812555
+  metadata.gz: a1eb7328166962d1dfee177ad4311926c7958217
+  data.tar.gz: f5133fc409be40473d1c14a0ae1880b1d007a35d
 SHA512:
-  metadata.gz: 9e8cb47942615ef6cee08df82ff32c026a1824aac18e3e07dacc74e71bb23c30f9959493491d3cb358ec6e4daccbe155c0562b4fa0794efd85b29a9ffa39a5cd
-  data.tar.gz: aedf7e3533db2a99570634e97a74cc82bb95673ed9f256153b7844a94638ce49436717c7912b7a552dbe13985c603078977270ff3f527128379b28cc03be5680
+  metadata.gz: a9bb3b82b53ef32a8f0d236c4e2561d7c56ce5c233f520a06bded564017e32e7d017758f43e0dff4d80c425b476e5ea95562d1f0414b7c26bd4e0d426efa8244
+  data.tar.gz: d4752345399d5ed62c138438ac80050c55de4ca84163d3c2121aed0bd7b404ffd36cc1caf6447d83a28bf570602f007bb5c55d59b70965e7dd6224831f350702

data/.gitignore

@@ -13,3 +13,4 @@
 *.a
 mkmf.log
 *.gem
+.byebug_history

data/README.md

@@ -343,93 +343,123 @@ op.submit!
 # if the op succeeds nothing will be raised, otherwise a ::Subroutine::Failure will be raised.
 ```
 
-## Extending Subroutine::Op
+## Built-in Extensions
 
-Great, so you're sold on using ops. Let's talk about how I usually standardize their usage in my apps. The most common thing needed is `current_user`. For this reason I usually follow the rails convention of declaring an "Application" op which declares all of my common needs. I hate writing `ApplicationOp` all the time so I usually call it `BaseOp`.
+### Subroutine::Association
+
+The `Subroutine::Association` module provides an interface for loading ActiveRecord instances easily.
 
 ```ruby
-class BaseOp < ::Subroutine::Op
+class UserUpdateOp < ::Subroutine::Op
+  include ::Subroutine::Association
 
-  attr_reader :current_user
+  association :user
 
-  def initialize(*args)
-    params = args.extract_options!
-    @current_user = args[0]
-    super(params)
-  end
+  string :first_name, :last_name
 
-end
-```
+  protected
 
-So now I can pass the current user as my first argument to any op constructor. The next most common case is permissions. In a common role-based system things become pretty easy. I usually just add a class method which declares the minimum required role.
+  def perform
+    user.update_attributes(
+      first_name: first_name,
+      last_name: last_name
+    )
 
-```ruby
-class SendInvitationOp < BaseOp
-  require_role :admin
+    true
+  end
 end
 ```
 
-In the case of a more complex permission system, I'll usually utilize pundit but still standardize the check as a validation.
-
 ```ruby
-class BaseOp < ::Subroutine::Op
+class RecordTouchOp < ::Subroutine::Op
+  include ::Subroutine::Association
 
-  validate :validate_permissions
+  association :record, polymorphic: true
 
   protected
 
-  # default implementation is to allow access.
-  def validate_permissions
-    true
-  end
+  def perform
+    record.touch
 
-  def not_authorized!
-    errors.add(:current_user, :not_authorized)
-    false
+    true
   end
 end
+```
+
+### Subroutine::Auth
+
+The `Subroutine::Auth` module provides basic bindings for application authorization. It assumes that, optionally, a `User` will be provided as the first argument to an Op. It forces authorization to be declared on each class it's included in.
+
+```ruby
+class SayHiOp < ::Subroutine::Op
+  include ::Subroutine::Auth
+
+  require_user!
 
-class SendInvitationOp < BaseOp
+  string :say_what, default: "hi"
 
   protected
 
-  def validate_permissions
-    unless UserPolicy.new(current_user).send_invitations?
-      return not_authorized!
-    end
+  def perform
+    puts "#{current_user.name} says: #{say_what}"
 
     true
   end
-
 end
 ```
 
-Clearly there are a ton of ways this could be implemented but that should be a good jumping-off point.
+```ruby
+user = User.find("john")
+SayHiOp.submit!(user)
+# => John says: hi
+
+SayHiOp.submit!(user, say_what: "hello")
+# => John says: hello
+
+
+SayHiOp.submit!
+# => raises Subroutine::Auth::NotAuthorizedError
+```
+
+There are a handful of authorization configurations:
+
+1. `require_user!` - ensures that a user is provided
+2. `require_no_user!` - ensures that a user is not present
+3. `no_user_requirements!` - explicitly doesn't matter
 
-Performance monitoring is also important to me so I've added a few hooks to observe what's going on during an op's submission. I'm primarily using Skylight at the moment.
+In addition to these top-level authorization declarations you can provide custom authorizations like so:
 
 ```ruby
-class BaseOp < ::Subroutine::Op
+class AccountSetSecretOp < ::Subroutine::Op
+  include ::Subroutine::Auth
+
+  require_user!
+  authorize :authorize_first_name_is_john
+
+  policy :can_set_secret?
+
+  string :secret
+  belongs_to :account
 
   protected
 
-  def observe_submission
-    Skylight.instrument category: 'op.submission', title: "#{self.class.name}#submit" do
-      yield
-    end
+  def perform
+    account.secret = secret
+    current_user.save!
+
+    true
   end
 
-  def observe_validation
-    Skylight.instrument category: 'op.validation', title: "#{self.class.name}#valid?" do
-      yield
+  def authorize_first_name_is_john
+    unless current_user.first_name == "john"
+      unauthorized!
     end
   end
 
-  def observe_perform
-    Skylight.instrument category: 'op.perform', title: "#{self.class.name}#perform" do
-      yield
-    end
+  def policy
+    ::UserPolicy.new(current_user, current_user)
   end
+
 end
 ```
 

data/lib/subroutine/association.rb

@@ -0,0 +1,132 @@
+module Subroutine
+  module Association
+
+    def self.included(base)
+      base.send :extend, ::Subroutine::Association::ClassMethods
+      class << base
+        alias_method :field_without_associations, :field
+        alias_method :field, :field_with_associations
+      end
+
+    end
+
+    module ClassMethods
+
+
+      def field_with_associations(*args)
+        opts = args.extract_options!
+        if opts[:association]
+          args.each do |arg|
+            association(arg, opts)
+          end
+        else
+          field_without_associations(*args, opts)
+        end
+      end
+
+      # association :user
+      #  - user_id
+      #  - user_type => "User"
+
+      # association :user, polymorphic: true
+      #  - user_id
+      #  - user_type
+      #  - user => polymorphic_lookup(user_type, user_id)
+
+      # association :inbound_user_request, as: :request
+      #  - inbound_user_request_id
+      #  - inbound_user_request_type => "InboundUserRequest"
+      #  - request => polymorphic_lookup(inbound_user_request_type, inbound_user_request_id)
+
+      # association :inbound_user_request, foreign_key: :request_id
+      #  - request_id
+      #  - request_type
+      #  - inbound_user_request => polymorphic_lookup(request_type, request_id)
+
+      # Other options:
+      # - unscoped => set true if the record should be looked up via Type.unscoped
+
+      def association(field, options = {})
+
+        if options[:as] && options[:foreign_key]
+          raise ArgumentError.new(":as and :foreign_key options should be provided together to an association invocation")
+        end
+
+        class_name = options[:class_name]
+
+        poly = options[:polymorphic] || !class_name.nil?
+        as = options[:as] || field
+        unscoped = !!options[:unscoped]
+
+        klass = class_name.to_s if class_name
+
+        foreign_key_method = (options[:foreign_key] || "#{field}_id").to_s
+        foreign_type_method = foreign_key_method.gsub(/_id$/, "_type")
+
+
+        if poly
+          string foreign_type_method
+        else
+          class_eval <<-EV, __FILE__, __LINE__+1
+            def #{foreign_type_method}
+              #{as.to_s.camelize.inspect}
+            end
+          EV
+        end
+
+        integer foreign_key_method
+
+        field_without_associations as, options.merge(association: true)
+
+        class_eval <<-EV, __FILE__, __LINE__+1
+          def #{as}_with_association
+            return @#{as} if defined?(@#{as})
+            @#{as} = begin
+              #{as}_without_association ||
+              polymorphic_instance(#{klass.nil? ? foreign_type_method : klass.to_s}, #{foreign_key_method}, #{unscoped.inspect})
+            end
+          end
+
+          def #{as}_with_association=(r)
+            @#{as} = r
+            #{poly || klass ? "params['#{foreign_type_method}'] = r.nil? ? nil : #{klass.nil? ? "r.class.name" : klass.to_s.inspect}" : ""}
+            params['#{foreign_key_method}'] = r.nil? ? nil : r.id
+            r
+          end
+        EV
+
+        alias_method :"#{as}_without_association", :"#{as}"
+        alias_method :"#{as}", :"#{as}_with_association"
+
+        alias_method :"#{as}_without_association=", :"#{as}="
+        alias_method :"#{as}=", :"#{as}_with_association="
+
+      end
+    end
+
+    def initialize(*args)
+      super(*args)
+
+      self._fields.each_pair do |field, config|
+        next unless config[:association]
+        next unless @original_params.has_key?(field)
+        send("#{field}=", @original_params[field]) # this gets the _id and _type into the params hash
+      end
+    end
+
+    def polymorphic_instance(_type, _id, _unscoped = false)
+      return nil unless _type && _id
+
+      klass = _type
+      klass = klass.camelize.constantize if klass.is_a?(String)
+
+      return nil unless klass
+
+      scope = klass.all
+      scope = scope.unscoped if _unscoped
+
+      scope.find(_id)
+    end
+
+  end
+end

data/lib/subroutine/auth.rb

@@ -0,0 +1,97 @@
+module Subroutine
+  module Auth
+
+    class NotAuthorizedError < ::StandardError
+
+      def initialize(msg = nil)
+        msg = I18n.t("errors.#{msg}", default: "Sorry, you are not authorized to perform this action.") if msg.is_a?(Symbol)
+        msg ||= I18n.t('errors.unauthorized', default: "Sorry, you are not authorized to perform this action.")
+        super msg
+      end
+
+      def status
+        401
+      end
+
+    end
+
+    def self.included(base)
+      base.instance_eval do
+        extend ::Subroutine::Auth::ClassMethods
+
+        class_attribute :authorization_declared
+        self.authorization_declared = false
+      end
+    end
+
+
+    module ClassMethods
+
+      def authorize(validation_name)
+        validate validation_name, unless: :skip_auth_checks?
+      end
+
+      def no_user_requirements!
+        self.authorization_declared = true
+      end
+
+      def require_user!
+        self.authorization_declared = true
+
+        validate unless: :skip_auth_checks? do
+          unauthorized! unless current_user.present?
+        end
+      end
+
+      def require_no_user!
+        self.authorization_declared = true
+
+        validate unless: :skip_auth_checks? do
+          unauthorized! :empty_unauthorized if current_user.present?
+        end
+      end
+
+      # policy :can_update_user
+      # policy :can_do_whatever, policy: :foo_policy
+      def policy(*meths)
+        opts = meths.extract_options!
+        policy_name = opts[:policy] || :policy
+        validate unless: :skip_auth_checks? do
+          p = self.send(policy_name)
+          if !p || meths.any?{|m| !(p.respond_to?("#{m}?") ? p.send("#{m}?") : p.send(m)) }
+            unauthorized! opts[:error]
+          end
+        end
+      end
+
+    end
+
+    def initialize(*args)
+      raise "Authorization management has not been declared on this class" if(!self.class.authorization_declared)
+
+      super(args.extract_options!)
+      @skip_auth_checks = false
+      @current_user = args.shift
+    end
+
+    def skip_auth_checks!
+      @skip_auth_checks = true
+      self
+    end
+
+    def skip_auth_checks?
+      !!@skip_auth_checks
+    end
+
+    def current_user
+      @current_user = ::User.find(@current_user) if Fixnum === @current_user
+      @current_user
+    end
+
+    def unauthorized!(reason = nil)
+      reason ||= :unauthorized
+      raise ::Subroutine::Auth::NotAuthorizedError.new(reason)
+    end
+
+  end
+end

data/lib/subroutine/version.rb

@@ -1,8 +1,8 @@
 module Subroutine
 
   MAJOR = 0
-  MINOR = 2
-  PATCH = 1
+  MINOR = 3
+  PATCH = 0
   PRE   = nil
 
   VERSION = [MAJOR, MINOR, PATCH, PRE].compact.join('.')

data/subroutine.gemspec

@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "mocha"
 end

data/test/subroutine/association_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+module Subroutine
+  class AuthTest < TestCase
+
+    def doug
+      @doug ||= ::User.new(id: 1, email_address: "doug@example.com")
+    end
+
+    def fred
+      @fred ||= ::User.new(id: 2, email_address: "fred@example.com")
+    end
+
+    def test_it_sets_accessors_on_init
+      op = SimpleAssociationOp.new user: doug
+      assert_equal "User", op.user_type
+      assert_equal doug.id, op.user_id
+    end
+
+    def test_it_looks_up_an_association
+      all_mock = mock
+
+      ::User.expects(:all).returns(all_mock)
+      all_mock.expects(:find).with(1).returns(doug)
+
+      op = SimpleAssociationOp.new user_type: "User", user_id: doug.id
+      assert_equal doug, op.user
+    end
+
+    def test_it_allows_an_association_to_be_looked_up_without_default_scoping
+      all_mock = mock
+      unscoped_mock = mock
+
+      ::User.expects(:all).returns(all_mock)
+      all_mock.expects(:unscoped).returns(unscoped_mock)
+      unscoped_mock.expects(:find).with(1).returns(doug)
+
+      op = UnscopedSimpleAssociationOp.new user_type: "User", user_id: doug.id
+      assert_equal doug, op.user
+    end
+
+    def test_it_allows_polymorphic_associations
+      all_mock = mock
+      ::User.expects(:all).never
+      ::AdminUser.expects(:all).returns(all_mock)
+      all_mock.expects(:find).with(1).returns(doug)
+
+      op = PolymorphicAssociationOp.new(admin_type: "AdminUser", admin_id: doug.id)
+      assert_equal doug, op.admin
+    end
+
+    def test_it_allows_the_class_to_be_set
+      op = ::AssociationWithClassOp.new(admin: doug)
+      assert_equal "AdminUser", op.admin_type
+    end
+
+  end
+end

data/test/subroutine/auth_test.rb

@@ -0,0 +1,69 @@
+require 'test_helper'
+
+module Subroutine
+  class AuthTest < TestCase
+
+    def user
+      @user ||= ::User.new(email_address: "doug@example.com")
+    end
+
+    def test_it_throws_an_error_if_authorization_is_not_defined
+      assert_raises "Authorization management has not been declared on this class" do
+        MissingAuthOp.new
+      end
+    end
+
+    def test_it_throws_an_error_if_require_user_but_none_is_provided
+      assert_raises ::Subroutine::Auth::NotAuthorizedError do
+        RequireUserOp.submit!
+      end
+    end
+
+    def test_it_does_not_throw_an_error_if_require_user_but_none_is_provided
+      RequireUserOp.submit! 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
+      end
+    end
+
+    def test_it_does_not_throw_an_error_if_require_no_user_and_none_is_provided
+      RequireNoUserOp.submit!
+    end
+
+    def test_it_does_not_throw_an_error_if_no_user_requirements_and_one_is_provided
+      NoUserRequirementsOp.submit! user
+    end
+
+    def test_it_does_not_throw_an_error_if_no_user_requirements_and_none_is_provided
+      NoUserRequirementsOp.submit!
+    end
+
+    def test_it_runs_custom_authorizations
+      CustomAuthorizeOp.submit! user
+
+      assert_raises ::Subroutine::Auth::NotAuthorizedError do
+        CustomAuthorizeOp.submit! User.new(email_address: "foo@bar.com")
+      end
+    end
+
+    def test_it_does_not_run_authorizations_if_explicitly_bypassed
+      op = CustomAuthorizeOp.new User.new(email_address: "foo@bar.com")
+      op.skip_auth_checks!
+      op.submit!
+    end
+
+    def test_it_runs_policies_as_part_of_authorization
+      assert_raises ::Subroutine::Auth::NotAuthorizedError do
+        PolicyOp.submit! user
+      end
+
+      op = PolicyOp.new
+      op.skip_auth_checks!
+      op.submit!
+    end
+
+  end
+end

data/test/subroutine/type_caster_test.rb

@@ -220,5 +220,19 @@ module Subroutine
       assert_equal "2022-12-22T10:30:24Z", op.iso_time_input
     end
 
+    def test_field_provided
+      op = ::SignupOp.new()
+      assert_equal false, op.send(:field_provided?, :email)
+
+      op = ::SignupOp.new(email: "foo")
+      assert_equal true, op.send(:field_provided?, :email)
+
+      op = ::DefaultsOp.new()
+      assert_equal false, op.send(:field_provided?, :foo)
+
+      op = ::DefaultsOp.new(foo: "foo")
+      assert_equal true, op.send(:field_provided?, :foo)
+    end
+
   end
 end

data/test/support/ops.rb

@@ -1,8 +1,12 @@
+require "subroutine/auth"
+require "subroutine/association"
+
 ## Models ##
 
 class User
   include ::ActiveModel::Model
 
+  attr_accessor :id
   attr_accessor :email_address
   attr_accessor :password
 
@@ -109,3 +113,78 @@ class TypeCastOp < ::Subroutine::Op
   array :array_input, :default => 'foo'
 
 end
+
+class OpWithAuth < ::Subroutine::Op
+  include ::Subroutine::Auth
+  def perform
+    true
+  end
+end
+
+class MissingAuthOp < OpWithAuth
+end
+
+class RequireUserOp < OpWithAuth
+  require_user!
+end
+
+class RequireNoUserOp < OpWithAuth
+  require_no_user!
+end
+
+class NoUserRequirementsOp < OpWithAuth
+  no_user_requirements!
+end
+
+class CustomAuthorizeOp < OpWithAuth
+
+  require_user!
+  authorize :authorize_user_is_correct
+
+  protected
+
+  def authorize_user_is_correct
+    unless current_user.email_address.to_s =~ /example\.com$/
+      unauthorized!
+    end
+  end
+end
+
+class PolicyOp < OpWithAuth
+
+  class FakePolicy
+    def user_can_access?
+      false
+    end
+  end
+
+  require_user!
+  policy :user_can_access?
+
+  def policy
+    @policy ||= FakePolicy.new
+  end
+end
+
+
+class OpWithAssociation < ::Subroutine::Op
+  include ::Subroutine::Association
+end
+
+class SimpleAssociationOp < ::OpWithAssociation
+
+  association :user
+
+end
+
+class UnscopedSimpleAssociationOp < ::OpWithAssociation
+  association :user, unscoped: true
+end
+
+class PolymorphicAssociationOp < ::OpWithAssociation
+  association :admin, polymorphic: true
+end
+
+class AssociationWithClassOp < ::OpWithAssociation
+  association :admin, class_name: "AdminUser"
+end

data/test/test_helper.rb

@@ -3,11 +3,10 @@ require 'minitest/autorun'
 require 'minitest/unit'
 
 require 'minitest/reporters'
+require 'mocha/mini_test'
 
 Minitest::Reporters.use!([Minitest::Reporters::DefaultReporter.new])
 
 class TestCase < (MiniTest::Unit::TestCase rescue ::MiniTest::Test); end
 
 require_relative 'support/ops'
-
-

metadata

@@ -1,83 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: subroutine
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-22 00:00:00.000000000 Z
+date: 2017-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: An interface for creating feature-driven operations.
@@ -87,8 +101,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -100,12 +114,16 @@ files:
 - gemfiles/am41.gemfile
 - gemfiles/am42.gemfile
 - lib/subroutine.rb
+- lib/subroutine/association.rb
+- lib/subroutine/auth.rb
 - lib/subroutine/failure.rb
 - lib/subroutine/filtered_errors.rb
 - lib/subroutine/op.rb
 - lib/subroutine/type_caster.rb
 - lib/subroutine/version.rb
 - subroutine.gemspec
+- test/subroutine/association_test.rb
+- test/subroutine/auth_test.rb
 - test/subroutine/base_test.rb
 - test/subroutine/type_caster_test.rb
 - test/support/ops.rb
@@ -120,17 +138,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Feature-driven operation objects.
@@ -141,6 +159,8 @@ test_files:
 - gemfiles/am40.gemfile
 - gemfiles/am41.gemfile
 - gemfiles/am42.gemfile
+- test/subroutine/association_test.rb
+- test/subroutine/auth_test.rb
 - test/subroutine/base_test.rb
 - test/subroutine/type_caster_test.rb
 - test/support/ops.rb