Marshal runner list so ActiveJob can handle it

app/jobs/create_derivatives_job.rb

@@ -1,8 +1,9 @@
 class CreateDerivativesJob < ActiveJob::Base
   queue_as :low
 
-  def perform(id, runner)
+  def perform(id, runner_marshalled)
     asset = GenericAsset.find(id)
+    runner = Marshal.load(runner_marshalled)
     runner.run(asset)
   end
 end

lib/oregon_digital/derivatives/delayed_runner.rb

@@ -4,7 +4,9 @@ class DelayedRunner
     delegate :to_a, :to => :runner
 
     def run(asset)
-      job_factory.perform_later(asset.id, runner)
+      # Have to marshal the runner because ActiveJob doesn't, and there's no
+      # unique ID for them.
+      job_factory.perform_later(asset.id, Marshal.dump(runner))
     end
 
     class Factory

spec/jobs/create_derivatives_job_spec.rb

@@ -10,10 +10,12 @@
         id = "1"
         asset = instance_double(GenericAsset)
         allow(GenericAsset).to receive(:find).with(id).and_return(asset)
+        marshalled_runner = double("marshalled")
         runner = instance_double(OregonDigital::Derivatives::Runners::RunnerList)
         allow(runner).to receive(:run).with(asset)
+        allow(Marshal).to receive(:load).with(marshalled_runner).and_return(runner)
 
-        subject.perform_now(id, runner)
+        subject.perform_now(id, marshalled_runner)
 
         expect(runner).to have_received(:run).with(asset)
       end

spec/oregon_digital/derivatives/delayed_runner_spec.rb

@@ -10,10 +10,12 @@
     it "should run it on the job factory" do
       asset = instance_double(GenericAsset, :id => double("id"))
       allow(job_factory).to receive(:perform_later)
+      marshalled_runner = double("marshalled")
+      allow(Marshal).to receive(:dump).with(runner).and_return(marshalled_runner)
 
       subject.run(asset)
 
-      expect(job_factory).to have_received(:perform_later).with(asset.id, runner)
+      expect(job_factory).to have_received(:perform_later).with(asset.id, marshalled_runner)
     end
   end
 end