activity_notification 2.3.2 → 2.4.0

data/spec/controllers/notifications_controller_shared_examples.rb

@@ -359,6 +359,156 @@ shared_examples_for :notifications_controller do
           expect(@notification_2.reload.opened?).to be_truthy
         end
       end
+
+      context 'with ids parameter' do
+        it "opens only specified notifications" do
+          post_with_compatibility :open_all, target_params.merge({ typed_target_param => test_target, ids: [@notification_1.id] }), valid_session
+          expect(@notification_1.reload.opened?).to be_truthy
+          expect(@notification_2.reload.opened?).to be_falsey
+        end
+
+        it "applies other filter options when ids are specified" do
+          post_with_compatibility :open_all, target_params.merge({ 
+            typed_target_param => test_target, 
+            ids: [@notification_1.id], 
+            filtered_by_key: 'non_existent_key' 
+          }), valid_session
+          expect(@notification_1.reload.opened?).to be_falsey
+          expect(@notification_2.reload.opened?).to be_falsey
+        end
+      end
+    end
+  end
+
+  describe "POST #destroy_all" do
+    context "http direct POST request" do
+      before do
+        @notification = create(:notification, target: test_target)
+        expect(test_target.notifications.count).to eq(1)
+        post_with_compatibility :destroy_all, target_params.merge({ typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 302 as http status code" do
+        expect(response.status).to eq(302)
+      end
+
+      it "destroys all notifications of the target" do
+        expect(test_target.notifications.count).to eq(0)
+      end
+
+      it "redirects to :index" do
+        expect(response).to redirect_to action: :index
+      end
+    end
+
+    context "http POST request from root_path" do
+      before do
+        @notification = create(:notification, target: test_target)
+        expect(test_target.notifications.count).to eq(1)
+        request.env["HTTP_REFERER"] = root_path
+        post_with_compatibility :destroy_all, target_params.merge({ typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 302 as http status code" do
+        expect(response.status).to eq(302)
+      end
+
+      it "destroys all notifications of the target" do
+        expect(test_target.notifications.count).to eq(0)
+      end
+
+      it "redirects to root_path as request.referer" do
+        expect(response).to redirect_to root_path
+      end
+    end
+
+    context "Ajax POST request" do
+      before do
+        @notification = create(:notification, target: test_target)
+        expect(test_target.notifications.count).to eq(1)
+        xhr_with_compatibility :post, :destroy_all, target_params.merge({ typed_target_param => test_target }), valid_session
+      end
+
+      it "returns 200 as http status code" do
+        expect(response.status).to eq(200)
+      end
+
+      it "assigns notification index as @notifications" do
+        expect(assigns(:notifications)).to eq([])
+      end
+
+      it "destroys all notifications of the target" do
+        expect(test_target.notifications.count).to eq(0)
+      end
+
+      it "renders the :destroy_all template as format js" do
+        expect(response).to render_template :destroy_all, format: :js
+      end
+    end
+
+    context "with filter request parameters" do
+      before do
+        @target_1, @notifiable_1, @group_1, @key_1 = create(:confirmed_user), create(:article), nil,           "key.1"
+        @target_2, @notifiable_2, @group_2, @key_2 = create(:confirmed_user), create(:comment), @notifiable_1, "key.2"
+        @notification_1 = create(:notification, target: test_target, notifiable: @notifiable_1, group: @group_1, key: @key_1)
+        @notification_2 = create(:notification, target: test_target, notifiable: @notifiable_2, group: @group_2, key: @key_2, created_at: @notification_1.created_at + 10.second)
+        expect(test_target.notifications.count).to eq(2)
+      end
+
+      context "with filtered_by_type request parameters" do
+        it "destroys filtered notifications only" do
+          post_with_compatibility :destroy_all, target_params.merge({ typed_target_param => test_target, 'filtered_by_type' => @notifiable_2.to_class_name }), valid_session
+          expect(test_target.notifications.count).to eq(1)
+          expect(test_target.notifications.first).to eq(@notification_1)
+        end
+      end
+
+      context "with filtered_by_group request parameters" do
+        it "destroys filtered notifications only" do
+          post_with_compatibility :destroy_all, target_params.merge({ typed_target_param => test_target, 'filtered_by_group_type' => @group_2.to_class_name, 'filtered_by_group_id' => @group_2.id.to_s }), valid_session
+          expect(test_target.notifications.count).to eq(1)
+          expect(test_target.notifications.first).to eq(@notification_1)
+        end
+      end
+
+      context "with filtered_by_key request parameters" do
+        it "destroys filtered notifications only" do
+          post_with_compatibility :destroy_all, target_params.merge({ typed_target_param => test_target, 'filtered_by_key' => @key_2 }), valid_session
+          expect(test_target.notifications.count).to eq(1)
+          expect(test_target.notifications.first).to eq(@notification_1)
+        end
+      end
+
+      context "with later_than request parameters" do
+        it "destroys filtered notifications only" do
+          post_with_compatibility :destroy_all, target_params.merge({ typed_target_param => test_target, 'later_than' => (@notification_1.created_at.in_time_zone + 5.second).iso8601(3) }), valid_session
+          expect(test_target.notifications.count).to eq(1)
+          expect(test_target.notifications.first).to eq(@notification_1)
+        end
+      end
+
+      context "with earlier_than request parameters" do
+        it "destroys filtered notifications only" do
+          post_with_compatibility :destroy_all, target_params.merge({ typed_target_param => test_target, 'earlier_than' => (@notification_2.created_at.in_time_zone - 5.second).iso8601(3) }), valid_session
+          expect(test_target.notifications.count).to eq(1)
+          expect(test_target.notifications.first).to eq(@notification_2)
+        end
+      end
+
+      context "with ids request parameters" do
+        it "destroys notifications with specified IDs only" do
+          post_with_compatibility :destroy_all, target_params.merge({ typed_target_param => test_target, 'ids' => [@notification_2.id.to_s] }), valid_session
+          expect(test_target.notifications.count).to eq(1)
+          expect(test_target.notifications.first).to eq(@notification_1)
+        end
+      end
+
+      context "with no filter request parameters" do
+        it "destroys all notifications of the target" do
+          post_with_compatibility :destroy_all, target_params.merge({ typed_target_param => test_target}), valid_session
+          expect(test_target.notifications.count).to eq(0)
+        end
+      end
     end
   end
 

data/spec/helpers/view_helpers_spec.rb

@@ -299,6 +299,13 @@ describe ActivityNotification::ViewHelpers, type: :helper do
     end
   end
 
+  describe '#destroy_all_notifications_path_for' do
+    it "returns path for the notification target" do
+      expect(destroy_all_notifications_path_for(target_user))
+        .to eq(destroy_all_user_notifications_path(target_user))
+    end
+  end
+
   describe '#notifications_url_for' do
     it "returns url for the notification target" do
       expect(notifications_url_for(target_user))
@@ -334,6 +341,13 @@ describe ActivityNotification::ViewHelpers, type: :helper do
     end
   end
 
+  describe '#destroy_all_notifications_url_for' do
+    it "returns url for the notification target" do
+      expect(destroy_all_notifications_url_for(target_user))
+        .to eq(destroy_all_user_notifications_url(target_user))
+    end
+  end
+
   describe '#subscriptions_path_for' do
     it "returns path for the subscription target" do
       expect(subscriptions_path_for(target_user))

data/spec/jobs/notification_resilience_job_spec.rb

@@ -0,0 +1,167 @@
+describe "Notification resilience in background jobs" do
+  include ActiveJob::TestHelper
+  
+  let(:user) { create(:user) }
+  let(:article) { create(:article, user: user) }
+  let(:comment) { create(:comment, article: article, user: create(:user)) }
+
+  before do
+    ActivityNotification::Mailer.deliveries.clear
+    clear_enqueued_jobs
+    clear_performed_jobs
+    @original_email_enabled = ActivityNotification.config.email_enabled
+    ActivityNotification.config.email_enabled = true
+  end
+
+  after do
+    ActivityNotification.config.email_enabled = @original_email_enabled
+  end
+
+  describe "Job resilience" do
+    it "handles missing notifications gracefully in background jobs" do
+      # Create a notification and destroy it to simulate race condition
+      notification = ActivityNotification::Notification.create!(
+        target: user,
+        notifiable: comment,
+        key: 'comment.create'
+      )
+      
+      notification_id = notification.id
+      notification.destroy
+      
+      # Expect warning to be logged
+      expect(Rails.logger).to receive(:warn).with(/ActivityNotification: Notification.*not found for email delivery/)
+      
+      # Execute job - should not raise error
+      expect {
+        perform_enqueued_jobs do
+          # Simulate job trying to send email for destroyed notification
+          begin
+            destroyed_notification = ActivityNotification::Notification.find(notification_id)
+            destroyed_notification.send_notification_email
+          rescue => e
+            # Handle any ORM-specific "record not found" exception
+            if ActivityNotification::NotificationResilience.record_not_found_exception?(e)
+              Rails.logger.warn("ActivityNotification: Notification with id #{notification_id} not found for email delivery (#{ActivityNotification.config.orm}/#{e.class.name}), likely destroyed before job execution")
+            else
+              raise e
+            end
+          end
+        end
+      }.not_to raise_error
+      
+      expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
+    end
+  end
+
+  describe "Mailer job resilience" do
+    context "when notification is destroyed before mailer job executes" do
+      it "handles the scenario gracefully" do
+        # Create a notification
+        notification = ActivityNotification::Notification.create!(
+          target: user,
+          notifiable: comment,
+          key: 'comment.create'
+        )
+        
+        notification_id = notification.id
+        
+        # Expect warning to be logged when notification is not found
+        expect(Rails.logger).to receive(:warn).with(/ActivityNotification: Notification.*not found for email delivery/)
+        
+        # Destroy the notification
+        notification.destroy
+        
+        # Try to send email using the mailer directly - this should use our resilient implementation
+        expect {
+          perform_enqueued_jobs do
+            # Create a mock notification that will raise RecordNotFound when accessed
+            mock_notification = double("notification")
+            allow(mock_notification).to receive(:id).and_return(notification_id)
+            allow(mock_notification).to receive(:target).and_raise(ActiveRecord::RecordNotFound)
+            
+            ActivityNotification::Mailer.send_notification_email(mock_notification).deliver_now
+          end
+        }.not_to raise_error
+        
+        # No email should be sent
+        expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
+      end
+    end
+
+    context "when notification exists during mailer job execution" do
+      it "sends email normally" do
+        # Enable email for this test
+        allow_any_instance_of(User).to receive(:notification_email_allowed?).and_return(true)
+        allow_any_instance_of(Comment).to receive(:notification_email_allowed?).and_return(true)
+        allow_any_instance_of(ActivityNotification::Notification).to receive(:email_subscribed?).and_return(true)
+        
+        # Create a notification
+        notification = ActivityNotification::Notification.create!(
+          target: user,
+          notifiable: comment,
+          key: 'comment.create'
+        )
+        
+        # Don't expect any warnings
+        expect(Rails.logger).not_to receive(:warn)
+        
+        # Send email - this should work normally
+        expect {
+          perform_enqueued_jobs do
+            ActivityNotification::Mailer.send_notification_email(notification).deliver_now
+          end
+        }.not_to raise_error
+        
+        # Email should be sent
+        expect(ActivityNotification::Mailer.deliveries.size).to eq(1)
+      end
+    end
+  end
+
+  describe "Multiple job resilience" do
+    it "continues processing other jobs even when some notifications are missing" do
+      # Enable email for this test
+      allow_any_instance_of(User).to receive(:notification_email_allowed?).and_return(true)
+      allow_any_instance_of(Comment).to receive(:notification_email_allowed?).and_return(true)
+      allow_any_instance_of(ActivityNotification::Notification).to receive(:email_subscribed?).and_return(true)
+      
+      # Create two notifications
+      notification1 = ActivityNotification::Notification.create!(
+        target: user,
+        notifiable: comment,
+        key: 'comment.create'
+      )
+      
+      notification2 = ActivityNotification::Notification.create!(
+        target: user,
+        notifiable: create(:comment, article: article, user: create(:user)),
+        key: 'comment.create'
+      )
+      
+      # Destroy the first notification
+      notification1_id = notification1.id
+      notification1.destroy
+      
+      # Expect one warning for the destroyed notification
+      expect(Rails.logger).to receive(:warn).with(/ActivityNotification: Notification.*not found for email delivery/).once
+      
+      # Process both jobs
+      expect {
+        perform_enqueued_jobs do
+          # First job - should handle missing notification gracefully
+          mock_notification1 = double("notification")
+          allow(mock_notification1).to receive(:id).and_return(notification1_id)
+          allow(mock_notification1).to receive(:target).and_raise(ActiveRecord::RecordNotFound)
+          ActivityNotification::Mailer.send_notification_email(mock_notification1).deliver_now
+          
+          # Second job - should work normally
+          ActivityNotification::Mailer.send_notification_email(notification2).deliver_now
+        end
+      }.not_to raise_error
+      
+      # Only one email should be sent (for notification2)
+      expect(ActivityNotification::Mailer.deliveries.size).to eq(1)
+    end
+  end
+end

data/spec/mailers/notification_resilience_spec.rb

@@ -0,0 +1,263 @@
+describe ActivityNotification::NotificationResilience do
+  include ActiveJob::TestHelper
+  let(:notification) { create(:notification) }
+  let(:test_target) { notification.target }
+  let(:notifications) { [create(:notification, target: test_target), create(:notification, target: test_target)] }
+  let(:batch_key) { 'test_batch_key' }
+
+  before do
+    ActivityNotification::Mailer.deliveries.clear
+    expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
+  end
+
+  describe "ORM exception handling" do
+    describe ".current_orm" do
+      it "returns the configured ORM" do
+        expect(ActivityNotification::NotificationResilience.current_orm).to eq(ActivityNotification.config.orm)
+      end
+    end
+
+    describe ".record_not_found_exception_class" do
+      context "with ActiveRecord ORM" do
+        before { allow(ActivityNotification.config).to receive(:orm).and_return(:active_record) }
+        
+        it "returns ActiveRecord::RecordNotFound" do
+          expect(ActivityNotification::NotificationResilience.record_not_found_exception_class).to eq(ActiveRecord::RecordNotFound)
+        end
+      end
+
+      context "with Mongoid ORM" do
+        before { allow(ActivityNotification.config).to receive(:orm).and_return(:mongoid) }
+        
+        it "returns Mongoid exception class if available" do
+          if defined?(Mongoid::Errors::DocumentNotFound)
+            expect(ActivityNotification::NotificationResilience.record_not_found_exception_class).to eq(Mongoid::Errors::DocumentNotFound)
+          else
+            expect(ActivityNotification::NotificationResilience.record_not_found_exception_class).to be_nil
+          end
+        end
+      end
+
+      context "with Dynamoid ORM" do
+        before { allow(ActivityNotification.config).to receive(:orm).and_return(:dynamoid) }
+        
+        it "returns Dynamoid exception class if available" do
+          if defined?(Dynamoid::Errors::RecordNotFound)
+            expect(ActivityNotification::NotificationResilience.record_not_found_exception_class).to eq(Dynamoid::Errors::RecordNotFound)
+          else
+            expect(ActivityNotification::NotificationResilience.record_not_found_exception_class).to be_nil
+          end
+        end
+      end
+
+      context "with unavailable ORM exception class" do
+        around do |example|
+          # Temporarily modify the ORM_EXCEPTIONS constant
+          original_exceptions = ActivityNotification::NotificationResilience::ORM_EXCEPTIONS
+          ActivityNotification::NotificationResilience.send(:remove_const, :ORM_EXCEPTIONS)
+          ActivityNotification::NotificationResilience.const_set(:ORM_EXCEPTIONS, {
+            active_record: 'NonExistent::ExceptionClass',
+            mongoid: 'Mongoid::Errors::DocumentNotFound', 
+            dynamoid: 'Dynamoid::Errors::RecordNotFound'
+          })
+          
+          example.run
+          
+          # Restore original constant
+          ActivityNotification::NotificationResilience.send(:remove_const, :ORM_EXCEPTIONS)
+          ActivityNotification::NotificationResilience.const_set(:ORM_EXCEPTIONS, original_exceptions)
+        end
+        
+        before { allow(ActivityNotification.config).to receive(:orm).and_return(:active_record) }
+        
+        it "returns nil when exception class is not available" do
+          expect(ActivityNotification::NotificationResilience.record_not_found_exception_class).to be_nil
+        end
+      end
+    end
+
+    describe ".record_not_found_exception?" do
+      it "returns true for ActiveRecord::RecordNotFound" do
+        exception = ActiveRecord::RecordNotFound.new("Test error")
+        expect(ActivityNotification::NotificationResilience.record_not_found_exception?(exception)).to be_truthy
+      end
+
+      it "returns false for other exceptions" do
+        exception = StandardError.new("Test error")
+        expect(ActivityNotification::NotificationResilience.record_not_found_exception?(exception)).to be_falsy
+      end
+
+      context "when exception class constantize raises NameError" do
+        around do |example|
+          # Temporarily modify the ORM_EXCEPTIONS constant
+          original_exceptions = ActivityNotification::NotificationResilience::ORM_EXCEPTIONS
+          ActivityNotification::NotificationResilience.send(:remove_const, :ORM_EXCEPTIONS)
+          ActivityNotification::NotificationResilience.const_set(:ORM_EXCEPTIONS, {
+            active_record: 'NonExistent::ExceptionClass1',
+            mongoid: 'NonExistent::ExceptionClass2', 
+            dynamoid: 'NonExistent::ExceptionClass3'
+          })
+          
+          example.run
+          
+          # Restore original constant
+          ActivityNotification::NotificationResilience.send(:remove_const, :ORM_EXCEPTIONS)
+          ActivityNotification::NotificationResilience.const_set(:ORM_EXCEPTIONS, original_exceptions)
+        end
+        
+        it "returns false when all exception classes are unavailable" do
+          exception = StandardError.new("Test error")
+          # Should return false because all exception classes will raise NameError
+          expect(ActivityNotification::NotificationResilience.record_not_found_exception?(exception)).to be_falsy
+        end
+      end
+    end
+  end
+
+  describe "Resilient email sending" do
+    describe "when notification is destroyed before email job executes" do
+      let(:destroyed_notification) { create(:notification) }
+      
+      before do
+        destroyed_notification_id = destroyed_notification.id
+        destroyed_notification.destroy
+        
+        # Mock the notification to simulate the scenario where the job tries to access a destroyed notification
+        allow(ActivityNotification::Notification).to receive(:find).with(destroyed_notification_id).and_raise(ActiveRecord::RecordNotFound)
+      end
+
+      context "with send_notification_email" do
+        it "handles missing notification gracefully and logs warning" do
+          expect(Rails.logger).to receive(:warn).with(/ActivityNotification: Notification.*not found for email delivery/)
+          
+          # Create a mock notification that will raise RecordNotFound when accessed
+          mock_notification = double("notification")
+          allow(mock_notification).to receive(:id).and_return(999)
+          allow(mock_notification).to receive(:target).and_raise(ActiveRecord::RecordNotFound)
+          
+          result = nil
+          expect {
+            result = ActivityNotification::Mailer.send_notification_email(mock_notification).deliver_now
+          }.not_to raise_error
+          
+          expect(result).to be_nil
+          expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
+        end
+      end
+
+      context "with send_batch_notification_email" do
+        it "handles missing notifications gracefully and logs warning" do
+          expect(Rails.logger).to receive(:warn).with(/ActivityNotification: Notification.*not found for email delivery/)
+          
+          # Create mock notifications that will raise RecordNotFound when accessed
+          mock_notifications = [double("notification")]
+          allow(mock_notifications.first).to receive(:id).and_return(999)
+          allow(mock_notifications.first).to receive(:key).and_return("test.key")
+          allow(mock_notifications.first).to receive(:notifiable).and_raise(ActiveRecord::RecordNotFound)
+          
+          result = nil
+          expect {
+            result = ActivityNotification::Mailer.send_batch_notification_email(test_target, mock_notifications, batch_key).deliver_now
+          }.not_to raise_error
+          
+          expect(result).to be_nil
+          expect(ActivityNotification::Mailer.deliveries.size).to eq(0)
+        end
+      end
+    end
+
+    describe "when notification exists" do
+      context "with send_notification_email" do
+        it "sends email normally" do
+          expect(Rails.logger).not_to receive(:warn)
+          
+          ActivityNotification::Mailer.send_notification_email(notification).deliver_now
+          
+          expect(ActivityNotification::Mailer.deliveries.size).to eq(1)
+          expect(ActivityNotification::Mailer.deliveries.last.to[0]).to eq(notification.target.email)
+        end
+      end
+
+      context "with send_batch_notification_email" do
+        it "sends batch email normally" do
+          expect(Rails.logger).not_to receive(:warn)
+          
+          ActivityNotification::Mailer.send_batch_notification_email(test_target, notifications, batch_key).deliver_now
+          
+          expect(ActivityNotification::Mailer.deliveries.size).to eq(1)
+          expect(ActivityNotification::Mailer.deliveries.last.to[0]).to eq(test_target.email)
+        end
+      end
+    end
+  end
+
+  describe "Class methods (when included in a class)" do
+    let(:test_class) { Class.new { include ActivityNotification::NotificationResilience } }
+    
+    describe "class method exception handling with NameError" do
+      around do |example|
+        # Temporarily modify the ORM_EXCEPTIONS constant
+        original_exceptions = ActivityNotification::NotificationResilience::ORM_EXCEPTIONS
+        ActivityNotification::NotificationResilience.send(:remove_const, :ORM_EXCEPTIONS)
+        ActivityNotification::NotificationResilience.const_set(:ORM_EXCEPTIONS, {
+          active_record: 'NonExistent::ClassMethodException',
+          mongoid: 'Mongoid::Errors::DocumentNotFound', 
+          dynamoid: 'Dynamoid::Errors::RecordNotFound'
+        })
+        
+        example.run
+        
+        # Restore original constant
+        ActivityNotification::NotificationResilience.send(:remove_const, :ORM_EXCEPTIONS)
+        ActivityNotification::NotificationResilience.const_set(:ORM_EXCEPTIONS, original_exceptions)
+      end
+      
+      before { allow(ActivityNotification.config).to receive(:orm).and_return(:active_record) }
+      
+      it "returns nil when exception class is not available (class method)" do
+        expect(test_class.record_not_found_exception_class).to be_nil
+      end
+      
+      it "returns false when exception class constantize raises NameError (class method)" do
+        exception = StandardError.new("Test error")
+        expect(test_class.record_not_found_exception?(exception)).to be_falsy
+      end
+    end
+  end
+
+  describe "Logging behavior" do
+    let(:mock_notification) { double("notification", id: 123) }
+    let(:resilience_instance) { Class.new { include ActivityNotification::NotificationResilience }.new }
+    
+    it "logs appropriate warning message with notification ID" do
+      exception = ActiveRecord::RecordNotFound.new("Test error")
+      
+      expect(Rails.logger).to receive(:warn).with(
+        /ActivityNotification: Notification with id 123 not found for email delivery.*likely destroyed before job execution/
+      )
+      
+      resilience_instance.send(:log_missing_notification, 123, exception)
+    end
+
+    it "logs warning message with context information" do
+      exception = ActiveRecord::RecordNotFound.new("Test error")
+      context = { target: "User", key: "comment.create" }
+      
+      expect(Rails.logger).to receive(:warn).with(
+        /ActivityNotification: Notification with id 123 not found for email delivery.*target: User, key: comment\.create/
+      )
+      
+      resilience_instance.send(:log_missing_notification, 123, exception, context)
+    end
+
+    it "logs warning message without ID when not provided" do
+      exception = ActiveRecord::RecordNotFound.new("Test error")
+      
+      expect(Rails.logger).to receive(:warn).with(
+        /ActivityNotification: Notification not found for email delivery.*likely destroyed before job execution/
+      )
+      
+      resilience_instance.send(:log_missing_notification, nil, exception)
+    end
+  end
+end

data/spec/models/notification_spec.rb

@@ -90,7 +90,7 @@ describe ActivityNotification::Notification, type: :model do
   end
 
   describe "with validation" do
-    before { @notification = build(:notification) }
+    before { @notification = create(:notification) }
 
     it "is valid with target, notifiable and key" do
       expect(@notification).to be_valid

data/spec/models/subscription_spec.rb

@@ -22,7 +22,7 @@ describe ActivityNotification::Subscription, type: :model do
   end
 
   describe "with validation" do
-    before { @subscription = build(:subscription) }
+    before { @subscription = create(:subscription) }
 
     it "is valid with target and key" do
       expect(@subscription).to be_valid

data/spec/rails_app/app/helpers/devise_helper.rb

@@ -0,0 +1,2 @@
+module DeviseHelper
+end

data/spec/rails_app/config/application.rb

@@ -34,6 +34,7 @@ module Dummy
     if Gem::Version.new("5.2.0") <= Rails.gem_version && Rails.gem_version < Gem::Version.new("6.0.0") && ENV['AN_TEST_DB'] != 'mongodb'
       config.active_record.sqlite3.represent_boolean_as_integer = true
     end
+    config.active_support.to_time_preserves_timezone = :zone
 
     # Configure CORS for API mode
     if defined?(Rack::Cors)

data/spec/rails_app/config/initializers/zeitwerk.rb

@@ -0,0 +1,10 @@
+# Mongoid 9.0+ compatibility
+if ENV['AN_ORM'] == 'mongoid'
+  # Preload helper modules before Rails initialization
+  Rails.application.config.before_initialize do
+    # Load all helper files manually to avoid Zeitwerk issues
+    Dir[Rails.root.join('app', 'helpers', '*.rb')].each do |helper_file|
+      require_dependency helper_file
+    end
+  end
+end