wayfarer 0.4.6 → 0.4.7

data/spec/base_spec.rb

@@ -3,222 +3,202 @@
 require "spec_helpers"
 
 describe Wayfarer::Base, redis: true do
-  include Wayfarer::Redis::Connection
+  let(:task) { build(:task, :redis_pool) }
 
-  let(:url) { "https://example.com" }
-  let(:batch) { "batch" }
-  let(:task) { build(:task, batch: batch, url: url) }
-  let(:klass) { Class.new(Wayfarer::Base) }
-
-  before { stub_const("DummyJob", klass) }
+  before do
+    stub_const("DummyJob", Class.new(ActiveJob::Base).include(Wayfarer::Base))
+  end
 
   describe "::crawl" do
     it "enqueues a task" do
       expect(DummyJob).to receive(:perform_later).with(task)
-      DummyJob.crawl(url, batch: batch)
+      DummyJob.crawl(task.url, batch: task.batch)
     end
 
     it "returns a task" do
-      expect(DummyJob.crawl(url)).to be_a(Wayfarer::Task)
+      expect(DummyJob.crawl(task.url)).to be_a(Wayfarer::Task)
     end
   end
 
-  describe "Callbacks" do
-    let(:counter) { task.counter }
+  describe "#perform" do
+    subject(:counter) { Wayfarer::Redis::Counter.new(task) }
+    let!(:initial) { counter.increment }
 
-    describe "after enqueue" do
-      it "increments the counter" do
-        expect {
-          DummyJob.crawl(url, batch: batch)
-        }.to change { counter.value }.by(1)
+    before do
+      DummyJob.class_eval do
+        route.to :index
       end
     end
 
-    describe "after perform" do
-      it "decrements the counter" do
-        DummyJob.crawl(url, batch: batch)
-        task.counter.increment
-        expect { perform_enqueued_jobs }.to change { task.counter.value }.by(-1)
+    describe "succeeding job" do
+      before do
+        DummyJob.class_eval do
+          def index; end
+        end
       end
 
-      context "when counter reaches 0" do
-        it "resets the barrier" do
-          DummyJob.crawl(url, batch: batch)
-          perform_enqueued_jobs
-          redis do |conn|
-            expect(conn.exists?(task.barrier.redis_key)).to be(false)
-          end
-        end
+      specify do
+        expect_any_instance_of(Wayfarer::Redis::Counter)
+          .to receive(:increment).at_least(:once).and_call_original
 
-        it "resets the counter" do
-          DummyJob.crawl(url, batch: batch)
+        expect {
+          DummyJob.perform_later(task)
           perform_enqueued_jobs
-          redis do |conn|
-            expect(conn.exists?(task.counter.redis_key)).to be(false)
-          end
-        end
-
-        it "runs after batch callbacks" do
-          expect { |spy|
-            klass.after_batch(&spy)
-            DummyJob.crawl(url, batch: batch)
-            perform_enqueued_jobs
-          }.to yield_control
-        end
+          assert_performed_jobs 1
+          expect(enqueued_jobs).to be_empty
+        }.not_to change { counter.value }.from(initial)
       end
     end
-  end
-
-  describe "Unhandled exceptions" do
-    let(:klass) { Class.new(Wayfarer::Base) }
-
-    before do
-      allow_any_instance_of(DummyJob).to receive(:perform).and_raise(RuntimeError.new)
-    end
 
-    it "does not retry the job" do
-      DummyJob.crawl(url, batch: batch)
-
-      expect {
-        begin
-          perform_enqueued_jobs
-        rescue StandardError
-          nil
+    describe "failing job" do
+      before do
+        DummyJob.class_eval do
+          def index
+            raise
+          end
         end
-      }.to change { enqueued_jobs.size }.by(-1)
-    end
+      end
 
-    it "decrements the counter" do
-      3.times { task.counter.increment }
+      specify do
+        expect_any_instance_of(Wayfarer::Redis::Counter)
+          .to receive(:increment).at_least(:once).and_call_original
 
-      DummyJob.crawl(url, batch: batch)
-      begin
-        perform_enqueued_jobs
-      rescue StandardError
-        nil
+        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)
       end
-
-      expect(task.counter.value).to be(3)
     end
-  end
 
-  describe "Retries" do
-    let(:klass) do
-      Class.new(Wayfarer::Base) do
-        retry_on RuntimeError, attempts: 3 do |job, error|
-          Spy.call(job, error)
+    describe "failing job with retries" do
+      before do
+        DummyJob.class_eval do
+          retry_on StandardError, attempts: 3
+
+          def index
+            raise
+          end
         end
       end
-    end
 
-    before do
-      allow_any_instance_of(DummyJob).to receive(:perform) do |job|
-        task = job.arguments.first
-        task.metadata.job = job
+      specify do
+        expect_any_instance_of(Wayfarer::Redis::Counter)
+          .to receive(:increment).at_least(:once).and_call_original
 
-        raise RuntimeError
+        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)
       end
-
-      stub_const("Spy", spy)
     end
 
-    it "retries the job" do
-      expect(Spy).to receive(:call).exactly(:once)
-                                   .with(kind_of(DummyJob),
-                                         kind_of(RuntimeError))
+    describe "discarded after retries" do
+      before do
+        DummyJob.class_eval do
+          ErrorA = Class.new(StandardError)
+          ErrorB = Class.new(StandardError)
 
-      DummyJob.crawl(url, batch: batch)
+          retry_on ErrorA, attempts: 5
 
-      expect {
-        perform_enqueued_jobs
-      }.to change { enqueued_jobs.last["executions"] }.by(1)
+          discard_on ErrorB
 
-      expect {
-        perform_enqueued_jobs
-      }.to change { enqueued_jobs.last["executions"] }.by(1)
+          def index
+            raise ErrorB if executions == 5
 
-      expect {
-        perform_enqueued_jobs
-      }.to change { enqueued_jobs.size }.by(-1)
-    end
-
-    it "marks the URL seen" do
-      task.counter.increment # otherwise barrier gets reset
-      DummyJob.crawl(url, batch: batch)
-      3.times { perform_enqueued_jobs }
-      expect(task.barrier.seen?(task.url)).to be(true)
-    end
-
-    it "decrements the counter" do
-      3.times { task.counter.increment }
+            raise ErrorA
+          end
+        end
+      end
 
-      DummyJob.crawl(url, batch: batch)
-      3.times { perform_enqueued_jobs }
+      specify do
+        expect_any_instance_of(Wayfarer::Redis::Counter)
+          .to receive(:increment).at_least(:once).and_call_original
 
-      expect(task.counter.value).to be(3)
+        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)
+      end
     end
 
-    it "runs after batch callbacks" do
-      expect { |spy|
-        klass.after_batch(&spy)
-        DummyJob.crawl(url, batch: batch)
-        3.times { perform_enqueued_jobs }
-      }.to yield_control
-    end
-  end
+    describe "discarded job" do
+      before do
+        DummyJob.class_eval do
+          discard_on RuntimeError
 
-  describe "Discarding" do
-    let(:klass) do
-      Class.new(Wayfarer::Base) do
-        discard_on RuntimeError do |job, error|
-          Spy.call(job, error)
+          def index
+            raise "boom"
+          end
         end
       end
-    end
 
-    before do
-      allow_any_instance_of(DummyJob).to receive(:perform) do |job|
-        task = job.arguments.first
-        task.metadata.job = job
+      specify do
+        expect_any_instance_of(Wayfarer::Redis::Counter)
+          .to receive(:increment).at_least(:once).and_call_original
 
-        raise RuntimeError
+        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)
       end
-
-      stub_const("Spy", spy)
     end
 
-    it "discards the job" do
-      expect(Spy).to receive(:call).exactly(:once)
-                                   .with(kind_of(DummyJob),
-                                         kind_of(RuntimeError))
+    describe "after_batch callback" do
+      let(:initial) { counter.value }
 
-      DummyJob.crawl(url, batch: batch)
+      describe "when after_perform callback fails" do
+        before do
+          DummyJob.class_eval do
+            after_perform { raise }
 
-      expect {
-        perform_enqueued_jobs
-      }.to change { enqueued_jobs.size }.by(-1)
-    end
+            def index; end
+          end
+        end
 
-    it "marks the URL seen" do
-      task.counter.increment # otherwise barrier gets reset
-      DummyJob.crawl(url, batch: batch)
-      perform_enqueued_jobs
-      expect(task.barrier.seen?(task.url)).to be(true)
-    end
+        specify do
+          expect_any_instance_of(Wayfarer::Redis::Counter)
+            .to receive(:increment).at_least(:once).and_call_original
 
-    it "decrements the counter" do
-      3.times { task.counter.increment }
-      DummyJob.crawl(url, batch: batch)
-      perform_enqueued_jobs
-      expect(task.counter.value).to be(3)
-    end
+          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)
+        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_any_instance_of(Wayfarer::Redis::Counter)
+            .to receive(:increment).at_least(:once).and_call_original
 
-    it "runs after batch callbacks" do
-      expect { |spy|
-        klass.after_batch(&spy)
-        DummyJob.crawl(url, batch: batch)
-        perform_enqueued_jobs
-      }.to yield_control
+          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)
+        end
+      end
     end
   end
 end

data/spec/batch_completion_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::BatchCompletion, redis: true do
+  let(:task) { build(:task, :redis_pool) }
+  let(:job) { double(arguments: [task]) }
+
+  describe "::call" do
+    let(:name) { "foo" }
+
+    subject { described_class.call(name, nil, nil, nil, { job: job }) }
+
+    context "with Wayfarer job" do
+      before { job.extend(Wayfarer::Base) }
+
+      specify do
+        expect(Wayfarer::BatchCompletion)
+          .to receive(:handle).with(name, job, task, instance_of(Wayfarer::Redis::Counter))
+
+        subject
+      end
+
+      it "does not reassign Redis pool" do
+        expect { subject }.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 { subject }.to change { task[:redis_pool] }.from(nil).to(Wayfarer::Redis::Pool.instance)
+        end
+      end
+    end
+
+    context "with other job" do
+      specify do
+        expect(Wayfarer::BatchCompletion).not_to receive(:handle)
+
+        subject
+      end
+    end
+  end
+
+  describe "::handle" do
+    let(:job) do
+      double(arguments: [task],
+             executions: executions,
+             exception_executions: exception_executions)
+    end
+
+    let(:initial_exception_executions) { {} }
+    let(:exception_executions) { initial_exception_executions }
+    let(:executions) { 0 }
+    let(:counter) { Wayfarer::Redis::Counter.new(task) }
+
+    subject(:handle) { described_class.handle(event, job, task, counter) }
+
+    before { task[:initial_exception_executions] = initial_exception_executions }
+
+    context "enqueue.active_job" 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 "perform.active_job" do
+      let(:event) { "perform.active_job" }
+
+      specify do
+        expect { handle }.to change { counter.value }.by(-1)
+      end
+
+      context "with exception occurred" do
+        let(:exception_executions) { { "[RuntimeError]" => 1 } }
+
+        specify do
+          expect { handle }.not_to(change { counter.value })
+        end
+      end
+    end
+
+    context "retry_stopped.active_job" do
+      let(:event) { "retry_stopped.active_job" }
+
+      specify do
+        expect { handle }.to change { counter.value }.by(-1)
+      end
+    end
+  end
+end

data/spec/cli/job_spec.rb

@@ -2,76 +2,72 @@
 
 require "spec_helpers"
 
-describe Wayfarer::CLI::Job, cli: true, redis: true do
+describe Wayfarer::CLI, cli: true, redis: true do
   include Wayfarer::Redis
 
   let(:url) { test_app_path("/hello_world") }
   let(:batch) { "my-batch" }
-  subject(:cli) { Wayfarer::CLI::Runner }
+  subject(:cli) { Wayfarer::CLI }
 
   before do
-    write_file "app/jobs/dummy_job.rb", <<~FILE
-      class DummyJob < Wayfarer::Base
+    write_file "dummy_job.rb", <<~FILE
+      class DummyJob < ActiveJob::Base
+        include Wayfarer::Base
       end
     FILE
   end
 
-  before { Wayfarer::CLI::Base.new.send(:load_environment) }
+  before { Wayfarer::CLI.new.send(:load_environment, "dummy_job.rb") }
 
-  describe "job perform" do
+  describe "perform" do
     it "performs the worker" do
       expect_any_instance_of(DummyJob).to receive(:perform).with(kind_of(Wayfarer::Task)) do |job|
         task = job.arguments.first
-        task.metadata.job = job
+        task[:job] = job
       end
 
-      cli.start(["job", "perform", "DummyJob", url])
-    end
-
-    it "collects garbage" do
-      expect_any_instance_of(Wayfarer::GC).to receive(:run).exactly(:once)
-      cli.start(["job", "perform", "DummyJob", url])
+      cli.start(["perform", "-r", "dummy_job.rb", "DummyJob", url])
     end
 
     context "using MockRedis" do
       it "performs the worker using MockRedis" do
-        cli.start(["job", "perform", "--mock-redis", "DummyJob", url])
-        expect(Wayfarer.config.redis.factory.call(nil)).to be_a(MockRedis)
+        cli.start(["perform", "--mock-redis", "DummyJob", url])
+        expect(Wayfarer.config[:redis][:factory].call(nil)).to be_a(MockRedis)
       end
     end
   end
 
-  describe "job enqueue" do
+  describe "enqueue" do
     it "enqueues the job" do
       expect(DummyJob).to receive(:crawl).with(Addressable::URI.parse(url), batch: kind_of(String))
-      cli.start(["job", "enqueue", "DummyJob", url])
+      cli.start(["enqueue", "DummyJob", url])
     end
 
     context "with batch provided" do
       it "enqueues the job" do
         expect(DummyJob).to receive(:crawl).with(Addressable::URI.parse(url), batch: batch)
-        cli.start(["job", "enqueue", "--batch", batch, "DummyJob", url])
+        cli.start(["enqueue", "--batch", batch, "DummyJob", url])
       end
     end
   end
 
-  describe "job execute" do
+  describe "execute" do
     it "executes the job" do
       expect(DummyJob).to receive(:crawl).with(Addressable::URI.parse(url), batch: kind_of(String))
-      cli.start(["job", "execute", "DummyJob", url])
+      cli.start(["execute", "DummyJob", url])
     end
 
     context "with batch provided" do
       it "enqueues the job" do
         expect(DummyJob).to receive(:crawl).with(Addressable::URI.parse(url), batch: batch)
-        cli.start(["job", "execute", "--batch", batch, "DummyJob", url])
+        cli.start(["execute", "--batch", batch, "DummyJob", url])
       end
     end
 
     context "using MockRedis" do
       it "performs the worker using MockRedis" do
-        cli.start(["job", "execute", "--mock-redis", "DummyJob", url])
-        expect(Wayfarer.config.redis.factory.call(nil)).to be_a(MockRedis)
+        cli.start(["execute", "--mock-redis", "DummyJob", url])
+        expect(Wayfarer.config[:redis][:factory].call(nil)).to be_a(MockRedis)
       end
     end
   end

data/spec/cli/routing_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::CLI, cli: true do
+  before { write_file("dummy_job.rb", contents) }
+
+  let(:contents) do
+    <<~RUBY
+      class DummyJob < ActiveJob::Base
+        include Wayfarer::Base
+
+        #{routes}
+      end
+    RUBY
+  end
+
+  describe "route" do
+    let(:routes) do
+      <<~RUBY
+        route.host #{test_app_host.inspect}, to: :index
+      RUBY
+    end
+
+    subject(:route) { described_class.start(["route", "-r", "dummy_job.rb", "DummyJob", url]) }
+
+    context "with matching URL" do
+      let(:url) { "http://#{test_app_host}" }
+
+      specify do
+        expect { route }.to output("Match => :index\n").to_stdout
+      end
+    end
+
+    context "with mismatching URL" do
+      let(:url) { "http://example.com" }
+
+      specify do
+        expect { route }.to output("Mismatch\n").to_stdout
+      end
+    end
+  end
+
+  describe "tree" do
+    subject(:tree) { described_class.start(["tree", "-r", "dummy_job.rb", "DummyJob", url]) }
+
+    context "without child routes" do
+      let(:url) { "http://#{test_app_host}" }
+      let(:routes) { "" }
+
+      specify do
+        expect { tree }.to output("Mismatch\n").to_stdout
+      end
+    end
+
+    context "symbol target" do
+      let(:url) { "http://#{test_app_host}" }
+      let(:routes) do
+        <<~RUBY
+          route.host #{test_app_host.inspect}, to: :index
+        RUBY
+      end
+
+      let(:expected_output) do
+        <<~OUTPUT
+          Match(:index)
+          └──Host("#{test_app_host}", match: true)
+             └──Target(match: true)
+        OUTPUT
+      end
+
+      specify do
+        expect { tree }.to output(expected_output).to_stdout
+      end
+    end
+
+    context "symbol target with params" do
+      let(:url) { "http://#{test_app_host}/barqux" }
+      let(:routes) do
+        <<~RUBY
+          route.host #{test_app_host.inspect}, to: :index do
+            path ":foobar"
+          end
+        RUBY
+      end
+
+      let(:expected_output) do
+        <<~OUTPUT
+          Match(:index, params: {:foobar=>"barqux"})
+          └──Host("#{test_app_host}", match: true)
+             └──Target(match: true)
+                └──Path("/:foobar", match: true, params: {:foobar=>"barqux"})
+        OUTPUT
+      end
+
+      specify do
+        expect { tree }.to output(expected_output).to_stdout
+      end
+    end
+  end
+end

data/spec/cli/version_spec.rb

@@ -2,7 +2,7 @@
 
 require "spec_helpers"
 
-describe Wayfarer::CLI::Runner, cli: true do
+describe Wayfarer::CLI, cli: true do
   describe "version" do
     it "prints the version" do
       expect {