async_experiments 0.0.1 → 0.1.0

data/spec/candidate_worker_spec.rb

@@ -1,12 +1,22 @@
 require "spec_helper"
 require "async_experiments/candidate_worker"
-require "async_experiments/experiment_result_worker"
+require "async_experiments/experiment_result_candidate_worker"
 
 RSpec.describe AsyncExperiments::CandidateWorker do
   let(:name) { "some_experiment" }
   let(:id) { SecureRandom.uuid }
+  let(:candidate_expiry) { 5 }
+  let(:results_expiry) { 60 }
+  let(:arguments) do
+    {
+      name: name,
+      id: id,
+      candidate_expiry: candidate_expiry,
+      results_expiry: results_expiry,
+    }
+  end
 
-  let(:run_output) { [{some: "output"}] }
+  let(:run_output) { [{ some: "output" }] }
 
   class TestWorker < AsyncExperiments::CandidateWorker
     def perform(run_output, experiment_config)
@@ -29,23 +39,16 @@ RSpec.describe AsyncExperiments::CandidateWorker do
 
 
   it "returns the control run output" do
-    output = subject.perform(run_output,
-      name: name,
-      id: id,
-    )
-
+    output = subject.perform(run_output, arguments)
     expect(output).to eq(run_output)
   end
 
   describe "#experiment_candidate(experiment_config)" do
-    it "triggers an ExperimentResultWorker with the candidate output and duration" do
-      expect(AsyncExperiments::ExperimentResultWorker).to receive(:perform_async)
-        .with(name, id, run_output, instance_of(Float), :candidate)
-
-      subject.perform(run_output,
-        name: name,
-        id: id,
-      )
+    it "triggers an ExperimentResultCandidateWorker with the candidate output and duration" do
+      expect(AsyncExperiments::ExperimentResultCandidateWorker).to receive(:perform_async)
+        .with(name, id, run_output, instance_of(Float), a_kind_of(Integer))
+
+      subject.perform(run_output, arguments)
     end
 
     context "when experiment errors are being raised" do
@@ -62,10 +65,7 @@ RSpec.describe AsyncExperiments::CandidateWorker do
         allow(Time).to receive(:now).and_raise(StandardError.new("Test exception"))
 
         expect {
-          subject.perform(run_output,
-            "name" => name,
-            "id" => id,
-          )
+          subject.perform(run_output, arguments)
         }.to raise_error(Exception, "Test exception")
       end
     end
@@ -84,12 +84,9 @@ RSpec.describe AsyncExperiments::CandidateWorker do
         allow(Time).to receive(:now).and_raise(StandardError.new("Test exception"))
 
         expect(AsyncExperiments::ExperimentErrorWorker).to receive(:perform_async)
-          .with(name, instance_of(String))
+          .with(name, instance_of(String), a_kind_of(Integer))
 
-        subject.perform(run_output,
-          name: name,
-          id: id,
-        )
+        subject.perform(run_output, arguments)
       end
     end
   end

data/spec/examples.txt

@@ -1,37 +1,48 @@
-example_id                                       | status | run_time        |
------------------------------------------------- | ------ | --------------- |
-./spec/async_experiments_spec.rb[1:1:1]          | passed | 0.00062 seconds |
-./spec/candidate_worker_spec.rb[1:1]             | passed | 0.00023 seconds |
-./spec/candidate_worker_spec.rb[1:2]             | passed | 0.00053 seconds |
-./spec/candidate_worker_spec.rb[1:3:1]           | passed | 0.00069 seconds |
-./spec/candidate_worker_spec.rb[1:3:2:1]         | passed | 0.00209 seconds |
-./spec/candidate_worker_spec.rb[1:3:3:1]         | passed | 0.0008 seconds  |
-./spec/experiment_control_spec.rb[1:1:1]         | passed | 0.00089 seconds |
-./spec/experiment_control_spec.rb[1:1:2]         | passed | 0.00117 seconds |
-./spec/experiment_control_spec.rb[1:1:3]         | passed | 0.00061 seconds |
-./spec/experiment_error_worker_spec.rb[1:1]      | passed | 0.00266 seconds |
-./spec/experiment_error_worker_spec.rb[1:2]      | passed | 0.00056 seconds |
-./spec/experiment_error_worker_spec.rb[1:3]      | passed | 0.0077 seconds  |
-./spec/experiment_result_spec.rb[1:1:1]          | passed | 0.00042 seconds |
-./spec/experiment_result_spec.rb[1:2:1]          | passed | 0.00043 seconds |
-./spec/experiment_result_spec.rb[1:3:1]          | passed | 0.00071 seconds |
-./spec/experiment_result_spec.rb[1:3:2]          | passed | 0.00045 seconds |
-./spec/experiment_result_spec.rb[1:3:3:1]        | passed | 0.00055 seconds |
-./spec/experiment_result_spec.rb[1:3:3:2]        | passed | 0.00048 seconds |
-./spec/experiment_result_spec.rb[1:3:4:1]        | passed | 0.00043 seconds |
-./spec/experiment_result_spec.rb[1:3:4:2]        | passed | 0.00058 seconds |
-./spec/experiment_result_spec.rb[1:4:1:1]        | passed | 0.00037 seconds |
-./spec/experiment_result_spec.rb[1:4:2:1:1]      | passed | 0.00095 seconds |
-./spec/experiment_result_spec.rb[1:4:2:1:2]      | passed | 0.00055 seconds |
-./spec/experiment_result_spec.rb[1:4:2:2:1]      | passed | 0.0005 seconds  |
-./spec/experiment_result_worker_spec.rb[1:1]     | passed | 0.00048 seconds |
-./spec/experiment_result_worker_spec.rb[1:2:1]   | passed | 0.00175 seconds |
-./spec/experiment_result_worker_spec.rb[1:3:1:1] | passed | 0.0013 seconds  |
-./spec/experiment_result_worker_spec.rb[1:3:2:1] | passed | 0.00235 seconds |
-./spec/experiment_result_worker_spec.rb[1:3:2:2] | passed | 0.0025 seconds  |
-./spec/util_spec.rb[1:1:1]                       | passed | 0.00021 seconds |
-./spec/util_spec.rb[1:2:1]                       | passed | 0.00016 seconds |
-./spec/util_spec.rb[1:3:1]                       | passed | 0.00014 seconds |
-./spec/util_spec.rb[1:3:2]                       | passed | 0.00016 seconds |
-./spec/util_spec.rb[1:3:3]                       | passed | 0.00012 seconds |
-./spec/util_spec.rb[1:3:4]                       | passed | 0.00011 seconds |
+example_id                                               | status | run_time        |
+-------------------------------------------------------- | ------ | --------------- |
+./spec/async_experiments_spec.rb[1:1:1]                  | passed | 0.00074 seconds |
+./spec/async_experiments_spec.rb[1:2:1]                  | passed | 0.00066 seconds |
+./spec/async_experiments_spec.rb[1:3:1:1]                | passed | 0.00059 seconds |
+./spec/async_experiments_spec.rb[1:3:2:1]                | passed | 0.00069 seconds |
+./spec/async_experiments_spec.rb[1:3:3:1]                | passed | 0.00076 seconds |
+./spec/candidate_worker_spec.rb[1:1]                     | passed | 0.00034 seconds |
+./spec/candidate_worker_spec.rb[1:2]                     | passed | 0.00076 seconds |
+./spec/candidate_worker_spec.rb[1:3:1]                   | passed | 0.00093 seconds |
+./spec/candidate_worker_spec.rb[1:3:2:1]                 | passed | 0.00204 seconds |
+./spec/candidate_worker_spec.rb[1:3:3:1]                 | passed | 0.00128 seconds |
+./spec/experiment_control_spec.rb[1:1:1]                 | passed | 0.00098 seconds |
+./spec/experiment_control_spec.rb[1:1:2]                 | passed | 0.0089 seconds  |
+./spec/experiment_control_spec.rb[1:1:3]                 | passed | 0.00131 seconds |
+./spec/experiment_error_worker_spec.rb[1:1]              | passed | 0.00054 seconds |
+./spec/experiment_error_worker_spec.rb[1:2]              | passed | 0.00057 seconds |
+./spec/experiment_error_worker_spec.rb[1:3:1]            | passed | 0.00064 seconds |
+./spec/experiment_error_worker_spec.rb[1:4:1]            | passed | 0.00069 seconds |
+./spec/experiment_error_worker_spec.rb[1:5]              | passed | 0.00071 seconds |
+./spec/experiment_result_candidate_worker_spec.rb[1:1]   | passed | 0.00059 seconds |
+./spec/experiment_result_candidate_worker_spec.rb[1:2]   | passed | 0.00142 seconds |
+./spec/experiment_result_control_worker_spec.rb[1:1]     | passed | 0.00119 seconds |
+./spec/experiment_result_control_worker_spec.rb[1:2:1]   | passed | 0.00128 seconds |
+./spec/experiment_result_control_worker_spec.rb[1:3:1]   | passed | 0.0022 seconds  |
+./spec/experiment_result_control_worker_spec.rb[1:3:2]   | passed | 0.00238 seconds |
+./spec/experiment_result_control_worker_spec.rb[1:3:3:1] | passed | 0.00213 seconds |
+./spec/experiment_result_spec.rb[1:1:1]                  | passed | 0.00062 seconds |
+./spec/experiment_result_spec.rb[1:1:2]                  | passed | 0.00058 seconds |
+./spec/experiment_result_spec.rb[1:2:1]                  | passed | 0.00431 seconds |
+./spec/experiment_result_spec.rb[1:2:2]                  | passed | 0.00067 seconds |
+./spec/experiment_result_spec.rb[1:2:3:1]                | passed | 0.00056 seconds |
+./spec/experiment_result_spec.rb[1:2:3:2:1]              | passed | 0.00063 seconds |
+./spec/experiment_result_spec.rb[1:2:3:3:1]              | passed | 0.00069 seconds |
+./spec/experiment_result_spec.rb[1:2:3:4]                | passed | 0.00059 seconds |
+./spec/experiment_result_spec.rb[1:2:4:1]                | passed | 0.00053 seconds |
+./spec/experiment_result_spec.rb[1:2:4:2]                | passed | 0.0006 seconds  |
+./spec/experiment_result_spec.rb[1:2:4:3]                | passed | 0.0005 seconds  |
+./spec/experiment_result_spec.rb[1:3:1:1:1]              | passed | 0.00069 seconds |
+./spec/experiment_result_spec.rb[1:3:1:2:1]              | passed | 0.00052 seconds |
+./spec/experiment_result_spec.rb[1:3:2:1]                | passed | 0.0004 seconds  |
+./spec/experiment_result_spec.rb[1:3:3:1]                | passed | 0.0011 seconds  |
+./spec/util_spec.rb[1:1:1]                               | passed | 0.00013 seconds |
+./spec/util_spec.rb[1:2:1]                               | passed | 0.00024 seconds |
+./spec/util_spec.rb[1:3:1]                               | passed | 0.00018 seconds |
+./spec/util_spec.rb[1:3:2]                               | passed | 0.00017 seconds |
+./spec/util_spec.rb[1:3:3]                               | passed | 0.00009 seconds |
+./spec/util_spec.rb[1:3:4]                               | passed | 0.00032 seconds |

data/spec/experiment_control_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 require "async_experiments/experiment_control"
-require "async_experiments/experiment_result_worker"
+require "async_experiments/experiment_result_control_worker"
 
 RSpec.describe AsyncExperiments::ExperimentControl do
   let(:name) { :some_experiment }
@@ -15,7 +15,7 @@ RSpec.describe AsyncExperiments::ExperimentControl do
     }
   }
 
-  let(:run_output) { [{some: "output"}] }
+  let(:run_output) { [{ some: "output" }] }
 
   class TestClass
     include AsyncExperiments::ExperimentControl
@@ -34,10 +34,10 @@ RSpec.describe AsyncExperiments::ExperimentControl do
     allow(SecureRandom).to receive(:uuid).and_return(id)
   end
 
-  describe "#experiment_control(name, candidate: candidate_config)" do
-    it "triggers an ExperimentResultWorker with the control output and duration" do
-      expect(AsyncExperiments::ExperimentResultWorker).to receive(:perform_async)
-        .with(name, id, run_output, instance_of(Float), :control)
+  describe "#experiment_control" do
+    it "triggers an ExperimentResultControlWorker with the control output and duration" do
+      expect(AsyncExperiments::ExperimentResultControlWorker).to receive(:perform_in)
+        .with(1, name, id, run_output, instance_of(Float), a_kind_of(Integer))
 
       subject.call(name, run_output, candidate_config)
     end
@@ -47,6 +47,8 @@ RSpec.describe AsyncExperiments::ExperimentControl do
         .with(*candidate_args,
           name: name,
           id: id,
+          candidate_expiry: a_kind_of(Integer),
+          results_expiry: a_kind_of(Integer),
         )
 
       subject.call(name, run_output, candidate_config)

data/spec/experiment_error_worker_spec.rb

@@ -5,9 +5,10 @@ require "async_experiments/experiment_error_worker"
 RSpec.describe AsyncExperiments::ExperimentErrorWorker do
   let(:name) { "some_experiment" }
   let(:error) { "Something went wrong" }
+  let(:expiry) { 30 }
 
   let(:statsd) { double(:statsd, increment: nil) }
-  let(:redis) { double(:redis, rpush: nil) }
+  let(:redis) { double(:redis, set: nil, exists: false, expire: nil) }
 
   subject { described_class.new }
 
@@ -20,17 +21,37 @@ RSpec.describe AsyncExperiments::ExperimentErrorWorker do
     Sidekiq::Testing.fake! do
       described_class.perform_async
 
-      expect(described_class.jobs.size).to eq(1)
+      expect(Sidekiq::Queues["experiments"].size).to eq(1)
     end
   end
 
   it "increments the statsd error count for the experiment" do
     expect(statsd).to receive(:increment).with("experiments.#{name}.exceptions")
-    subject.perform(name, error)
+    subject.perform(name, error, expiry)
   end
 
-  it "stores the exception for later reporting" do
-    expect(redis).to receive(:rpush).with("experiments:#{name}:exceptions", error)
-    subject.perform(name, error)
+  context "when redis already has the exception stored" do
+    before { allow(redis).to receive(:exists).and_return(true) }
+
+    it "does not store the exception" do
+      expect(redis).not_to receive(:set)
+      subject.perform(name, error, expiry)
+    end
+  end
+
+  context "when redis does not have the exception stored" do
+    before { allow(redis).to receive(:exists).and_return(false) }
+
+    it "stores the exception" do
+      expect(redis).to receive(:set)
+        .with(/^experiments:#{Regexp.quote(name)}:exceptions:/, error)
+      subject.perform(name, error, expiry)
+    end
+  end
+
+  it "sets an expiry time" do
+    expect(redis).to receive(:expire)
+      .with(/^experiments:#{Regexp.quote(name)}:exceptions:/, expiry)
+    subject.perform(name, error, expiry)
   end
 end

data/spec/experiment_result_candidate_worker_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+require "async_experiments"
+require "async_experiments/experiment_result"
+require "async_experiments/experiment_result_candidate_worker"
+
+RSpec.describe AsyncExperiments::ExperimentResultCandidateWorker do
+  let(:name) { "some_experiment" }
+  let(:id) { SecureRandom.uuid }
+
+  let(:statsd) { double(:statsd) }
+  let(:redis) { double(:redis) }
+  let(:redis_key) { double(:redis_key) }
+
+  let(:candidate_output) { "candidate output" }
+  let(:candidate_duration) { 5.0 }
+
+  let(:candidate) {
+    double(:candidate,
+      candidate?: true,
+      control?: false,
+      key: redis_key,
+    )
+  }
+  let(:expiry) { 10 }
+
+  subject { described_class.new }
+
+  before do
+    allow(Sidekiq).to receive(:redis).and_yield(redis)
+    AsyncExperiments.statsd = statsd
+  end
+
+  it "uses the 'experiments' queue" do
+    Sidekiq::Testing.fake! do
+      described_class.perform_async
+
+      expect(Sidekiq::Queues["experiments"].size).to eq(1)
+    end
+  end
+
+  it "stores the run output and duration" do
+    allow(AsyncExperiments::ExperimentResult).to receive(:new)
+      .with(name, id, :candidate, redis, statsd, candidate_output, candidate_duration)
+      .and_return(candidate)
+
+    expect(candidate).to receive(:store_run_output).with(expiry)
+
+    subject.perform(name, id, candidate_output, candidate_duration, expiry)
+  end
+end

data/spec/experiment_result_control_worker_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+require "async_experiments"
+require "async_experiments/experiment_result"
+require "async_experiments/experiment_result_control_worker"
+
+RSpec.describe AsyncExperiments::ExperimentResultControlWorker do
+  let(:name) { "some_experiment" }
+  let(:id) { SecureRandom.uuid }
+
+  let(:statsd) { double(:statsd) }
+  let(:redis) { double(:redis) }
+  let(:redis_key) { double(:redis_key) }
+
+  let(:control_output) { "control output" }
+  let(:control_duration) { 10.0 }
+
+  let(:candidate_output) { "candidate output" }
+  let(:candidate_duration) { 5.0 }
+  let(:allowed_attempts) { 5 }
+
+  let(:expiry) { 30 }
+
+  let(:control) {
+    double(:control,
+      control?: true,
+      candidate?: false,
+      key: redis_key,
+    )
+  }
+  let(:candidate) {
+    double(:candidate,
+      candidate?: true,
+      control?: false,
+      key: redis_key,
+    )
+  }
+
+  subject { described_class.new }
+
+  before do
+    allow(Sidekiq).to receive(:redis).and_yield(redis)
+    AsyncExperiments.statsd = statsd
+    allow(AsyncExperiments::ExperimentResult).to receive(:new)
+      .with(name, id, :control, redis, statsd, control_output, control_duration)
+      .and_return(control)
+
+    allow(AsyncExperiments::ExperimentResult).to receive(:new)
+      .with(name, id, :candidate, redis, statsd)
+      .and_return(candidate)
+  end
+
+  it "uses the 'experiments' queue" do
+    Sidekiq::Testing.fake! do
+      described_class.perform_async
+
+      expect(Sidekiq::Queues["experiments"].size).to eq(1)
+    end
+  end
+
+  context "when the candidate is available" do
+    before do
+      allow(candidate).to receive(:available?).and_return(true)
+    end
+
+    it "processes the run output with the candidate" do
+      expect(control).to receive(:process_run_output).with(candidate, expiry)
+      subject.perform(name, id, control_output, control_duration, expiry)
+    end
+  end
+
+  context "when the candidate is unavailable" do
+    before do
+      allow(candidate).to receive(:available?).and_return(false)
+      allow(described_class).to receive(:perform_in)
+    end
+
+    it "does not process the run output" do
+      expect(control).not_to receive(:process_run_output)
+      subject.perform(name, id, control_output, control_duration, expiry)
+    end
+
+    it "schedules the job to run again later" do
+      args = [name, id, control_output, control_duration, expiry, allowed_attempts]
+      expect(described_class).to receive(:perform_in).with(5, *args, 2)
+      subject.perform(*args)
+    end
+
+    context "and it has completed it's allowed jobs" do
+      it "does not schedule the job for later" do
+        args = [name, id, control_output, control_duration, expiry, allowed_attempts, allowed_attempts]
+        expect(described_class).to_not receive(:perform_in)
+        subject.perform(*args)
+      end
+    end
+  end
+end

data/spec/experiment_result_spec.rb

@@ -2,135 +2,153 @@ require "spec_helper"
 require "async_experiments/experiment_result"
 
 RSpec.describe AsyncExperiments::ExperimentResult do
+  let(:name) { :test_name }
   let(:id) { SecureRandom.uuid }
-  let(:name) { :test_experiment }
-
-  let(:control_run_output) { "control output" }
-  let(:control_duration) { 10.0 }
-
-  let(:candidate_run_output) { "candidate output" }
-  let(:candidate_duration) { 5.0 }
-
-  let(:redis) { double(:redis, del: nil) }
-  let(:statsd) { double(:statsd, timing: nil, increment: nil) }
-
-  let(:control) { described_class.new(name, id, :control, redis, statsd, control_run_output, control_duration) }
-  let(:candidate) { described_class.new(name, id, :candidate, redis, statsd, candidate_run_output, candidate_duration) }
-
-  describe "#key" do
-    it "builds a key from the name and ID" do
-      expect(control.key).to eq("test_experiment:#{id}")
-    end
+  let(:type) { :control }
+  let(:output) { "output" }
+  let(:duration) { 1.0 }
+  let(:redis_key) { "experiments:#{name}:#{id}:#{type}" }
+  let(:statsd) do
+    double(
+      :statsd,
+      timing: nil,
+      increment: nil,
+    )
   end
+  let(:redis) do
+    double(
+      :redis,
+      set: true,
+      expire: true,
+      del: true,
+      exists: false,
+    )
+  end
+
+  subject { described_class.new(name, id, type, redis, statsd, output, duration) }
 
   describe "#store_run_output" do
-    it "stores the branch's run output and duration" do
+    let(:expiry) { 10 }
+    after { subject.store_run_output(expiry) }
+
+    it "sets item in redis" do
       expect(redis).to receive(:set)
-        .with("experiments:#{name}:#{id}:candidate", {
-          run_output: candidate_run_output,
-          duration: candidate_duration,
-        }.to_json)
+        .with(redis_key, { run_output: output, duration: duration }.to_json)
+    end
 
-      candidate.store_run_output
+    it "sets an expiry on the redis entry" do
+      expect(redis).to receive(:expire)
+        .with(redis_key, expiry)
     end
   end
 
-  describe "control#process_run_output(candidate)" do
-    before do
-      allow(redis).to receive(:rpush)
+  describe "#process_run_output" do
+    let(:candidate_key) { "experiments:#{name}:#{id}:candidate" }
+    let(:candidate_duration) { 5.0 }
+    let(:candidate_output) { "different" }
+    let(:candidate) do
+      double(
+        :candidate,
+        run_output: candidate_output,
+        duration: candidate_duration,
+      )
     end
+    let(:expiry) { 30 }
+    after { subject.process_run_output(candidate, expiry) }
 
-    it "reports the control and candidate durations to statsd" do
+    it "stores the durations with statsd" do
       expect(statsd).to receive(:timing)
-        .with("experiments.#{name}.control", control_duration)
-
+        .with("experiments.#{name}.control", duration)
       expect(statsd).to receive(:timing)
         .with("experiments.#{name}.candidate", candidate_duration)
+    end
 
-      control.process_run_output(candidate)
+    it "deletes candidate data" do
+      expect(redis).to receive(:del).with(candidate_key)
     end
 
-    it "deletes the candidate data from redis" do
-      expect(redis).to receive(:del).with("experiments:#{name}:#{id}:candidate")
+    context "when candidate data is different to control data" do
+      let(:candidate_output) { "different" }
 
-      control.process_run_output(candidate)
-    end
+      it "increments mismatch count with statsd" do
+        expect(statsd).to receive(:increment).with("experiments.#{name}.mismatches")
+      end
 
-    context "if there's variation between the outputs" do
-      it "increments the mismatch count in statsd" do
-        expect(statsd).to receive(:increment)
-          .with("experiments.#{name}.mismatches")
+      context "and the the data is already in redis" do
+        before { allow(redis).to receive(:exists).and_return(true) }
 
-        control.process_run_output(candidate)
+        it "doesn't add the difference to redis" do
+          expect(redis).not_to receive(:set)
+        end
       end
 
-      it "logs the mismatch to redis" do
-        expect(redis).to receive(:rpush).with(
-          "experiments:#{name}:mismatches",
-          [["~", "", "control output", "candidate output"]].to_json,
-        )
+      context "but the data is already in redis" do
+        before { allow(redis).to receive(:exists).and_return(false) }
+
+        it "adds the difference to redis" do
+          expect(redis).to receive(:set)
+            .with(/^experiments:#{Regexp.quote(name)}:mismatches:/, a_kind_of(String))
+        end
+      end
 
-        control.process_run_output(candidate)
+      it "sets the expiry in redis" do
+        expect(redis).to receive(:expire)
+          .with(/^experiments:#{Regexp.quote(name)}:mismatches:/, expiry)
       end
     end
 
-    context "if there's no variation" do
-      let(:candidate_run_output) { control_run_output }
+    context "when candidate data is the same as control data" do
+      let(:candidate_output) { output }
 
-      it "does not increment the mismatch count" do
+      it "doesn't increment a mismatch with statsd" do
         expect(statsd).not_to receive(:increment)
-        control.process_run_output(candidate)
       end
 
-      it "does not log the mismatch to redis" do
+      it "doesn't add a difference to redis" do
         expect(redis).not_to receive(:rpush)
-        control.process_run_output(candidate)
+      end
+
+      it "doesn't update mismatch result expiry" do
+        expect(redis).not_to receive(:expire)
       end
     end
   end
 
-  describe ".new" do
-    let(:type) { :candidate }
+  describe "#available?" do
+    subject { described_class.new(name, id, type, redis, statsd, output, duration).available? }
 
-    context "if duration and output are provided" do
-      it "uses those" do
-        candidate = described_class.new(name, id, type, redis, statsd, "arbitrary output", 1.23)
-        expect(candidate.run_output).to eq("arbitrary output")
-        expect(candidate.duration).to eq(1.23)
+    context "when instance is initialised with output and duration as nil" do
+      let(:output) { nil }
+      let(:duration) { nil }
+      before do
+        allow(redis).to receive(:get)
+          .and_return(redis_data.nil? ? nil : JSON.dump(redis_data))
       end
-    end
 
-    context "if duration and output are not provided" do
       context "and redis has the data" do
-        before do
-          allow(redis).to receive(:get).with("experiments:#{name}:#{id}:#{type}").and_return({
-            run_output: candidate_run_output,
-            duration: candidate_duration,
-          }.to_json)
-        end
-
-        it "uses the redis data" do
-          candidate = described_class.new(name, id, type, redis, statsd)
-          expect(candidate.run_output).to eq(candidate_run_output)
-          expect(candidate.duration).to eq(candidate_duration)
-        end
+        let(:redis_data) { { run_output: "output", duration: 1.0 } }
 
-        it "is considered available" do
-          candidate = described_class.new(name, id, type, redis, statsd)
-          expect(candidate.available?).to eq(true)
-        end
+        it { is_expected.to be true }
       end
 
-      context "but redis does not have the data" do
-        before do
-          allow(redis).to receive(:get).and_return("")
-        end
+      context "but redis doesn't have the data" do
+        let(:redis_data) { nil }
 
-        it "is considered unavailable" do
-          missing_candidate = described_class.new(name, id, type, redis, statsd)
-          expect(missing_candidate.available?).to eq(false)
-        end
+        it { is_expected.to be false }
       end
     end
+
+    context "when instance is initialised with output and duration as values" do
+      let(:output) { "output" }
+      let(:duration) { 1.0 }
+      it { is_expected.to be true }
+    end
+
+    context "when run_output is nil and duration is provided" do
+      let(:output) { nil }
+      let(:duration) { 1.0 }
+
+      it { is_expected.to be true }
+    end
   end
 end