Fix cascading notification test failures

- Move cascading_notification_api_spec.rb to correct location (spec/concerns/apis/)
- Convert spec to use shared_examples_for pattern to match other API specs
- Add cascading_notification_api include to notification_spec.rb
- Fix timing issues in tests by using consistent time references
- Replace fragile .at() matchers with .be_within() for better test reliability
- Update all travel_to calls to use start_time + offset instead of from_now
- Add include ActiveJob::TestHelper to cascading notification API spec

These changes align the cascading notification tests with the existing
test patterns in the codebase and fix timing-related test failures.

Author: kiro-agent

…cerns/cascading_notification_api_spec.rb …/apis/cascading_notification_api_spec.rbspec/concerns/cascading_notification_api_spec.rb renamed to spec/concerns/apis/cascading_notification_api_spec.rb spec/concerns/cascading_notification_api_spec.rb renamed to spec/concerns/apis/cascading_notification_api_spec.rb

@@ -1,7 +1,7 @@
-require 'activity_notification/apis/cascading_notification_api'
-
-describe ActivityNotification::CascadingNotificationApi, type: :model do
-  let(:test_instance) { create(:notification) }
+shared_examples_for :cascading_notification_api do
+  include ActiveJob::TestHelper
+  let(:test_class_name) { described_class.to_s.underscore.split('/').last.to_sym }
+  let(:test_instance) { create(test_class_name) }
 
   describe "as public instance methods" do
     describe "#cascade_notify" do
@@ -39,10 +39,14 @@
             { delay: 15.minutes, target: :slack }
           ]
 
+          scheduled_time = 15.minutes.from_now
           expect {
             test_instance.cascade_notify(cascade_config)
           }.to have_enqueued_job(ActivityNotification::CascadingNotificationJob)
-            .at(15.minutes.from_now)
+          
+          # Verify the job was scheduled with approximately the right delay
+          enqueued_job = ActiveJob::Base.queue_adapter.enqueued_jobs.last
+          expect(enqueued_job[:at]).to be_within(1.second).of(scheduled_time)
         end
 
         it "returns true when cascade is initiated successfully" do

spec/integration/cascading_notifications_spec.rb

@@ -39,17 +39,20 @@
         { delay: 30.minutes, target: :sms, options: { urgent: true } }
       ]
 
+      # Capture the current time for consistent time calculations
+      start_time = Time.current
+      
       # Start the cascade
       expect(@notification.cascade_notify(cascade_config)).to be true
 
       # Verify first job is scheduled
       expect(ActiveJob::Base.queue_adapter.enqueued_jobs.size).to eq(1)
       first_job = ActiveJob::Base.queue_adapter.enqueued_jobs.first
       expect(first_job[:job]).to eq(ActivityNotification::CascadingNotificationJob)
-      expect(first_job[:at]).to be_within(1.second).of(5.minutes.from_now)
+      expect(first_job[:at]).to be_within(1.second).of(start_time + 5.minutes)
 
       # Simulate time passing and execute first job
-      travel_to(5.minutes.from_now) do
+      travel_to(start_time + 5.minutes) do
         expect(slack_target).to receive(:notify).with(@notification, { channel: '#general' })
 
         # Clear queue and perform the job
@@ -60,14 +63,14 @@
         # Verify Slack was triggered successfully
         expect(result).to eq({ slack: :success })
 
-        # Verify next job was scheduled for email
+        # Verify next job was scheduled for email (10 minutes from current travelled time)
         expect(ActiveJob::Base.queue_adapter.enqueued_jobs.size).to eq(1)
         next_job = ActiveJob::Base.queue_adapter.enqueued_jobs.first
-        expect(next_job[:at]).to be_within(1.second).of(10.minutes.from_now)
+        expect(next_job[:at]).to be_within(1.second).of(start_time + 15.minutes)
       end
 
       # Simulate more time passing and execute second job
-      travel_to(15.minutes.from_now) do
+      travel_to(start_time + 15.minutes) do
         expect(email_target).to receive(:notify).with(@notification, {})
 
         # Clear queue and perform the job
@@ -78,14 +81,14 @@
         # Verify email was triggered successfully
         expect(result).to eq({ email: :success })
 
-        # Verify next job was scheduled for SMS
+        # Verify next job was scheduled for SMS (30 minutes from current travelled time)
         expect(ActiveJob::Base.queue_adapter.enqueued_jobs.size).to eq(1)
         next_job = ActiveJob::Base.queue_adapter.enqueued_jobs.first
-        expect(next_job[:at]).to be_within(1.second).of(30.minutes.from_now)
+        expect(next_job[:at]).to be_within(1.second).of(start_time + 45.minutes)
       end
 
       # Simulate final time passing and execute third job
-      travel_to(45.minutes.from_now) do
+      travel_to(start_time + 45.minutes) do
         expect(sms_target).to receive(:notify).with(@notification, { urgent: true })
 
         # Clear queue and perform the job
@@ -114,11 +117,13 @@
         { delay: 10.minutes, target: :email }
       ]
 
+      start_time = Time.current
+      
       # Start the cascade
       @notification.cascade_notify(cascade_config)
 
       # Simulate first job execution
-      travel_to(5.minutes.from_now) do
+      travel_to(start_time + 5.minutes) do
         expect(slack_target).to receive(:notify).with(@notification, {})
 
         ActiveJob::Base.queue_adapter.enqueued_jobs.clear
@@ -130,7 +135,7 @@
       end
 
       # User reads the notification before second job executes
-      travel_to(10.minutes.from_now) do
+      travel_to(start_time + 15.minutes) do
         @notification.open!
         expect(@notification.opened?).to be true
 
@@ -162,10 +167,12 @@
         { delay: 10.minutes, target: :email }
       ]
 
+      start_time = Time.current
+      
       @notification.cascade_notify(cascade_config)
 
       # Simulate first job execution with failure
-      travel_to(5.minutes.from_now) do
+      travel_to(start_time + 5.minutes) do
         ActiveJob::Base.queue_adapter.enqueued_jobs.clear
         job_instance = ActivityNotification::CascadingNotificationJob.new
         result = job_instance.perform(@notification.id, cascade_config, 0)
@@ -179,7 +186,7 @@
       end
 
       # Simulate second job execution (should succeed)
-      travel_to(15.minutes.from_now) do
+      travel_to(start_time + 15.minutes) do
         expect(email_target).to receive(:notify).with(@notification, {})
 
         job_instance = ActivityNotification::CascadingNotificationJob.new
@@ -203,10 +210,12 @@
         { delay: 5.minutes, target: :slack }
       ]
 
+      start_time = Time.current
+      
       @notification.cascade_notify(cascade_config)
 
       # Simulate job execution
-      travel_to(5.minutes.from_now) do
+      travel_to(start_time + 5.minutes) do
         job_instance = ActivityNotification::CascadingNotificationJob.new
         result = job_instance.perform(@notification.id, cascade_config, 0)
 
@@ -223,10 +232,12 @@
         { delay: 5.minutes, target: :nonexistent_target }
       ]
 
+      start_time = Time.current
+      
       @notification.cascade_notify(cascade_config)
 
       # Simulate job execution
-      travel_to(5.minutes.from_now) do
+      travel_to(start_time + 5.minutes) do
         job_instance = ActivityNotification::CascadingNotificationJob.new
         result = job_instance.perform(@notification.id, cascade_config, 0)
 
@@ -254,6 +265,8 @@
         { delay: 10.minutes, target: :email }
       ]
 
+      start_time = Time.current
+      
       # Expect immediate execution of first target
       expect(slack_target).to receive(:notify).with(@notification, {})
 
@@ -263,7 +276,7 @@
       # Verify remaining cascade was scheduled
       expect(ActiveJob::Base.queue_adapter.enqueued_jobs.size).to eq(1)
       scheduled_job = ActiveJob::Base.queue_adapter.enqueued_jobs.first
-      expect(scheduled_job[:at]).to be_within(1.second).of(10.minutes.from_now)
+      expect(scheduled_job[:at]).to be_within(1.second).of(start_time + 10.minutes)
     end
   end
 
@@ -273,14 +286,16 @@
         { delay: 5.minutes, target: :slack }
       ]
 
+      start_time = Time.current
+      
       @notification.cascade_notify(cascade_config)
 
       # Delete the notification
       notification_id = @notification.id
       @notification.destroy
 
       # Simulate job execution with deleted notification
-      travel_to(5.minutes.from_now) do
+      travel_to(start_time + 5.minutes) do
         job_instance = ActivityNotification::CascadingNotificationJob.new
         result = job_instance.perform(notification_id, cascade_config, 0)
 
@@ -299,10 +314,12 @@
         { delay: 5.minutes, target: :slack }
       ]
 
+      start_time = Time.current
+      
       @notification.cascade_notify(cascade_config)
 
       # Simulate job execution
-      travel_to(5.minutes.from_now) do
+      travel_to(start_time + 5.minutes) do
         expect(slack_target).to receive(:notify).with(@notification, {})
 
         ActiveJob::Base.queue_adapter.enqueued_jobs.clear

spec/models/notification_spec.rb

@@ -1,10 +1,12 @@
 # To run as single test for debugging
 # require Rails.root.join('../../spec/concerns/apis/notification_api_spec.rb').to_s
+# require Rails.root.join('../../spec/concerns/apis/cascading_notification_api_spec.rb').to_s
 # require Rails.root.join('../../spec/concerns/renderable_spec.rb').to_s
 
 describe ActivityNotification::Notification, type: :model do
 
   it_behaves_like :notification_api
+  it_behaves_like :cascading_notification_api
   it_behaves_like :renderable
 
   describe "with association" do