wayfarer 0.4.6 → 0.4.8

data/spec/wayfarer/base_spec.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Base, :integration, :redis do
+  let(:task) { build(:task, :redis_pool) }
+
+  before do
+    mock_job! :dummy_job
+  end
+
+  describe "::crawl" do
+    it "enqueues a task" do
+      allow(DummyJob).to receive(:perform_later)
+      DummyJob.crawl(task.url, batch: task.batch)
+      expect(DummyJob).to have_received(:perform_later).with(task)
+    end
+
+    it "returns a task" do
+      expect(DummyJob.crawl(task.url)).to be_a(Wayfarer::Task)
+    end
+  end
+
+  describe "#perform" do
+    let(:counter) { build(:counter, task: task) }
+    let!(:initial) { counter.increment }
+
+    before do
+      allow(Wayfarer::Redis::Counter).to receive(:new).and_return(counter)
+      allow(counter).to receive(:increment).and_call_original
+
+      DummyJob.class_eval do
+        route.to :index
+      end
+    end
+
+    describe "succeeding job" do
+      before do
+        DummyJob.class_eval do
+          def index; end
+        end
+      end
+
+      specify do
+        expect {
+          DummyJob.perform_later(task)
+          perform_enqueued_jobs
+          assert_performed_jobs 1
+          expect(enqueued_jobs).to be_empty
+        }.not_to change(counter, :value).from(initial)
+
+        expect(counter).to have_received(:increment).at_least(:once)
+      end
+    end
+
+    describe "failing job" do
+      before do
+        DummyJob.class_eval do
+          def index
+            raise
+          end
+        end
+      end
+
+      specify do
+        expect {
+          DummyJob.perform_later(task)
+          expect { perform_enqueued_jobs }.to raise_error(RuntimeError)
+          assert_performed_jobs 1
+          expect(enqueued_jobs).to be_empty
+        }.not_to change(counter, :value).from(initial)
+
+        expect(counter).to have_received(:increment).at_least(:once)
+      end
+    end
+
+    describe "failing job with retries" do
+      before do
+        DummyJob.class_eval do
+          retry_on StandardError, attempts: 3
+
+          def index
+            raise
+          end
+        end
+      end
+
+      specify do
+        expect {
+          DummyJob.perform_later(task)
+          2.times { perform_enqueued_jobs }
+          expect { perform_enqueued_jobs }.to raise_error(RuntimeError)
+          assert_performed_jobs 3
+          expect(enqueued_jobs).to be_empty
+        }.not_to change(counter, :value).from(initial)
+
+        expect(counter).to have_received(:increment).at_least(:once)
+      end
+    end
+
+    describe "discarded after retries" do
+      before do
+        stub_const("ErrorA", Class.new(StandardError))
+        stub_const("ErrorB", Class.new(StandardError))
+
+        DummyJob.class_eval do
+          retry_on ErrorA, attempts: 5
+          discard_on ErrorB
+
+          def index
+            raise ErrorB if executions == 5
+
+            raise ErrorA
+          end
+        end
+      end
+
+      specify do
+        expect {
+          DummyJob.perform_later(task)
+          4.times { perform_enqueued_jobs }
+          perform_enqueued_jobs
+          assert_performed_jobs 5
+          expect(enqueued_jobs).to be_empty
+        }.not_to change(counter, :value).from(initial)
+
+        expect(counter).to have_received(:increment).at_least(:once)
+      end
+    end
+
+    describe "discarded job" do
+      before do
+        DummyJob.class_eval do
+          discard_on RuntimeError
+
+          def index
+            raise "boom"
+          end
+        end
+      end
+
+      specify do
+        expect {
+          DummyJob.perform_later(task)
+          perform_enqueued_jobs
+          assert_performed_jobs 1
+          expect(enqueued_jobs).to be_empty
+        }.not_to change(counter, :value).from(initial)
+
+        expect(counter).to have_received(:increment).at_least(:once)
+      end
+    end
+
+    describe "after_batch callback" do
+      let(:initial) { counter.value }
+
+      describe "when after_perform callback fails" do
+        before do
+          DummyJob.class_eval do
+            after_perform { raise }
+
+            def index; end
+          end
+        end
+
+        specify do
+          expect {
+            DummyJob.perform_later(task)
+            expect { perform_enqueued_jobs }.to raise_error(RuntimeError)
+            assert_performed_jobs 1
+            expect(enqueued_jobs).to be_empty
+          }.not_to change(counter, :value).from(initial)
+
+          expect(counter).to have_received(:increment).at_least(:once)
+        end
+      end
+
+      describe "when after_batch callback fails" do
+        before do
+          DummyJob.class_eval do
+            after_batch { raise }
+
+            def index; end
+          end
+        end
+
+        specify do
+          expect {
+            DummyJob.perform_later(task)
+            expect { perform_enqueued_jobs }.to raise_error(RuntimeError)
+            assert_performed_jobs 1
+            expect(enqueued_jobs).to be_empty
+          }.not_to change(counter, :value).from(initial)
+
+          expect(counter).to have_received(:increment).at_least(:once)
+        end
+      end
+    end
+  end
+end

data/spec/wayfarer/batch_completion_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+# The RSpec/SpecFilePathFormat offense was not addressed as it requires renaming
+# the file, not changing its content.
+describe Wayfarer::BatchCompletion, :redis do
+  let(:task) { build(:task, :redis_pool) }
+  let(:job) { instance_spy(ActiveJob::Base, arguments: [task]) }
+
+  describe "::call" do
+    subject(:call_batch_completion) { described_class.call(name, nil, nil, nil, { job: job }) }
+
+    let(:name) { "foo" }
+
+    context "with Wayfarer job" do
+      before { job.extend(Wayfarer::Base) }
+
+      specify do
+        allow(described_class).to receive(:handle)
+
+        call_batch_completion
+
+        expect(described_class).to have_received(:handle).with(name, job, task)
+      end
+
+      it "does not reassign Redis pool" do
+        expect { call_batch_completion }.not_to change { task[:redis_pool] }.from(Wayfarer::Redis::Pool.instance)
+      end
+
+      context "without Redis pool" do
+        before do
+          task[:redis_pool] = nil
+        end
+
+        it "assigns Redis pool" do
+          expect { call_batch_completion }.to change { task[:redis_pool] }.from(nil).to(Wayfarer::Redis::Pool.instance)
+        end
+      end
+    end
+
+    context "with other job" do
+      specify do
+        allow(described_class).to receive(:handle)
+
+        call_batch_completion
+
+        expect(described_class).not_to have_received(:handle)
+      end
+    end
+  end
+
+  describe "::handle" do
+    subject(:handle) { described_class.handle(event, job, task) }
+
+    let(:job) do
+      instance_spy(ActiveJob::Base,
+                   arguments: [task],
+                   executions: executions,
+                   exception_executions: exception_executions)
+    end
+
+    let(:initial_exception_executions) { {} }
+    let(:exception_executions) { initial_exception_executions }
+    let(:executions) { 0 }
+    let(:counter) { build(:counter, task: task) }
+
+    before do
+      task[:job] = job
+      task[:initial_exception_executions] = initial_exception_executions
+    end
+
+    context "with an 'enqueue.active_job' event" do
+      let(:event) { "enqueue.active_job" }
+
+      specify do
+        expect { handle }.to change(counter, :value).by(1)
+      end
+
+      context "with retry" do
+        let(:executions) { 1 }
+
+        specify do
+          expect { handle }.not_to(change(counter, :value))
+        end
+      end
+    end
+
+    context "with a 'perform.active_job' event" do
+      let(:event) { "perform.active_job" }
+
+      context "when job succeeds" do
+        specify do
+          expect { handle }.to change(counter, :value).by(-1)
+        end
+
+        context "when batch completes" do
+          before do
+            counter.increment
+            allow(Wayfarer::GC).to receive(:run).and_call_original
+          end
+
+          specify do
+            handle
+
+            expect(job).to have_received(:run_callbacks)
+            expect(Wayfarer::GC).to have_received(:run).with(task)
+          end
+        end
+
+        context "when batch does not complete" do
+          before do
+            allow(Wayfarer::GC).to receive(:run)
+          end
+
+          specify do
+            handle
+
+            expect(job).not_to have_received(:run_callbacks)
+            expect(Wayfarer::GC).not_to have_received(:run)
+          end
+        end
+      end
+
+      context "when an exception occurrs" do
+        let(:exception_executions) { { "[RuntimeError]" => 1 } }
+
+        specify do
+          expect { handle }.not_to(change(counter, :value))
+        end
+      end
+    end
+
+    context "with a 'retry_stopped.active_job' event" do
+      let(:event) { "retry_stopped.active_job" }
+
+      specify do
+        expect { handle }.to change(counter, :value).by(-1)
+      end
+    end
+  end
+end

data/spec/wayfarer/cli/job_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe "Jobs", :cli, :integration, :redis do
+  include Wayfarer::Redis
+
+  subject(:cli) { Wayfarer::CLI }
+
+  let(:url) { test_app_path("/hello_world") }
+  let(:batch) { "my-batch" }
+
+  before do
+    mock_job! :dummy_job
+
+    write_file "dummy_job.rb", <<~FILE
+      Wayfarer::CLI.new.send(:load_environment, "dummy_job.rb")
+      class DummyJob < ActiveJob::Base
+        include Wayfarer::Base
+      end
+    FILE
+  end
+
+  describe "perform" do
+    it "performs the worker" do
+      # rubocop:disable RSpec/AnyInstance
+      # The CLI reloads DummyJob from file. #expect_any_instance_of alters the
+      # object initialization in a way that survives this class reloading.
+      expect_any_instance_of(DummyJob).to receive(:perform).with(kind_of(Wayfarer::Task)) do |job|
+        # rubocop:enable RSpec/AnyInstance
+        task = job.arguments.first
+        task[:job] = job
+      end
+
+      cli.start(["perform", "-r", "dummy_job.rb", "DummyJob", url])
+    end
+
+    context "when using MockRedis" do
+      it "performs the worker using MockRedis" do
+        cli.start(["perform", "--mock-redis", "DummyJob", url])
+        expect(Wayfarer.config[:redis][:factory].call(nil)).to be_a(MockRedis)
+      end
+    end
+  end
+
+  describe "enqueue" do
+    before do
+      allow(DummyJob).to receive(:crawl)
+    end
+
+    it "enqueues the job" do
+      cli.start(["enqueue", "DummyJob", url])
+      expect(DummyJob).to have_received(:crawl).with(Addressable::URI.parse(url), batch: kind_of(String))
+    end
+
+    context "with a batch provided" do
+      it "enqueues the job" do
+        cli.start(["enqueue", "--batch", batch, "DummyJob", url])
+        expect(DummyJob).to have_received(:crawl).with(Addressable::URI.parse(url), batch: batch)
+      end
+    end
+  end
+
+  describe "execute" do
+    before do
+      allow(DummyJob).to receive(:crawl)
+    end
+
+    it "executes the job" do
+      cli.start(["execute", "--retain-pool", "DummyJob", url])
+      expect(DummyJob).to have_received(:crawl).with(Addressable::URI.parse(url), batch: kind_of(String))
+    end
+
+    context "with a batch provided" do
+      it "executes the job" do
+        cli.start(["execute", "--retain-pool", "--batch", batch, "DummyJob", url])
+        expect(DummyJob).to have_received(:crawl).with(Addressable::URI.parse(url), batch: batch)
+      end
+    end
+
+    context "with mock Redis" do
+      it "executes the worker using MockRedis" do
+        cli.start(["execute", "--retain-pool", "--mock-redis", "DummyJob", url])
+        expect(Wayfarer.config[:redis][:factory].call(nil)).to be_a(MockRedis)
+      end
+    end
+  end
+end