gouda 0.1.3 → 0.1.5

data/test/gouda/scheduler_test.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require "gouda/test_helper"
+
+class GoudaSchedulerTest < ActiveSupport::TestCase
+  include AssertHelper
+
+  setup do
+    Gouda::Workload.delete_all
+    Gouda::JobFuse.delete_all
+  end
+
+  class TestJob < ActiveJob::Base
+    self.queue_adapter = Gouda::Adapter.new
+
+    def perform(regular = "ok", mandatory:, optional: "hidden")
+    end
+  end
+
+  class FailingJob < ActiveJob::Base
+    include Gouda::ActiveJobExtensions::Concurrency
+    self.queue_adapter = Gouda::Adapter.new
+
+    class MegaError < StandardError
+    end
+
+    retry_on StandardError, wait: :polynomially_longer, attempts: 5
+    retry_on Gouda::InterruptError, wait: 0, attempts: 5
+    retry_on MegaError, attempts: 3, wait: 0
+
+    def perform
+      raise MegaError.new "Kaboom!"
+    end
+  end
+
+  test "keeps re-enqueueing cron jobs after failed job (also with kwargs)" do
+    tab = {
+      second_minutely: {
+        cron: "*/1 * * * * *", # every second
+        class: "GoudaSchedulerTest::FailingJob"
+      }
+    }
+
+    assert_nothing_raised do
+      Gouda::Scheduler.build_scheduler_entries_list!(tab)
+      Gouda::Scheduler.upsert_workloads_from_entries_list!
+    end
+
+    assert_equal 1, Gouda::Workload.enqueued.count
+    Gouda.worker_loop(n_threads: 1, check_shutdown: Gouda::TimerShutdownCheck.new(2))
+
+    refute_empty Gouda::Workload.enqueued
+    assert Gouda::Workload.count > 3
+  end
+
+  test "retries do not have a scheduler_key" do
+    tab = {
+      second_minutely: {
+        cron: "*/1 * * * * *", # every second
+        class: "GoudaSchedulerTest::FailingJob"
+      }
+    }
+
+    assert_nothing_raised do
+      Gouda::Scheduler.build_scheduler_entries_list!(tab)
+      Gouda::Scheduler.upsert_workloads_from_entries_list!
+    end
+
+    assert_equal 1, Gouda::Workload.enqueued.count
+    assert_equal "second_minutely_*/1 * * * * *_GoudaSchedulerTest::FailingJob", Gouda::Workload.enqueued.first.scheduler_key
+    sleep(2)
+    Gouda::Workload.checkout_and_perform_one(executing_on: "Unit test")
+
+    assert_equal 1, Gouda::Workload.retried.reload.count
+    assert_nil Gouda::Workload.retried.first.scheduler_key
+    assert_equal "enqueued", Gouda::Workload.retried.first.state
+  end
+
+  test "re-inserts the next subsequent job after executing the queued one" do
+    tab = {
+      second_minutely: {
+        cron: "*/1 * * * * *", # every second
+        class: "GoudaSchedulerTest::TestJob",
+        args: ["omg"],
+        kwargs: {mandatory: "WOOHOO", optional: "yeah"},
+        set: {priority: 150}
+      }
+    }
+
+    assert_nothing_raised do
+      Gouda::Scheduler.build_scheduler_entries_list!(tab)
+    end
+
+    assert_changes_by(-> { Gouda::Workload.count }, exactly: 1) do
+      3.times do
+        Gouda::Scheduler.upsert_workloads_from_entries_list!
+      end
+    end
+
+    job = Gouda::Workload.first
+    assert_equal 1, Gouda::Workload.count
+
+    sleep 1
+
+    assert_equal job, Gouda::Workload.checkout_and_lock_one(executing_on: "test")
+
+    assert_changes_by(-> { Gouda::Workload.count }, exactly: 1) do
+      3.times do
+        Gouda::Scheduler.upsert_workloads_from_entries_list!
+      end
+    end
+
+    assert_equal 2, Gouda::Workload.count
+    Gouda::Workload.all.each(&:perform_and_update_state!)
+    assert_equal 0, Gouda::Workload.errored.count
+    workload = Gouda::Workload.find_by(scheduler_key: "second_minutely_*/1 * * * * *_GoudaSchedulerTest::TestJob")
+    assert_equal 150, workload.priority
+    assert_equal ["omg", {
+      "optional" => "yeah",
+      "mandatory" => "WOOHOO",
+      "_aj_ruby2_keywords" => ["mandatory", "optional"]
+    }], workload.serialized_params["arguments"]
+  end
+
+  test "accepts crontab with nil args" do
+    tab = {
+      first_hourly: {
+        cron: "@hourly",
+        class: "GoudaSchedulerTest::TestJob",
+        args: [nil, nil]
+      }
+    }
+
+    assert_nothing_raised do
+      Gouda::Scheduler.build_scheduler_entries_list!(tab)
+    end
+
+    assert_changes_by(-> { Gouda::Workload.count }, exactly: 1) do
+      Gouda::Scheduler.upsert_workloads_from_entries_list!
+    end
+
+    assert_equal [nil, nil], Gouda::Workload.first.serialized_params["arguments"]
+  end
+
+  test "is able to accept a crontab" do
+    tab = {
+      first_hourly: {
+        cron: "@hourly",
+        class: "GoudaSchedulerTest::TestJob",
+        args: ["one"],
+        kwargs: {mandatory: "Yeah"}
+      },
+      second_minutely: {
+        cron: "*/1 * * * *",
+        class: "GoudaSchedulerTest::TestJob",
+        args: [6],
+        kwargs: {mandatory: "Yeah", optional: "something"}
+      },
+      third_hourly_with_args_and_kwargs: {
+        cron: "@hourly",
+        class: "GoudaSchedulerTest::TestJob",
+        args: [1],
+        kwargs: {mandatory: "alright"}
+      },
+      interval: {
+        interval_seconds: 250,
+        class: "GoudaSchedulerTest::TestJob",
+        args: [4],
+        kwargs: {mandatory: "tasty"}
+      }
+    }
+    assert_nothing_raised do
+      Gouda::Scheduler.build_scheduler_entries_list!(tab)
+    end
+
+    travel_to Time.utc(2023, 6, 23, 20, 0)
+    assert_changes_by(-> { Gouda::Workload.count }, exactly: 4) do
+      3.times do
+        Gouda::Scheduler.upsert_workloads_from_entries_list!
+      end
+    end
+
+    tab[:fifth] = {
+      cron: "@hourly",
+      class: "GoudaSchedulerTest::TestJob",
+      kwargs: {mandatory: "good"}
+    }
+
+    Gouda::Scheduler.build_scheduler_entries_list!(tab)
+    assert_changes_by(-> { Gouda::Workload.count }, exactly: 1) do
+      Gouda::Scheduler.upsert_workloads_from_entries_list!
+    end
+
+    assert tab.delete(:fifth)
+    Gouda::Scheduler.build_scheduler_entries_list!(tab)
+    assert_changes_by(-> { Gouda::Workload.count }, exactly: -1) do
+      Gouda::Scheduler.upsert_workloads_from_entries_list!
+    end
+
+    Gouda::Workload.all.each(&:perform_and_update_state!)
+    assert_equal 0, Gouda::Workload.errored.count
+    assert_equal [6, {
+      "optional" => "something",
+      "mandatory" => "Yeah",
+      "_aj_ruby2_keywords" => ["mandatory", "optional"]
+    }], Gouda::Workload.find_by(scheduler_key: "second_minutely_*/1 * * * *_GoudaSchedulerTest::TestJob").serialized_params["arguments"]
+  end
+end

data/test/gouda/seconds_to_start_distribution.csv

@@ -0,0 +1,280 @@
+"count","seconds_to_execution"
+1,29146
+1,28471
+1,27796
+1,27121
+1,26446
+1,25771
+1,25096
+1,24421
+1,23746
+1,23071
+1,22396
+1,21720
+1,21045
+1,20370
+1,19695
+1,19020
+1,18345
+1,17670
+1,16995
+1,16320
+1,15645
+1,14970
+1,14295
+1,13620
+1,12945
+1,12270
+1,11595
+1,10920
+1,10245
+1,9570
+1,8895
+1,8220
+1,7545
+1,6870
+1,6195
+1,5915
+1,5752
+1,5520
+1,5438
+1,5190
+1,5114
+2,4929
+1,4845
+1,4609
+1,4489
+1,4373
+1,4170
+1,4133
+1,4106
+1,4090
+1,3956
+1,3945
+2,3834
+1,3598
+1,3495
+1,3383
+1,3377
+1,3341
+1,3302
+1,3174
+1,3139
+1,2987
+1,2869
+1,2861
+1,2820
+2,2805
+1,2328
+1,2179
+1,2145
+1,1982
+1,1947
+1,1678
+1,1673
+1,1470
+1,1459
+1,1441
+1,1318
+1,1270
+1,1170
+1,1123
+1,1079
+1,974
+1,970
+1,957
+1,893
+1,795
+1,778
+1,740
+1,478
+1,442
+1,262
+1,207
+4,197
+1,166
+1,131
+2,123
+1,122
+3,120
+2,119
+1,118
+1,117
+1,116
+1,114
+3,111
+1,110
+2,109
+1,108
+2,107
+5,106
+3,105
+3,104
+4,103
+1,102
+1,101
+1,100
+3,99
+1,98
+2,97
+2,96
+2,95
+2,94
+1,93
+1,92
+4,91
+1,90
+2,89
+2,88
+1,87
+1,86
+2,85
+3,84
+2,83
+1,82
+2,81
+1,80
+3,79
+1,78
+5,77
+1,76
+3,75
+2,74
+1,73
+3,72
+5,71
+1,70
+3,69
+4,68
+3,67
+2,66
+1,65
+3,64
+2,63
+2,62
+2,61
+1,60
+2,59
+1,58
+1,57
+3,56
+1,55
+8,54
+2,53
+2,52
+2,51
+1,50
+2,49
+2,48
+2,47
+3,46
+3,45
+4,43
+3,42
+4,41
+2,40
+4,39
+2,37
+2,35
+4,34
+2,33
+4,32
+4,31
+1,30
+2,29
+2,28
+5,27
+1,26
+1,25
+4,24
+4,23
+1,22
+3,21
+2,20
+2,19
+3,17
+2,16
+3,15
+3,13
+1,12
+2,11
+5,10
+3,9
+4,8
+4,7
+4,6
+3,5
+2,4
+3,3
+3,2
+2,1
+3,0
+2,-2
+1,-5
+2,-7
+1,-8
+3,-10
+1,-12
+3,-13
+2,-16
+1,-18
+1,-21
+2,-28
+2,-30
+2,-35
+1,-36
+3,-40
+1,-41
+1,-42
+3,-45
+1,-46
+2,-47
+1,-49
+3,-50
+2,-51
+1,-52
+2,-54
+2,-55
+1,-56
+2,-57
+2,-58
+2,-59
+2,-60
+2,-62
+5,-63
+2,-64
+3,-65
+1,-66
+2,-68
+4,-69
+2,-70
+1,-71
+3,-75
+1,-76
+1,-77
+1,-80
+1,-82
+2,-83
+2,-84
+1,-85
+1,-86
+2,-87
+1,-88
+1,-89
+2,-90
+1,-91
+2,-92
+3,-93
+1,-94
+4,-95
+1,-100
+2,-101
+2,-102
+1,-107
+1,-180
+1,-270
+2,-275
+1,-302
+2,-308
+1,-455
+1,-1129

data/test/gouda/test_helper.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "debug"
+require "active_record"
+require "active_job"
+require "active_support/test_case"
+require "minitest/autorun"
+require "minitest"
+require "support/assert_helper"
+require_relative "../../lib/gouda"
+
+class ActiveSupport::TestCase
+  SEED_DB_NAME = -> { "gouda_tests_%s" % Random.new(Minitest.seed).hex(4) }
+
+  def self.adapter
+  end
+
+  attr_reader :case_random
+
+  setup do
+    create_postgres_database_if_none
+    @adapter || Gouda::Adapter.new
+    @case_random = Random.new(Minitest.seed)
+    Gouda::Railtie.initializers.each(&:run)
+    ActiveJob::Base.logger = nil
+    Gouda.config.logger.level = 4
+  end
+
+  teardown do
+    truncate_test_tables
+  end
+
+  def create_postgres_database_if_none
+    ActiveRecord::Base.establish_connection(adapter: "postgresql", encoding: "unicode", database: SEED_DB_NAME.call)
+    ActiveRecord::Base.connection.execute("SELECT 1 FROM gouda_workloads")
+  rescue ActiveRecord::NoDatabaseError, ActiveRecord::ConnectionNotEstablished
+    create_postgres_database
+    retry
+  rescue ActiveRecord::StatementInvalid
+    ActiveRecord::Schema.define(version: 1) do |via_definer|
+      Gouda.create_tables(via_definer)
+    end
+    retry
+  end
+
+  def create_postgres_database
+    ActiveRecord::Migration.verbose = false
+    ActiveRecord::Base.establish_connection(adapter: "postgresql", database: "postgres")
+    ActiveRecord::Base.connection.create_database(SEED_DB_NAME.call, charset: :unicode)
+    ActiveRecord::Base.connection.close
+    ActiveRecord::Base.establish_connection(adapter: "postgresql", encoding: "unicode", database: SEED_DB_NAME.call)
+  end
+
+  def truncate_test_tables
+    ActiveRecord::Base.connection.execute("TRUNCATE TABLE gouda_workloads")
+    ActiveRecord::Base.connection.execute("TRUNCATE TABLE gouda_job_fuses")
+  end
+
+  def test_create_tables
+    ActiveRecord::Base.transaction do
+      ActiveRecord::Base.connection.execute("DROP TABLE gouda_workloads")
+      ActiveRecord::Base.connection.execute("DROP TABLE gouda_job_fuses")
+      # The adapter has to be in a variable as the schema definition is scoped to the migrator, not self
+      ActiveRecord::Schema.define(version: 1) do |via_definer|
+        Gouda.create_tables(via_definer)
+      end
+    end
+  end
+end

data/test/gouda/worker_test.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "gouda/test_helper"
+
+class GoudaWorkerTest < ActiveSupport::TestCase
+  include AssertHelper
+
+  # self.use_transactional_tests = false
+
+  # This is a bit obtuse but we need to be able to compute this value from inside the ActiveJob
+  # and the job won't have access to the test case object. To avoid mistakes, we can put it
+  # in a constant - which is lexically-scoped. We also evaluate it lazily since the Rails
+  # constant is possibly not initialized yet when this code loads.
+  # We need to include the PID in the path, because we might be running
+  # multiple test processes on the same box - and they might start touching
+  # files from each other.
+  PATH_TO_TEST_FILE = -> { File.expand_path(File.join("tmp", "#{Process.pid}-gouda-worker-test-output.bin")) }
+
+  class JobWithEnqueueKey < ActiveJob::Base
+    self.queue_adapter = :gouda
+
+    def enqueue_concurrency_key
+      "zombie"
+    end
+
+    def perform
+    end
+  end
+
+  class SimpleJob < ActiveJob::Base
+    self.queue_adapter = :gouda
+
+    def perform
+      File.open(PATH_TO_TEST_FILE.call, "a") do |f|
+        f.write("A")
+      end
+    end
+  end
+
+  test "runs workloads from all queues without a queue constraint" do
+    Gouda.in_bulk do
+      6.times { SimpleJob.perform_later }
+      6.times { SimpleJob.set(queue: "urgent").perform_later }
+    end
+    assert_equal 12, Gouda::Workload.where(state: "enqueued").count
+
+    Gouda.worker_loop(n_threads: 1, check_shutdown: Gouda::EmptyQueueShutdownCheck.new)
+
+    # Check that the side effects of the job have been performed - in this case, that
+    # 12 chars have been written into the file. Every job writes a char.
+    assert_equal 12, File.size(PATH_TO_TEST_FILE.call)
+
+    assert_equal 0, Gouda::Workload.where(state: "enqueued").count
+    assert_equal 12, Gouda::Workload.where(state: "finished").count
+  end
+
+  test "does not run workloads destined for a different queue" do
+    only_from_bravo = Gouda.parse_queue_constraint("queue-bravo")
+    bravo_queue_has_no_jobs = Gouda::EmptyQueueShutdownCheck.new(only_from_bravo)
+
+    Gouda.in_bulk do
+      12.times { SimpleJob.set(queue: "queue-alpha").perform_later }
+    end
+    assert_equal 12, Gouda::Workload.where(state: "enqueued").count
+
+    Gouda.worker_loop(n_threads: 1, queue_constraint: only_from_bravo, check_shutdown: bravo_queue_has_no_jobs)
+
+    assert_equal 12, Gouda::Workload.where(state: "enqueued").count
+    assert_equal 0, Gouda::Workload.where(state: "finished").count
+  end
+
+  test "reaps zombie workloads and then executes replacements" do
+    past = 10.minutes.ago
+    2.times do
+      zombie_job = JobWithEnqueueKey.new
+      Gouda::Workload.create!(
+        scheduled_at: past,
+        active_job_id: zombie_job.job_id,
+        execution_started_at: past,
+        last_execution_heartbeat_at: past,
+        queue_name: "default",
+        active_job_class_name: "GoudaWorkerTest::JobWithEnqueueKey",
+        serialized_params: {
+          job_id: zombie_job.job_id,
+          locale: "en",
+          priority: nil,
+          timezone: "UTC",
+          arguments: [],
+          job_class: zombie_job.class.to_s,
+          executions: 0,
+          queue_name: "default",
+          enqueued_at: past,
+          exception_executions: {}
+        },
+        state: "executing",
+        execution_concurrency_key: nil,
+        enqueue_concurrency_key: nil,
+        executing_on: "unit test",
+        position_in_bulk: 0
+      )
+    end
+
+    assert_equal 2, Gouda::Workload.where(state: "executing").count
+
+    Gouda.worker_loop(n_threads: 2, check_shutdown: Gouda::TimerShutdownCheck.new(2.0))
+
+    assert_equal 0, Gouda::Workload.where(state: "enqueued").count
+    assert_equal 0, Gouda::Workload.where(state: "executing").count
+
+    # The original 2 workloads got zombie-reaped and marked "finished".
+    # There should have been only 1 workload enqueued as a retry, because due to
+    # the enqueue concurrency key there would only be 1 allowed into the queue. It
+    # then should have executed normally and marked "finished".
+    assert_equal 3, Gouda::Workload.where(state: "finished").count
+  end
+end