Clean up tests after unifying discard behaviour

Author: rosa

test/dummy/app/jobs/discard_on_conflict_job.rb

@@ -0,0 +1,3 @@
+class DiscardableUpdateResultJob < UpdateResultJob
+  limits_concurrency key: ->(job_result, **) { job_result }, on_conflict: :discard
+end

test/dummy/app/jobs/discardable_update_result_job.rb

@@ -196,6 +196,61 @@ class ConcurrencyControlsTest < ActiveSupport::TestCase
     end
   end
 
+  test "discard jobs when concurrency limit is reached with on_conflict: :discard" do
+    # Enqueue first job - should be executed
+    job1 = DiscardableUpdateResultJob.perform_later(@result, name: "1", pause: 0.2)
+    # Enqueue second job - should be discarded due to concurrency limit
+    job2 = DiscardableUpdateResultJob.perform_later(@result, name: "2")
+    # Enqueue third job - should also be discarded
+    job3 = DiscardableUpdateResultJob.perform_later(@result, name: "3")
+
+    wait_for_jobs_to_finish_for(5.seconds)
+    assert_no_unfinished_jobs
+
+    # Only the first job did something
+    assert_stored_sequence(@result, [ "1" ])
+
+    # All jobs have finished and have no blocked executions
+    jobs = SolidQueue::Job.where(active_job_id: [ job1, job2, job3 ].map(&:job_id))
+    assert_equal 3, jobs.count
+
+    jobs.each do |job|
+      assert job.finished?
+      assert_nil job.blocked_execution
+    end
+  end
+
+  test "discard on conflict across different concurrency keys" do
+    another_result = JobResult.create!(queue_name: "default", status: "seq: ")
+    DiscardableUpdateResultJob.perform_later(@result, name: "1", pause: 0.2)
+    DiscardableUpdateResultJob.perform_later(another_result, name: "2", pause: 0.2)
+    DiscardableUpdateResultJob.perform_later(@result, name: "3") # Should be discarded
+    DiscardableUpdateResultJob.perform_later(another_result, name: "4") # Should be discarded
+
+    wait_for_jobs_to_finish_for(5.seconds)
+    assert_no_unfinished_jobs
+
+    # Only the first 2 jobs did something
+    assert_stored_sequence(@result, [ "1" ])
+    assert_stored_sequence(another_result, [ "2" ])
+  end
+
+  test "discard on conflict and release semaphore" do
+    DiscardableUpdateResultJob.perform_later(@result, name: "1", pause: 0.1)
+    # will be discarded
+    DiscardableUpdateResultJob.perform_later(@result, name: "2")
+
+    wait_for_jobs_to_finish_for(5.seconds)
+    assert_no_unfinished_jobs
+
+    # Enqueue another job that shouldn't be discarded or blocked
+    DiscardableUpdateResultJob.perform_later(@result, name: "3")
+    wait_for_jobs_to_finish_for(5.seconds)
+    assert_no_unfinished_jobs
+
+    assert_stored_sequence(@result, [ "1", "3" ])
+  end
+
   private
     def assert_stored_sequence(result, *sequences)
       expected = sequences.map { |sequence| "seq: " + sequence.map { |name| "s#{name}c#{name}" }.join }

test/dummy/app/jobs/limited_discard_job.rb

@@ -10,11 +10,11 @@ def perform(job_result)
     end
   end
 
-  class DiscardedNonOverlappingJob < NonOverlappingJob
+  class DiscardableNonOverlappingJob < NonOverlappingJob
     limits_concurrency key: ->(job_result, **) { job_result }, on_conflict: :discard
   end
 
-  class DiscardedOverlappingJob < NonOverlappingJob
+  class DiscardableThrottledJob < NonOverlappingJob
     limits_concurrency to: 2, key: ->(job_result, **) { job_result }, on_conflict: :discard
   end
 
@@ -26,11 +26,11 @@ class NonOverlappingGroupedJob2 < NonOverlappingJob
     limits_concurrency key: ->(job_result, **) { job_result }, group: "MyGroup"
   end
 
-  class DiscardedNonOverlappingGroupedJob1 < NonOverlappingJob
+  class DiscardableNonOverlappingGroupedJob1 < NonOverlappingJob
     limits_concurrency key: ->(job_result, **) { job_result }, group: "DiscardingGroup", on_conflict: :discard
   end
 
-  class DiscardedNonOverlappingGroupedJob2 < NonOverlappingJob
+  class DiscardableNonOverlappingGroupedJob2 < NonOverlappingJob
     limits_concurrency key: ->(job_result, **) { job_result }, group: "DiscardingGroup", on_conflict: :discard
   end
 
@@ -195,10 +195,10 @@ class DiscardedNonOverlappingGroupedJob2 < NonOverlappingJob
 
   test "enqueue jobs with discarding concurrency controls" do
     assert_ready do
-      active_job = DiscardedNonOverlappingJob.perform_later(@result, name: "A")
+      active_job = DiscardableNonOverlappingJob.perform_later(@result, name: "A")
       assert active_job.successfully_enqueued?
 
-      assert_not DiscardedNonOverlappingJob.perform_later(@result, name: "B") do |overlapping_active_job|
+      assert_not DiscardableNonOverlappingJob.perform_later(@result, name: "B") do |overlapping_active_job|
         assert_not overlapping_active_job.successfully_enqueued?
         assert_equal @discarded_concurrent_error, overlapping_active_job.enqueue_error
       end
@@ -207,14 +207,14 @@ class DiscardedNonOverlappingGroupedJob2 < NonOverlappingJob
 
   test "enqueue scheduled job with discarding concurrency controls" do
     assert_ready do
-      active_job = DiscardedNonOverlappingJob.perform_later(@result, name: "A")
+      active_job = DiscardableNonOverlappingJob.perform_later(@result, name: "A")
       assert active_job.successfully_enqueued?
     end
 
     scheduled_job_id = nil
 
     assert_scheduled do
-      scheduled_active_job = DiscardedNonOverlappingJob.set(wait: 0.5.seconds).perform_later(@result, name: "B")
+      scheduled_active_job = DiscardableNonOverlappingJob.set(wait: 0.5.seconds).perform_later(@result, name: "B")
       assert scheduled_active_job.successfully_enqueued?
       assert_nil scheduled_active_job.enqueue_error
 
@@ -231,8 +231,8 @@ class DiscardedNonOverlappingGroupedJob2 < NonOverlappingJob
 
   test "enqueues jobs in bulk with discarding concurrency controls" do
     jobs = [
-      job_1 = DiscardedNonOverlappingJob.new(@result, name: "A"),
-      job_2 = DiscardedNonOverlappingJob.new(@result, name: "B")
+      job_1 = DiscardableNonOverlappingJob.new(@result, name: "A"),
+      job_2 = DiscardableNonOverlappingJob.new(@result, name: "B")
     ]
 
     assert_job_counts(ready: 1, discarded: 1) do
@@ -249,16 +249,16 @@ class DiscardedNonOverlappingGroupedJob2 < NonOverlappingJob
   test "enqueue jobs with discarding concurrency controls when below limit" do
     assert_job_counts(ready: 2) do
       assert_ready do
-        active_job = DiscardedOverlappingJob.perform_later(@result, name: "A")
+        active_job = DiscardableThrottledJob.perform_later(@result, name: "A")
         assert active_job.successfully_enqueued?
       end
 
       assert_ready do
-        active_job = DiscardedOverlappingJob.perform_later(@result, name: "B")
+        active_job = DiscardableThrottledJob.perform_later(@result, name: "B")
         assert active_job.successfully_enqueued?
       end
 
-      assert_not DiscardedOverlappingJob.perform_later(@result, name: "C") do |overlapping_active_job|
+      assert_not DiscardableThrottledJob.perform_later(@result, name: "C") do |overlapping_active_job|
         assert_not overlapping_active_job.successfully_enqueued?
         assert_equal @discarded_concurrent_error, overlapping_active_job.enqueue_error
       end
@@ -282,13 +282,13 @@ class DiscardedNonOverlappingGroupedJob2 < NonOverlappingJob
   test "enqueue jobs with discarding concurrency controls in the same concurrency group" do
     assert_job_counts(ready: 1) do
       assert_ready do
-        active_job = DiscardedNonOverlappingGroupedJob1.perform_later(@result, name: "A")
+        active_job = DiscardableNonOverlappingGroupedJob1.perform_later(@result, name: "A")
         assert active_job.successfully_enqueued?
         assert_equal 1, active_job.concurrency_limit
         assert_equal "DiscardingGroup/JobResult/#{@result.id}", active_job.concurrency_key
       end
 
-      assert_not DiscardedNonOverlappingGroupedJob2.perform_later(@result, name: "B") do |blocked_active_job|
+      assert_not DiscardableNonOverlappingGroupedJob2.perform_later(@result, name: "B") do |blocked_active_job|
         assert_not blocked_active_job.successfully_enqueued?
         assert_equal 1, blocked_active_job.concurrency_limit
         assert_equal "DiscardingGroup/JobResult/#{@result.id}", blocked_active_job.concurrency_key