devise_invitable 3.0.4 → 3.1.0

data/lib/devise_invitable/models.rb

@@ -1,4 +1,5 @@
 require 'active_support/deprecation'
+require 'active_support/security_utils'
 require 'devise_invitable/models/authenticatable'
 
 module Devise
@@ -30,7 +31,7 @@ module Devise
       attr_accessor :completing_invite
       attr_accessor :registering_directly
       attr_accessor :invited_by_for_next_invitation
-      attr_reader   :raw_invitation_token
+      attr_reader   :acceptance_token
 
       included do
         include ::DeviseInvitable::Inviter
@@ -145,6 +146,13 @@ module Devise
         current_invitation&.invitation_token = value
       end
 
+      # The public raw token is an encrypted acceptance envelope for new
+      # invitations. Before persistence it falls back to the underlying Devise
+      # token so invitation callbacks retain their historical behavior.
+      def raw_invitation_token
+        acceptance_token || @raw_invitation_token
+      end
+
       def invitation_created_at
         current_invitation&.invitation_created_at
       end
@@ -201,38 +209,42 @@ module Devise
         current_invitation.invitation_token = nil
       end
 
-      # Save the resource, accept the selected invitation, and supersede the
-      # other outstanding invitations for the same resource.
+      # Save the resource, accept the selected invitation, and resolve the
+      # other outstanding invitations for the same invite keys.
       def accept_invitation!
         if current_invitation&.pending?
+          @accepted_invitation_for_provisioned_resource = resource_previously_provisioned?
+          provisioning_acceptance = !accepted_invitation_for_provisioned_resource?
+          previous_confirmed_at = confirmed_at if respond_to?(:confirmed_at)
           @accepting_invitation = true
+          skip_reconfirmation! if respond_to?(:skip_reconfirmation!)
           run_callbacks :invitation_accepted do
             accepted_at = Time.now.utc
             self.confirmed_at ||= accepted_at if respond_to?(:confirmed_at=)
 
             if save
               current_invitation.invitable = self
-              current_invitation.resource_created_at ||= accepted_at
+              current_invitation.resource_created_at ||= accepted_at if provisioning_acceptance
               current_invitation.invitation_accepted_at = accepted_at
               current_invitation.invitation_token = nil
               current_invitation.save!
-              supersede_other_invitations!(accepted_at)
+              resolve_other_invitations_after_acceptance!(accepted_at)
               reset_devise_invitation_associations
               true
             else
               false
             end
           end.tap do |saved|
-            rollback_accepted_invitation unless saved
+            rollback_accepted_invitation(previous_confirmed_at) unless saved
             @accepting_invitation = false
           end
         end
       end
 
-      def rollback_accepted_invitation
+      def rollback_accepted_invitation(previous_confirmed_at = nil)
         invitation = current_invitation
         invitation.reload if invitation&.persisted?
-        self.confirmed_at = nil if self.respond_to?(:confirmed_at=)
+        self.confirmed_at = previous_confirmed_at if respond_to?(:confirmed_at=)
       end
 
       # Verify wheather a user is created by invitation, irrespective to invitation status
@@ -240,6 +252,14 @@ module Devise
         devise_invitations.provisioning.exists?
       end
 
+      def resource_previously_provisioned?
+        persisted? && !invitation_pending?
+      end
+
+      def accepted_invitation_for_provisioned_resource?
+        !!@accepted_invitation_for_provisioned_resource
+      end
+
       # True only while this record is a placeholder created by an unresolved
       # invitation. An active resource may have other pending invitations.
       def invitation_pending?
@@ -274,6 +294,8 @@ module Devise
 
       # Reset invitation token and send invitation again
       def invite!(invited_by = nil, options = {})
+        options = options.dup
+        invitation_data = options.delete(:invitation_data)
         resource_was_new = new_record?
         # Required to workaround confirmable model's confirmation_required? method
         # being implemented to check for non-nil value of confirmed_at
@@ -286,6 +308,7 @@ module Devise
         self.downcase_keys if new_record_and_responds_to?(:downcase_keys)
         self.strip_whitespace if new_record_and_responds_to?(:strip_whitespace)
         invitation = build_devise_invitation(invited_by)
+        invitation.invitation_data = invitation_data
         if instance_variable_defined?(:@invited_by_for_next_invitation)
           remove_instance_variable(:@invited_by_for_next_invitation)
         end
@@ -293,6 +316,8 @@ module Devise
         generate_invitation_token
 
         run_callbacks :invitation_created do
+          invitation.invitation_data = DeviseInvitable::AcceptanceToken
+            .normalize_invitation_data(invitation.invitation_data)
           now = Time.now.utc
           invitation.invitation_created_at = now
 
@@ -305,8 +330,15 @@ module Devise
             end
             invitation.save!
             reset_devise_invitation_associations
+            generate_acceptance_token
             invitation.invited_by.decrement_invitation_limit! if invitation.invited_by.present?
-            deliver_invitation(options) unless skip_invitation
+            unless skip_invitation
+              if self.class.deliver_invitation_later
+                enqueue_invitation_delivery(options)
+              else
+                deliver_invitation(options)
+              end
+            end
           end
         end
       end
@@ -338,7 +370,8 @@ module Devise
 
       # Enforce password when invitation is being accepted
       def password_required?
-        (accepting_invitation? && self.class.require_password_on_accepting) || super
+        (accepting_invitation? && !resource_previously_provisioned? &&
+          self.class.require_password_on_accepting) || super
       end
 
       def unauthenticated_message
@@ -359,16 +392,12 @@ module Devise
 
       # Deliver the invitation email
       def deliver_invitation(options = {})
-        generate_invitation_token! unless @raw_invitation_token
-        marked_as_sent = false
-        unless current_invitation.invitation_sent_at
-          current_invitation.update_attribute :invitation_sent_at, Time.now.utc
-          marked_as_sent = true
-        end
-        send_devise_notification(:invitation_instructions, @raw_invitation_token, options)
-      rescue
-        current_invitation.update_attribute(:invitation_sent_at, nil) if marked_as_sent
-        raise
+        DeviseInvitable::InvitationDelivery.call(
+          current_invitation,
+          resource: self,
+          acceptance_token: acceptance_token,
+          options: options
+        )
       end
 
       # provide alias to the encrypted invitation_token stored by devise
@@ -414,6 +443,15 @@ module Devise
           association._loaded?
         end
 
+        def enqueue_invitation_delivery(options)
+          DeviseInvitable::InvitationDelivery.enqueue(
+            current_invitation,
+            resource: self,
+            acceptance_token: acceptance_token,
+            options: options
+          )
+        end
+
         def assign_invitation_attribute(attribute, value)
           return unless current_invitation
 
@@ -470,19 +508,49 @@ module Devise
           generate_invitation_token && current_invitation.save!
         end
 
+        def generate_acceptance_token
+          @acceptance_token = DeviseInvitable::AcceptanceToken.generate(
+            invitation: current_invitation,
+            raw_token: @raw_invitation_token,
+            invite_key: current_invitation.invite_key_for_acceptance.presence ||
+              self.class.normalized_invite_keys(attributes),
+            invitation_data: current_invitation.invitation_data
+          )
+        end
+
+        def prepare_invitation_delivery
+          generate_invitation_token! unless @raw_invitation_token
+          generate_acceptance_token unless acceptance_token
+          acceptance_token
+        end
+
+        def send_invitation_notification_now(token, options)
+          devise_mailer
+            .send(:invitation_instructions, self, token, options)
+            .deliver_now
+        end
+
         def new_record_and_responds_to?(method)
           self.new_record? && self.respond_to?(method, true)
         end
 
         def build_devise_invitation(invited_by)
-          invite_key_values = self.class.invite_key_fields.each_with_object({}) do |key, values|
-            values[key] = public_send(key)
-          end
-          DeviseInvitable::Invitation.new(
+          invite_key_values = self.class.normalized_invite_keys(attributes)
+          invitation = DeviseInvitable::Invitation.new(
             invitable_type: self.class.devise_invitable_base_class.name,
-            invite_key: invite_key_values,
+            invite_key: {},
             invited_by: invited_by || invited_by_for_next_invitation
           )
+          invitation.transient_invite_key = invite_key_values
+          invitation
+        end
+
+        def resolve_other_invitations_after_acceptance!(time)
+          if self.class.supersede_other_invitations_on_accept
+            supersede_other_invitations!(time)
+          else
+            preserve_other_invitations!
+          end
         end
 
         def supersede_other_invitations!(time)
@@ -499,6 +567,16 @@ module Devise
           end
         end
 
+        def preserve_other_invitations!
+          self.class.pending_invitations_for(attributes).each do |invitation|
+            next if invitation.id == current_invitation.id
+
+            invitation.invitable = self
+            invitation.resource_created_at = nil if current_invitation.provisioning?
+            invitation.save!
+          end
+        end
+
         def resolve_invitations_after_registration!
           self.class.pending_invitations_for(attributes).each do |invitation|
             invitation.update!(
@@ -608,6 +686,10 @@ module Devise
           original_token = attributes.delete(:invitation_token)
           invitable = find_by_invitation_token(original_token, false)
           if invitable.errors.empty?
+            if invitable.resource_previously_provisioned?
+              attributes.delete(:password)
+              attributes.delete(:password_confirmation)
+            end
             invitable.assign_attributes(attributes)
             invitable.accept_invitation!
           end
@@ -622,12 +704,9 @@ module Devise
             return
           end
 
-          invitation_token = Devise.token_generator.digest(self, :invitation_token, original_token)
-          invitation = DeviseInvitable::Invitation.where(
-            invitable_type: devise_invitable_base_class.name,
-            invitation_token: invitation_token
-          ).first
-          invitable = invitation&.invitable || new(invitation ? invitation.invite_key : {})
+          invitation, invite_key = invitation_and_key_from_token(original_token)
+          invitable = invitation&.invitable || new(invite_key || {})
+          invitable.assign_attributes(invite_key) if invitation && invite_key.present?
           invitable.instance_variable_set(:@current_invitation, invitation)
           if invitation.nil?
             invitable.errors.add(:invitation_token, :invalid)
@@ -640,9 +719,14 @@ module Devise
         def pending_invitations_for(attributes)
           keys = normalized_invite_keys(attributes)
           digest = DeviseInvitable::Invitation.digest_for(devise_invitable_base_class.name, keys)
-          DeviseInvitable::Invitation.pending.where(
-            invitable_type: devise_invitable_base_class.name,
-            invite_key_digest: digest
+          DeviseInvitable::Invitation.to_adapter.find_all(
+            conditions: {
+              invitation_accepted_at: nil,
+              superseded_at: nil,
+              revoked_at: nil,
+              invitable_type: devise_invitable_base_class.name,
+              invite_key_digest: digest
+            }
           ).to_a
         end
 
@@ -683,6 +767,9 @@ module Devise
         Devise::Models.config(self, :allow_insecure_sign_in_after_accept)
         Devise::Models.config(self, :require_password_on_accepting)
         Devise::Models.config(self, :create_resource_on_invitation)
+        Devise::Models.config(self, :store_invite_keys_until_delivery)
+        Devise::Models.config(self, :deliver_invitation_later)
+        Devise::Models.config(self, :supersede_other_invitations_on_accept)
 
         def invited_by_class_name=(value)
           DeviseInvitable.warn_deprecated_invited_by_setting(:invited_by_class_name)
@@ -696,6 +783,44 @@ module Devise
 
         private
 
+          def invitation_and_key_from_token(original_token)
+            payload = DeviseInvitable::AcceptanceToken.decode(original_token)
+            return legacy_invitation_and_key(original_token) unless payload
+            return [nil, nil] unless payload[:invitable_type] == devise_invitable_base_class.name
+
+            invitation_token = Devise.token_generator.digest(
+              self,
+              :invitation_token,
+              payload[:raw_token]
+            )
+            invitation = DeviseInvitable::Invitation.to_adapter.find_first(
+              id: payload[:invitation_id],
+              invitable_type: devise_invitable_base_class.name,
+              invitation_token: invitation_token
+            )
+            invitation.invitation_data = payload[:invitation_data] || {} if invitation
+            invite_key = normalized_invite_keys(payload[:invite_key] || {})
+            expected_digest = DeviseInvitable::Invitation.digest_for(
+              devise_invitable_base_class.name,
+              invite_key
+            )
+            invitation = nil unless invitation &&
+              ActiveSupport::SecurityUtils.secure_compare(
+                invitation.invite_key_digest,
+                expected_digest
+              )
+            [invitation, invite_key]
+          end
+
+          def legacy_invitation_and_key(original_token)
+            invitation_token = Devise.token_generator.digest(self, :invitation_token, original_token)
+            invitation = DeviseInvitable::Invitation.to_adapter.find_first(
+              invitable_type: devise_invitable_base_class.name,
+              invitation_token: invitation_token
+            )
+            [invitation, invitation&.invite_key]
+          end
+
           def ensure_unique_invite_key_match!(required_attributes, attributes)
             filtered_attributes = attributes.to_h.with_indifferent_access
               .slice(*required_attributes)
@@ -703,7 +828,7 @@ module Devise
             return unless filtered_attributes.size == required_attributes.size
 
             filtered_attributes = devise_parameter_filter.filter(filtered_attributes)
-            matches = where(filtered_attributes).limit(2).to_a
+            matches = to_adapter.find_all(conditions: filtered_attributes, limit: 2).to_a
             return unless matches.many?
 
             raise DeviseInvitable::AmbiguousInviteKeyError,

data/lib/devise_invitable/version.rb

@@ -1,3 +1,3 @@
 module DeviseInvitable
-  VERSION = '3.0.4'.freeze
+  VERSION = '3.1.0'.freeze
 end

data/lib/devise_invitable.rb

@@ -1,9 +1,14 @@
 module DeviseInvitable
   class AmbiguousInviteKeyError < StandardError; end
+  class InvitationDataTooLargeError < ArgumentError; end
+  class MissingInviteKeyError < StandardError; end
   class ResourceAttributesRequirePlaceholderError < ArgumentError; end
 
+  autoload :AcceptanceToken, 'devise_invitable/acceptance_token'
   autoload :Inviter, 'devise_invitable/inviter'
   autoload :Invitation, 'devise_invitable/invitation'
+  autoload :InvitationDelivery, 'devise_invitable/invitation_delivery'
+  autoload :InvitationDeliveryJob, 'devise_invitable/invitation_delivery_job'
   autoload :Mailer, 'devise_invitable/mailer'
   autoload :Migrator, 'devise_invitable/migrator'
   autoload :Mapping, 'devise_invitable/mapping'
@@ -12,6 +17,15 @@ module DeviseInvitable
     autoload :Registrations, 'devise_invitable/controllers/registrations'
     autoload :Helpers, 'devise_invitable/controllers/helpers'
   end
+
+  def self.invitation_delivery_job
+    job = Devise.invitation_delivery_job
+    job = job.constantize if job.respond_to?(:constantize)
+    return job if job.respond_to?(:perform_later)
+
+    raise ArgumentError,
+      'Devise.invitation_delivery_job must respond to perform_later'
+  end
 end
 
 require 'devise'
@@ -101,10 +115,36 @@ module Devise
   @@require_password_on_accepting = true
 
   # Public: Create the invited resource as soon as an invitation is sent.
-  # When false, only the invitation and its invite keys are persisted and the
-  # resource is created when the invitation is accepted.
+  # When false, only the invitation record is persisted and the resource is
+  # created when the invitation is accepted.
   mattr_accessor :create_resource_on_invitation
   @@create_resource_on_invitation = false
+
+  # Public: Store invite keys until an invitation is delivered so a skipped,
+  # resource-less invitation can be delivered later. Stored keys are cleared
+  # after successful delivery.
+  mattr_accessor :store_invite_keys_until_delivery
+  @@store_invite_keys_until_delivery = false
+
+  # Public: Deliver invitation emails through the configured invitation job.
+  # Other Devise notifications continue to use send_devise_notification.
+  mattr_accessor :deliver_invitation_later
+  @@deliver_invitation_later = false
+
+  # Public: Active Job class used by Invitation#deliver_later. It may be a
+  # class or a class name and must respond to perform_later.
+  mattr_accessor :invitation_delivery_job
+  @@invitation_delivery_job = 'DeviseInvitable::InvitationDeliveryJob'
+
+  # Public: Queue used by the default invitation delivery job.
+  mattr_accessor :invitation_delivery_queue_name
+  @@invitation_delivery_queue_name = :mailers
+
+  # Public: Supersede other pending invitations for the same invite keys when
+  # one invitation is accepted. Disable this only when each invitation carries
+  # an independently acceptable application-specific context.
+  mattr_accessor :supersede_other_invitations_on_accept
+  @@supersede_other_invitations_on_accept = true
 end
 
 module DeviseInvitable

data/lib/generators/devise_invitable/install_generator.rb

@@ -51,6 +51,27 @@ module DeviseInvitable
   # Default: false
   # config.create_resource_on_invitation = true
 
+  # Store invite keys until delivery so skipped invitations without placeholder
+  # resources can be delivered later. Keys are cleared after successful delivery.
+  # Default: false
+  # config.store_invite_keys_until_delivery = true
+
+  # Deliver invitation emails with the configured invitation delivery job.
+  # Other Devise notifications still use send_devise_notification.
+  # Default: false
+  # config.deliver_invitation_later = true
+
+  # Active Job class and queue used by invitation.deliver_later. Configure a
+  # custom job class when invitations should inherit from ApplicationJob or use
+  # application-specific retry and callback behavior.
+  # config.invitation_delivery_job = "MyInvitationDeliveryJob"
+  # config.invitation_delivery_queue_name = :mailers
+
+  # Supersede other pending invitations for the same invite keys when one is
+  # accepted. Disable this only for independently acceptable invitation data.
+  # Default: true
+  # config.supersede_other_invitations_on_accept = false
+
   # The column name used for counter_cache column. If this is nil,
   # the #invited_by association is declared without counter_cache.
   # Default: nil

data/test/integration/invitation_test.rb

@@ -147,6 +147,32 @@ class InvitationTest < ActionDispatch::IntegrationTest
     Devise.allow_insecure_sign_in_after_accept = original_option_value
   end
 
+  test 'does not sign in an already provisioned user when accepting another invitation' do
+    original_create_resource = User.create_resource_on_invitation
+    original_supersede = User.supersede_other_invitations_on_accept
+    User.create_resource_on_invitation = false
+    User.supersede_other_invitations_on_accept = false
+
+    first_invited = User.invite!(email: 'valid@email.com')
+    first_token = first_invited.raw_invitation_token
+    second_invited = User.invite!(email: 'valid@email.com')
+    second_token = second_invited.raw_invitation_token
+    user = User.accept_invitation!(
+      invitation_token: first_token,
+      password: '123456789',
+      password_confirmation: '123456789'
+    )
+
+    set_password invitation_token: second_token
+
+    assert_equal new_user_session_path, current_path
+    assert user.reload.valid_password?('123456789')
+    refute user.valid_password?('987654321')
+  ensure
+    User.create_resource_on_invitation = original_create_resource
+    User.supersede_other_invitations_on_accept = original_supersede
+  end
+
   test 'clear token and set invitation_accepted_at after recover password instead of accept_invitation' do
     user = User.invite!(email: 'valid@email.com')
 

data/test/jobs/invitation_delivery_job_test.rb

@@ -0,0 +1,138 @@
+require 'test_helper'
+require 'model_tests_helper'
+
+class InvitationDeliveryJobTest < ActiveSupport::TestCase
+  setup do
+    @invitation_delivery_job = Devise.invitation_delivery_job
+    @invitation_delivery_queue_name = Devise.invitation_delivery_queue_name
+    @create_resource_on_invitation = User.create_resource_on_invitation
+    @store_invite_keys_until_delivery = User.store_invite_keys_until_delivery
+    @deliver_invitation_later = User.deliver_invitation_later
+    User.create_resource_on_invitation = false
+    User.deliver_invitation_later = false
+    DeviseInvitable::Invitation.delete_all
+  end
+
+  teardown do
+    Devise.invitation_delivery_job = @invitation_delivery_job
+    Devise.invitation_delivery_queue_name = @invitation_delivery_queue_name
+    User.create_resource_on_invitation = @create_resource_on_invitation
+    User.store_invite_keys_until_delivery = @store_invite_keys_until_delivery
+    User.deliver_invitation_later = @deliver_invitation_later
+  end
+
+  test 'deliver_later passes a persisted invitation and acceptance token to the configured job' do
+    job_class = Class.new do
+      class << self
+        attr_reader :arguments
+
+        def perform_later(*arguments)
+          @arguments = arguments
+          :enqueued
+        end
+      end
+    end
+    Devise.invitation_delivery_job = job_class
+
+    user = User.invite!(email: 'queued@example.com', skip_invitation: true)
+    invitation = user.current_invitation
+
+    assert_equal :enqueued, invitation.deliver_later
+    enqueued_invitation, acceptance_token, options = job_class.arguments
+    assert_equal invitation, enqueued_invitation
+    assert_equal({}, options)
+    assert_equal 'queued@example.com',
+      DeviseInvitable::AcceptanceToken.decode(acceptance_token).dig(:invite_key, :email)
+
+    assert_difference('ActionMailer::Base.deliveries.size', 1) do
+      DeviseInvitable::InvitationDeliveryJob.perform_now(
+        DeviseInvitable::Invitation.find(invitation.id),
+        acceptance_token,
+        options
+      )
+    end
+    assert_predicate invitation.reload, :invitation_sent_at
+    assert_equal ['queued@example.com'], ActionMailer::Base.deliveries.last.to
+  end
+
+  test 'the default job delivers a reloaded resource-less invitation from stored keys' do
+    User.store_invite_keys_until_delivery = true
+    user = User.invite!(email: 'stored@example.com', skip_invitation: true)
+    invitation = DeviseInvitable::Invitation.find(user.current_invitation.id)
+
+    assert_difference('ActionMailer::Base.deliveries.size', 1) do
+      DeviseInvitable::InvitationDeliveryJob.perform_now(invitation)
+    end
+
+    assert_predicate invitation.reload, :invitation_sent_at
+    assert_empty invitation.invite_key
+    assert_equal ['stored@example.com'], ActionMailer::Base.deliveries.last.to
+  end
+
+  test 'the default job does not enqueue through send_devise_notification' do
+    user = User.invite!(email: 'direct@example.com', skip_invitation: true)
+    invitation = user.current_invitation
+    acceptance_token = user.acceptance_token
+    User.any_instance.stubs(:send_devise_notification).raises('must not be called')
+
+    assert_difference('ActionMailer::Base.deliveries.size', 1) do
+      DeviseInvitable::InvitationDeliveryJob.perform_now(
+        invitation,
+        acceptance_token
+      )
+    end
+
+    assert_predicate invitation.reload, :invitation_sent_at
+  end
+
+  test 'the setting enqueues the normal invitation flow with the configured job' do
+    job_class = Class.new do
+      class << self
+        attr_reader :arguments
+
+        def perform_later(*arguments)
+          @arguments = arguments
+          :enqueued
+        end
+      end
+    end
+    Devise.invitation_delivery_job = job_class
+    User.deliver_invitation_later = true
+    User.any_instance.stubs(:send_devise_notification).raises('must not be called')
+
+    assert_no_difference('ActionMailer::Base.deliveries.size') do
+      User.invite!(email: 'configured@example.com')
+    end
+
+    invitation, acceptance_token, options = job_class.arguments
+    assert_predicate invitation, :persisted?
+    assert_nil invitation.invitation_sent_at
+    assert_equal({ validate: false }, options)
+    assert_equal 'configured@example.com',
+      DeviseInvitable::AcceptanceToken.decode(acceptance_token).dig(:invite_key, :email)
+  end
+
+  test 'the normal flow keeps using send_devise_notification when the setting is disabled' do
+    User.any_instance.expects(:send_devise_notification)
+      .with(:invitation_instructions, kind_of(String), { validate: false })
+      .returns(:application_delivery)
+
+    assert_equal :application_delivery,
+      User.invite_mail!(email: 'application-delivery@example.com')
+  end
+
+  test 'the default job uses the configured queue' do
+    Devise.invitation_delivery_queue_name = :critical_mailers
+
+    assert_equal 'critical_mailers', DeviseInvitable::InvitationDeliveryJob.new.queue_name
+  end
+
+  test 'a reloaded resource-less invitation needs stored keys or an acceptance token' do
+    user = User.invite!(email: 'missing@example.com', skip_invitation: true)
+    invitation = DeviseInvitable::Invitation.find(user.current_invitation.id)
+
+    assert_raises(DeviseInvitable::MissingInviteKeyError) do
+      invitation.deliver_later
+    end
+  end
+end

data/test/lazy_loading_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+require 'open3'
+
+class LazyLoadingTest < ActiveSupport::TestCase
+  LIBRARY = File.expand_path('../lib', __dir__)
+
+  test 'loading devise invitable does not load Active Job' do
+    script = <<~RUBY
+      $LOAD_PATH.unshift #{LIBRARY.inspect}
+      require 'devise_invitable'
+      abort 'Active Job was loaded' if defined?(ActiveJob::Base)
+    RUBY
+    _stdout, stderr, status = Open3.capture3(RbConfig.ruby, '-e', script)
+
+    assert status.success?, stderr
+  end
+end