activejob-temporal 0.1.0 → 0.3.0

data/lib/activejob/temporal/transaction_safety.rb

@@ -6,14 +6,115 @@ module ActiveJob
   module Temporal
     module TransactionSafety
       module QueueAdapterSetter
+        INHERITED_TRANSACTION_SETTING_MISSING = Object.new.freeze
+
         def queue_adapter=(adapter)
+          previous_transaction_setting = enqueue_after_transaction_commit
+
           super.tap do
-            self.enqueue_after_transaction_commit = true if temporal_queue_adapter?(adapter)
+            if temporal_queue_adapter?(adapter)
+              apply_temporal_transaction_safety(previous_transaction_setting)
+            else
+              restore_temporal_transaction_safety
+            end
+          end
+        end
+
+        def enqueue_after_transaction_commit=(value)
+          super.tap do
+            next if setting_temporal_transaction_safety?
+
+            @activejob_temporal_transaction_setting_explicit = true
+            @activejob_temporal_transaction_setting_changed_after_safety = true if temporal_transaction_safety_applied?
           end
         end
 
         private
 
+        def apply_temporal_transaction_safety(previous_transaction_setting)
+          return if temporal_transaction_safety_applied?
+          return if temporal_transaction_setting_explicit?
+
+          @activejob_temporal_previous_transaction_setting =
+            transaction_setting_before_temporal_safety(previous_transaction_setting)
+          apply_enqueue_after_transaction_commit_for_temporal(true)
+          @activejob_temporal_transaction_safety_applied = true
+          @activejob_temporal_transaction_setting_changed_after_safety = false
+        end
+
+        def restore_temporal_transaction_safety
+          unless temporal_transaction_safety_applied?
+            restore_inherited_temporal_transaction_safety
+            return
+          end
+
+          unless @activejob_temporal_transaction_setting_changed_after_safety
+            apply_enqueue_after_transaction_commit_for_temporal(@activejob_temporal_previous_transaction_setting)
+          end
+
+          remove_instance_variable(:@activejob_temporal_previous_transaction_setting)
+          @activejob_temporal_transaction_safety_applied = false
+          @activejob_temporal_transaction_setting_changed_after_safety = false
+        end
+
+        def restore_inherited_temporal_transaction_safety
+          return if temporal_transaction_setting_explicit_locally?
+
+          inherited_setting = inherited_temporal_transaction_previous_setting
+          return if inherited_setting.equal?(INHERITED_TRANSACTION_SETTING_MISSING)
+
+          apply_enqueue_after_transaction_commit_for_temporal(inherited_setting)
+        end
+
+        def apply_enqueue_after_transaction_commit_for_temporal(value)
+          @activejob_temporal_setting_transaction_safety = true
+          self.enqueue_after_transaction_commit = value
+        ensure
+          @activejob_temporal_setting_transaction_safety = false
+        end
+
+        def transaction_setting_before_temporal_safety(current_setting)
+          inherited_setting = inherited_temporal_transaction_previous_setting
+          return current_setting if inherited_setting.equal?(INHERITED_TRANSACTION_SETTING_MISSING)
+
+          inherited_setting
+        end
+
+        def inherited_temporal_transaction_previous_setting
+          return INHERITED_TRANSACTION_SETTING_MISSING unless superclass.respond_to?(
+            :temporal_transaction_safety_applied?, true
+          )
+
+          if superclass.send(:temporal_transaction_safety_applied?)
+            superclass.send(:temporal_previous_transaction_setting)
+          else
+            superclass.send(:inherited_temporal_transaction_previous_setting)
+          end
+        end
+
+        def temporal_previous_transaction_setting
+          @activejob_temporal_previous_transaction_setting
+        end
+
+        def temporal_transaction_setting_explicit?
+          return true if temporal_transaction_setting_explicit_locally?
+          return false unless superclass.respond_to?(:temporal_transaction_setting_explicit?, true)
+
+          superclass.send(:temporal_transaction_setting_explicit?)
+        end
+
+        def temporal_transaction_setting_explicit_locally?
+          @activejob_temporal_transaction_setting_explicit == true
+        end
+
+        def temporal_transaction_safety_applied?
+          @activejob_temporal_transaction_safety_applied == true
+        end
+
+        def setting_temporal_transaction_safety?
+          @activejob_temporal_setting_transaction_safety == true
+        end
+
         def temporal_queue_adapter?(adapter)
           case adapter
           when Symbol, String

data/lib/activejob/temporal/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveJob
   module Temporal
-    VERSION = "0.1.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/activejob/temporal/visibility_query.rb

@@ -3,10 +3,25 @@
 module ActiveJob
   module Temporal
     module VisibilityQuery
+      SAFE_VALUE_PATTERN = /\A[A-Za-z0-9_.:-]+\z/
+
       module_function
 
+      # Quotes a value for use in a Temporal visibility list filter.
+      #
+      # Escaping alone is not enough: Temporal's list filter grammar also treats
+      # backslashes as escapes, so a value containing one can break out of the
+      # quoted literal. Values are restricted to an allowlist instead.
+      #
+      # @param value [#to_s] Value to embed in a list filter
+      # @return [String] Single-quoted literal
+      # @raise [ArgumentError] if the value contains characters outside the allowlist
       def quote(value)
-        "'#{value.to_s.gsub("'", "''")}'"
+        string_value = value.to_s
+        return "'#{string_value}'" if string_value.match?(SAFE_VALUE_PATTERN)
+
+        raise ArgumentError,
+              "visibility query values may only contain letters, numbers, underscore, hyphen, period, and colon"
       end
     end
   end

data/lib/activejob/temporal/worker_pool.rb

@@ -140,6 +140,19 @@ module ActiveJob
         end
 
         validate_public_binds!
+        validate_port_ranges!
+      end
+
+      # Each worker binds base_port + index, so overlapping ranges would make
+      # workers fight over the same port and crash-loop.
+      def validate_port_ranges!
+        return unless @health_check_port && @metrics_port
+        return unless @health_check_port < @metrics_port + @size && @metrics_port < @health_check_port + @size
+
+        raise ArgumentError,
+              "health_check_port and metrics_port ranges overlap for #{@size} workers: " \
+              "health check #{@health_check_port}-#{@health_check_port + @size - 1}, " \
+              "metrics #{@metrics_port}-#{@metrics_port + @size - 1}"
       end
 
       def positive_integer(value, name)

data/lib/activejob/temporal/worker_registrations.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "temporalio/activity"
+
+module ActiveJob
+  module Temporal
+    # Resolves which workflows and activities a worker registers, from configuration.
+    #
+    # By default a worker hosts the built-in ActiveJob workloads. `worker_activities`
+    # adds custom activity classes - for example activities invoked by workflows owned
+    # by another service, where only the activity name and JSON payloads travel over
+    # the wire. Setting `worker_activejob_workloads = false` turns the worker into an
+    # activities-only worker that hosts nothing but those custom activities.
+    module WorkerRegistrations
+      Result = Struct.new(:workflows, :activities, keyword_init: true)
+
+      class << self
+        # Configuration validation rejects the nothing-to-register combination up front
+        # (see Configuration#validate_worker_registration_settings).
+        #
+        # @param configuration [ActiveJob::Temporal::Configuration]
+        # @return [Result] workflows and activities to pass to Temporalio::Worker
+        # @raise [WorkerRegistrationError] when a worker_activities entry does not resolve
+        #   to a Temporalio::Activity::Definition subclass
+        def resolve(configuration)
+          workflows = []
+          activities = custom_activities(configuration)
+
+          if configuration.worker_activejob_workloads
+            workflows += [
+              Workflows::AjWorkflow,
+              Workflows::DeadLetterWorkflow
+            ]
+            activities += [
+              Activities::RateLimitActivity,
+              Activities::DependencyStatusActivity,
+              Activities::AjRunnerActivity
+            ]
+          end
+
+          Result.new(workflows: workflows, activities: activities)
+        end
+
+        private
+
+        def custom_activities(configuration)
+          Array(configuration.worker_activities).map { |entry| resolve_activity(entry) }
+        end
+
+        def resolve_activity(entry)
+          activity = entry.is_a?(String) ? constantize_activity(entry) : entry
+          return activity if activity.is_a?(Class) && activity < Temporalio::Activity::Definition
+
+          raise WorkerRegistrationError,
+                "worker_activities entry #{entry.inspect} is not a Temporalio::Activity::Definition subclass"
+        end
+
+        def constantize_activity(name)
+          name.constantize
+        rescue NameError
+          raise WorkerRegistrationError, "worker_activities entry #{name.inspect} does not resolve to a class"
+        end
+      end
+    end
+  end
+end

data/lib/activejob/temporal/worker_runtime.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../temporal"
+require_relative "rails_environment_loader"
+require_relative "certificate_watcher"
+require_relative "reload_signal_queue"
+require_relative "worker_client_reloader"
+require_relative "worker_pool"
+require_relative "metrics_server"
+require_relative "worker_health"
+require_relative "health_check_server"
+require_relative "workflows/aj_workflow"
+require_relative "workflows/dead_letter_workflow"
+require_relative "activities/rate_limit_activity"
+require_relative "activities/dependency_status_activity"
+require_relative "activities/aj_runner_activity"
+require_relative "worker_registrations"

data/lib/activejob/temporal/workflow_enqueuer.rb

@@ -7,6 +7,7 @@ require_relative "job_payload_builder"
 require_relative "observability"
 require_relative "workflow_enqueuer_batch"
 require_relative "workflow_id_builder"
+require_relative "workflow_types"
 
 module ActiveJob
   module Temporal
@@ -128,7 +129,7 @@ module ActiveJob
       # Starts the Temporal workflow with the given options.
       # @api private
       def start_workflow(job, payload, options)
-        workflow_class = Workflows::AjWorkflow
+        workflow_class = WorkflowTypes::ACTIVE_JOB
         handle = start_temporal_workflow(workflow_class, job, payload, options)
 
         log_enqueued(job, options, payload, duplicate: false)

data/lib/activejob/temporal/workflow_types.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Temporal
+    module WorkflowTypes
+      ACTIVE_JOB = "AjWorkflow"
+      DEAD_LETTER = "ActiveJobTemporalDeadLetterWorkflow"
+    end
+  end
+end

data/lib/activejob/temporal/workflows/aj_workflow.rb

@@ -8,6 +8,7 @@ require "temporalio/workflow"
 
 require_relative "../activities/rate_limit_activity"
 require_relative "dead_letter_support"
+require_relative "dead_letter_workflow"
 require_relative "workflow_continue_as_new"
 require_relative "workflow_child_workflows"
 require_relative "workflow_chaining"
@@ -109,7 +110,8 @@ module ActiveJob
         # @option payload [String] :job_class Fully-qualified job class name (required)
         # @option payload [String] :job_id Unique job identifier (required)
         # @option payload [String] :queue_name Target queue name (required)
-        # @option payload [Array] :arguments Serialized job arguments (required)
+        # @option payload [Hash] :active_job Full ActiveJob serialized payload
+        # @option payload [Array] :arguments Legacy serialized job arguments
         # @option payload [Hash] :default_activity_options Global activity timeout defaults (required)
         # @option payload [Hash] :retry_policy Retry policy for activity execution (required)
         # @option payload [Hash] :temporal_options Per-job timeout configuration (optional)
@@ -127,14 +129,14 @@ module ActiveJob
         #   The timer persists across worker restarts and does not block worker threads.
         #
         # @example Immediate execution
-        #   execute({ job_class: "MyJob", job_id: "123", arguments: ["arg1"] })
+        #   execute({ job_class: "MyJob", job_id: "123", active_job: { "arguments" => ["arg1"] } })
         #
         # @example Scheduled execution (non-blocking sleep)
         #   execute({
         #     job_class: "MyJob",
         #     job_id: "123",
         #     scheduled_at: "2025-10-31T12:00:00Z",
-        #     arguments: []
+        #     active_job: { "arguments" => [] }
         #   })
         #   # Workflow sleeps until scheduled time without consuming worker resources
         #
@@ -175,13 +177,24 @@ module ActiveJob
         def schedule_execution_payload(payload)
           return payload unless payload_value(payload, :schedule_id)
 
-          execution_job_id = Temporalio::Workflow.info.workflow_id
+          execution_job_id = schedule_execution_identity
           payload.merge(
             "job_id" => execution_job_id,
             "schedule_execution_job_id" => execution_job_id
           )
         end
 
+        def schedule_execution_identity
+          info = Temporalio::Workflow.info
+          run_id = if info.respond_to?(:first_execution_run_id)
+                     info.first_execution_run_id
+                   elsif info.respond_to?(:run_id)
+                     info.run_id
+                   end
+
+          [info.workflow_id, run_id].compact.join(":")
+        end
+
         # Extracts scheduled execution time from payload.
         # @api private
         def extract_scheduled_time(payload)

data/lib/activejob/temporal/workflows/workflow_dependencies.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "time"
+require "timeout"
 require "temporalio/error"
 
 require_relative "../activities/dependency_status_activity"
@@ -11,8 +13,11 @@ module ActiveJob
         DEPENDENCY_CHECK_ACTIVITY_TIMEOUT = 30.0
         DEPENDENCY_CHECK_RETRY_POLICY = Temporalio::RetryPolicy.new(max_attempts: 1)
         DEPENDENCY_WAIT_INTERVAL = 10.0
+        DEPENDENCY_WAIT_TIMEOUT = 86_400.0
+        DEPENDENCY_WAIT_MAX_INTERVAL = 60.0
+        DEPENDENCY_WAIT_BACKOFF = 2.0
         DEPENDENCY_NOT_FOUND_MAX_CHECKS = 6
-        COMPLETED_DEPENDENCY_STATES = %w[completed].freeze
+        COMPLETED_DEPENDENCY_STATES = %w[completed continued_as_new].freeze
         FAILED_DEPENDENCY_STATES = %w[failed canceled terminated timed_out unknown].freeze
         NOT_FOUND_DEPENDENCY_STATES = %w[not_found].freeze
 
@@ -23,16 +28,19 @@ module ActiveJob
           return if dependencies.empty?
 
           workflow_state["phase"] = "waiting_dependencies"
-          not_found_counts = Hash.new(0)
-          loop do
-            wait_while_paused
-            statuses = check_dependency_statuses(dependencies)
-            expired_not_found_statuses = expired_not_found_statuses(statuses, not_found_counts)
-            failed_statuses = failed_dependency_statuses(statuses) + expired_not_found_statuses
-            fail_for_dependencies!(failed_statuses) if fail_on_dependency_failure?(payload) && failed_statuses.any?
-            break if dependencies_satisfied?(statuses, expired_not_found_statuses)
-
-            Temporalio::Workflow.sleep(DEPENDENCY_WAIT_INTERVAL)
+          wait_options = dependency_wait_options(payload)
+          deadline = dependency_wait_deadline(wait_options)
+          begin
+            with_dependency_wait_timeout(wait_options, deadline) do
+              wait_for_dependency_statuses(payload, dependencies, wait_options)
+            end
+          rescue Timeout::Error
+            timed_out_statuses = dependency_timeout_statuses(dependencies)
+            if fail_on_dependency_failure?(payload)
+              fail_for_dependencies!(timed_out_statuses)
+            else
+              workflow_state.delete("dependency_wait")
+            end
           end
         end
 
@@ -50,6 +58,116 @@ module ActiveJob
           )
         end
 
+        def wait_for_dependency_statuses(payload, dependencies, wait_options)
+          not_found_counts = dependency_wait_not_found_counts
+          wait_interval = dependency_wait_current_interval(wait_options)
+          loop do
+            wait_while_paused
+            statuses = check_dependency_statuses(dependencies)
+            expired_not_found_statuses = expired_not_found_statuses(statuses, not_found_counts)
+            failed_statuses = failed_dependency_statuses(statuses) + expired_not_found_statuses
+            fail_for_dependencies!(failed_statuses) if fail_on_dependency_failure?(payload) && failed_statuses.any?
+            break if dependencies_satisfied?(statuses, expired_not_found_statuses)
+
+            persist_dependency_wait_state(not_found_counts, wait_interval)
+            continue_as_new_if_needed(payload)
+            Temporalio::Workflow.sleep(wait_interval)
+            wait_interval = next_dependency_wait_interval(wait_interval, wait_options)
+          end
+          workflow_state.delete("dependency_wait")
+        end
+
+        def with_dependency_wait_timeout(wait_options, deadline, &)
+          remaining_timeout = dependency_wait_remaining_timeout(deadline)
+          raise Timeout::Error, "dependency wait timed out" unless remaining_timeout.positive?
+
+          Temporalio::Workflow.timeout(
+            remaining_timeout,
+            Timeout::Error,
+            "dependency wait timed out after #{wait_options[:timeout]} seconds",
+            summary: "Dependency wait timeout",
+            &
+          )
+        end
+
+        def dependency_wait_options(payload)
+          configured_options = payload[:dependency_wait] || payload["dependency_wait"] || {}
+          initial_interval = positive_float_option(configured_options, :initial_interval, DEPENDENCY_WAIT_INTERVAL)
+          max_interval = positive_float_option(configured_options, :max_interval, DEPENDENCY_WAIT_MAX_INTERVAL)
+          {
+            timeout: positive_float_option(configured_options, :timeout, DEPENDENCY_WAIT_TIMEOUT),
+            initial_interval: initial_interval,
+            max_interval: [max_interval, initial_interval].max,
+            backoff: backoff_option(configured_options)
+          }
+        end
+
+        def positive_float_option(options, key, default)
+          value = options[key] || options[key.to_s]
+          return default unless value
+
+          number = Float(value)
+          number.positive? ? number : default
+        rescue ArgumentError, TypeError
+          default
+        end
+
+        def backoff_option(options)
+          value = options[:backoff] || options["backoff"]
+          return DEPENDENCY_WAIT_BACKOFF unless value
+
+          backoff = Float(value)
+          backoff >= 1.0 ? backoff : DEPENDENCY_WAIT_BACKOFF
+        rescue ArgumentError, TypeError
+          DEPENDENCY_WAIT_BACKOFF
+        end
+
+        def dependency_wait_not_found_counts
+          Hash.new(0).merge(dependency_wait_state["not_found_counts"] || {})
+        end
+
+        def dependency_wait_current_interval(wait_options)
+          current_interval = dependency_wait_state["current_interval"]
+          return wait_options[:initial_interval] unless current_interval
+
+          interval = Float(current_interval)
+          interval.positive? ? interval : wait_options[:initial_interval]
+        rescue ArgumentError, TypeError
+          wait_options[:initial_interval]
+        end
+
+        def dependency_wait_state
+          workflow_state["dependency_wait"] ||= {}
+        end
+
+        def dependency_wait_deadline(wait_options)
+          deadline_at = dependency_wait_state["deadline_at"]
+          return Time.iso8601(deadline_at) if deadline_at
+
+          persist_dependency_wait_deadline(wait_options)
+        rescue ArgumentError, TypeError
+          persist_dependency_wait_deadline(wait_options)
+        end
+
+        def persist_dependency_wait_deadline(wait_options)
+          deadline = Temporalio::Workflow.now + wait_options[:timeout]
+          dependency_wait_state["deadline_at"] = deadline.iso8601
+          deadline
+        end
+
+        def dependency_wait_remaining_timeout(deadline)
+          deadline - Temporalio::Workflow.now
+        end
+
+        def persist_dependency_wait_state(not_found_counts, wait_interval)
+          dependency_wait_state["not_found_counts"] = not_found_counts
+          dependency_wait_state["current_interval"] = wait_interval
+        end
+
+        def next_dependency_wait_interval(wait_interval, wait_options)
+          [wait_interval * wait_options[:backoff], wait_options[:max_interval]].min
+        end
+
         def dependencies_satisfied?(statuses, expired_not_found_statuses)
           expired_not_found_keys = expired_not_found_statuses.map { |status| dependency_status_key(status) }
           statuses.all? do |status|
@@ -79,16 +197,23 @@ module ActiveJob
         end
 
         def dependency_state(status)
-          status["state"] || status[:state]
+          status_value(status, :state)
         end
 
         def dependency_status_key(status)
-          job_class = status["job_class"] || status[:job_class]
-          job_id = status["job_id"] || status[:job_id]
+          job_class = status_value(status, :job_class)
+          job_id = status_value(status, :job_id)
+          workflow_id = status_value(status, :workflow_id)
+          run_id = status_value(status, :run_id)
           return "#{job_class}:#{job_id}" if job_class && job_id
           return job_id if job_id
+          return [workflow_id, run_id].compact.join(":") if workflow_id
+
+          status.hash
+        end
 
-          status["workflow_id"] || status[:workflow_id] || status.hash
+        def status_value(status, key)
+          status[key.to_s] || status[key]
         end
 
         def fail_on_dependency_failure?(payload)
@@ -109,6 +234,14 @@ module ActiveJob
             non_retryable: true
           )
         end
+
+        def dependency_timeout_statuses(dependencies)
+          dependencies.map do |dependency|
+            dependency.each_with_object({ "state" => "timed_out" }) do |(key, value), status|
+              status[key.to_s] = value
+            end
+          end
+        end
       end
     end
   end

data/lib/activejob/temporal.rb

@@ -9,17 +9,9 @@ require_relative "temporal/configurable"
 require_relative "temporal/client"
 require_relative "temporal/logger"
 require_relative "temporal/bind_policy"
-require_relative "temporal/rails_environment_loader"
 require_relative "temporal/tls_file"
-require_relative "temporal/certificate_watcher"
-require_relative "temporal/reload_signal_queue"
-require_relative "temporal/worker_client_reloader"
-require_relative "temporal/worker_pool"
 require_relative "temporal/audit_log"
-require_relative "temporal/metrics_server"
 require_relative "temporal/observability"
-require_relative "temporal/worker_health"
-require_relative "temporal/health_check_server"
 require_relative "temporal/middleware"
 require_relative "temporal/payload_serializers"
 require_relative "temporal/rate_limit_options"
@@ -36,6 +28,7 @@ require_relative "temporal/child_workflow_options"
 require_relative "temporal/chain_options"
 require_relative "temporal/dependency_options"
 require_relative "temporal/workflow_identity"
+require_relative "temporal/workflow_types"
 require_relative "temporal/job_payload_builder"
 require_relative "temporal/schedule_options"
 require_relative "temporal/conditional_enqueue"
@@ -44,17 +37,13 @@ require_relative "temporal/temporal_options"
 require_relative "temporal/schedule"
 require_relative "temporal/schedulable"
 require_relative "temporal/workflow_id_builder"
+require_relative "temporal/job_id_validation"
 require_relative "temporal/batch_enqueue_result"
 require_relative "temporal/batch_enqueuer"
 require_relative "temporal/workflow_enqueuer_batch"
 require_relative "temporal/workflow_enqueuer"
 require_relative "temporal/adapter"
 require_relative "temporal/transaction_safety"
-require_relative "temporal/workflows/aj_workflow"
-require_relative "temporal/workflows/dead_letter_workflow"
-require_relative "temporal/activities/rate_limit_activity"
-require_relative "temporal/activities/dependency_status_activity"
-require_relative "temporal/activities/aj_runner_activity"
 require_relative "temporal/cancel"
 require_relative "temporal/inspect"
 require_relative "temporal/signal_query"
@@ -110,6 +99,11 @@ module ActiveJob
     # @see Cancel.cancel
     class TemporalConnectionError < Error; end
 
+    # Raised when a worker_activities entry cannot be used as a Temporal activity.
+    #
+    # @see WorkerRegistrations.resolve
+    class WorkerRegistrationError < Error; end
+
     extend Configurable
 
     class << self
@@ -168,6 +162,20 @@ module ActiveJob
         fresh_client
       end
 
+      # Re-reads the API key (api_key or api_key_file) and applies it to the memoized
+      # client's live connection. No reconnect happens - the SDK sends the header per-RPC
+      # from the connection's stored options. Worker processes call this from the
+      # api_key_watch file watcher; a long-lived enqueue-side process using a rotating
+      # token file must call it on its own schedule (nothing watches the file there).
+      #
+      # @return [String, nil] the freshly resolved API key
+      def refresh_api_key!
+        fresh_key = Client.resolve_api_key(config)
+        client.connection.api_key = fresh_key
+        Logger.log_event("api_key_refreshed")
+        fresh_key
+      end
+
       # Cancels a running or scheduled job by job ID.
       #
       # This method requests cancellation for the Temporal workflow associated with the job.

data/test/mutant_unit_test.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "mutant/minitest/coverage"
+require_relative "../spec/spec_helper"
+
+# mutant-minitest discovers test/**/*_test.rb, while the migrated suite keeps
+# the existing spec/ split for CI and developer workflows.
+Minitest::Spec.cover "ActiveJob::Temporal::WorkflowIdBuilder#build"
+Minitest::Spec.cover "ActiveJob::Temporal::WorkflowIdBuilder.default_for"
+
+Dir[File.expand_path("../spec/unit/**/*_spec.rb", __dir__)].each do |path|
+  require path
+end