👀 Views: 0 💬 Answers: 1 📅 Created: 2025-09-12

ruby-on-rails callbacks transactions legacy-code ruby

I'm learning this framework and I'm working on a project and hit a roadblock... I've been banging my head against this for hours. While refactoring an older Rails application (using Rails 5.2), I stumbled upon a peculiar issue with callbacks in a model that heavily utilizes nested transactions. The model in question has before_save and after_commit callbacks that seem to be interfering with each other, causing unexpected behavior during tests. The model looks somewhat like this: ```ruby class Order < ApplicationRecord has_many :line_items before_save :calculate_total after_commit :notify_customer def calculate_total self.total = line_items.sum(:price) end def notify_customer NotificationService.send_order_confirmation(self) end end ``` During development, I modified an existing test that creates an `Order` along with its associated `LineItem` records. It looks like this: ```ruby describe Order do it 'calculates the total and sends confirmation after save' do order = Order.new order.line_items.build(price: 100) order.save expect(order.total).to eq(100) expect(NotificationService).to have_received(:send_order_confirmation).with(order) end end ``` However, upon running the test, the `NotificationService` method is not being called, despite the `order` being saved successfully. My initial assumption is that the nested transaction might be rolling back the after_commit callback, but the logs don't indicate any issues with the transaction itself. I've attempted adding `puts` statements into both callbacks to see their execution order, and indeed, `calculate_total` runs correctly, but `notify_customer` seems to be skipped entirely. I even tried switching the callbacks' order and removing the nested transactions, but that led to other inconsistencies. Could there be a deeper issue with how ActiveRecord handles nested transactions, or is it possible that callbacks in this context are not behaving as expected? Any insights on best practices for managing nested transactions with callbacks in Rails would be greatly appreciated! Furthermore, if there are any recommended patterns for ensuring that both the total calculation and notification happen reliably, I'd love to hear them. Am I missing something obvious? I'm working in a CentOS environment. Any suggestions would be helpful. Any examples would be super helpful.