wayfarer 0.4.7 → 0.4.8

data/spec/{networking → wayfarer/networking}/context_spec.rb

@@ -3,62 +3,69 @@
 require "spec_helpers"
 
 describe Wayfarer::Networking::Context do
-  let(:instance) { Object.new }
-  let(:strategy) { spy }
-  let(:renewing_error) { Class.new(StandardError) }
-  subject(:context) { Wayfarer::Networking::Context.new(strategy) }
+  subject(:context) { described_class.new(strategy) }
 
-  before do
-    allow(strategy).to receive(:renew_on).and_return([renewing_error])
-    allow(strategy).to receive(:create).and_return(instance)
+  let(:instance) { Object.new }
+  let(:strategy) do
+    double( # rubocop:disable RSpec/VerifiedDoubles
+      create: instance,
+      destroy: nil,
+      renew_on: [renewing_error],
+      fetch: nil,
+      live: nil
+    )
   end
 
-  describe "#new" do
-    it "assigns the strategy" do
-      expect(context.strategy).to be(strategy)
-    end
+  let(:renewing_error) { Class.new(StandardError) }
 
-    it "assigns the instance" do
-      expect(context.strategy).to be(strategy)
-    end
+  before do
+    allow(strategy).to receive(:destroy)
   end
 
   describe "#fetch" do
     let(:url) { Object.new }
 
-    it "fetches" do
-      expect(strategy).to receive(:fetch).with(instance, url)
+    specify do
       context.fetch(url)
+
+      expect(strategy).to have_received(:fetch).with(instance, url)
     end
 
-    context "with renewing exception raised" do
+    context "with renewing exception" do
       before do
         allow(strategy).to receive(:fetch).and_raise(renewing_error)
       end
 
       it "renews and reraises" do
-        expect(context).to receive(:renew)
-
         expect {
           context.fetch(url)
         }.to raise_error(renewing_error)
+
+        expect(strategy).to have_received(:destroy).with(instance)
       end
     end
 
-    context "with configured renewing exception raised" do
+    context "with renewing exception raised" do
       let(:other_error) { Class.new(StandardError) }
 
-      before do
+      around do |example|
+        original_renew_on = Wayfarer.config[:network][:renew_on]
         Wayfarer.config[:network][:renew_on] = [other_error]
+        example.run
+        Wayfarer.config[:network][:renew_on] = original_renew_on
+      end
+
+      before do
+        allow(strategy).to receive(:renew_on).and_return([renewing_error, other_error])
         allow(strategy).to receive(:fetch).and_raise(other_error)
       end
 
       it "renews and reraises" do
-        expect(context).to receive(:renew)
-
         expect {
           context.fetch(url)
         }.to raise_error(other_error)
+
+        expect(strategy).to have_received(:destroy).with(instance)
       end
     end
 
@@ -67,12 +74,12 @@ describe Wayfarer::Networking::Context do
         allow(strategy).to receive(:fetch).and_raise(StandardError)
       end
 
-      it "reraises" do
-        expect(context).not_to receive(:renew)
-
+      it "reraises without renewing" do
         expect {
           context.fetch(url)
         }.to raise_error(StandardError)
+
+        expect(strategy).not_to have_received(:destroy)
       end
     end
   end
@@ -81,28 +88,29 @@ describe Wayfarer::Networking::Context do
     let(:page) { Object.new }
 
     it "calls live" do
-      expect(strategy).to receive(:live).with(instance)
       context.live
+
+      expect(strategy).to have_received(:live).with(instance)
     end
 
-    context "with renewing exception raised" do
+    context "with renewing exception" do
       before do
         allow(strategy).to receive(:live).and_raise(renewing_error)
       end
 
       it "renews and reraises" do
-        expect(context).to receive(:renew)
-
         expect {
           context.live
         }.to raise_error(renewing_error)
+
+        expect(strategy).to have_received(:destroy).with(instance)
       end
 
       context "when renewing raises" do
         let(:other_error) { Class.new(StandardError) }
 
         before do
-          allow(context).to receive(:renew).and_raise(other_error)
+          allow(strategy).to receive(:destroy).and_raise(other_error)
         end
 
         it "reraises the original exception" do
@@ -118,27 +126,27 @@ describe Wayfarer::Networking::Context do
         allow(strategy).to receive(:live).and_raise(StandardError)
       end
 
-      it "reraises" do
-        expect(context).not_to receive(:renew)
-
+      it "reraises without renewing" do
         expect {
           context.live(page)
         }.to raise_error(StandardError)
+
+        expect(strategy).not_to have_received(:destroy)
       end
     end
   end
 
   describe "#renew" do
-    it "destroys" do
-      expect(strategy).to receive(:destroy).with(instance)
+    specify do
       context.renew
+      expect(strategy).to have_received(:destroy).with(instance)
     end
   end
 
   describe "#instance" do
-    it "creates an instance" do
-      expect(strategy).to receive(:create).and_return(instance)
+    specify do
       expect(context.instance).to be(instance)
+      expect(strategy).to have_received(:create)
     end
   end
 end

data/spec/wayfarer/networking/ferrum_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+require_relative "strategy"
+
+describe Wayfarer::Networking::Ferrum, :ferrum do
+  it_behaves_like "Network strategy", strategy: described_class,
+                                      browser: true,
+                                      request_headers: true,
+                                      response_headers: true,
+                                      status_code: true,
+                                      raises_on_error_response: true
+end

data/spec/{networking → wayfarer/networking}/follow_spec.rb

@@ -3,13 +3,14 @@
 require "spec_helpers"
 
 describe Wayfarer::Networking::Follow do
+  subject(:outer) { described_class.new(inner) }
+
   let(:page) { build(:page) }
   let(:url) { test_app_path("/foo") }
   let(:redirect_url) { test_app_path("/redirect") }
   let(:success) { Wayfarer::Networking::Result::Success.new(page) }
   let(:redirect) { Wayfarer::Networking::Result::Redirect.new(redirect_url) }
   let(:inner) { spy }
-  subject(:outer) { described_class.new(inner) }
 
   describe "#fetch" do
     context "when context returns Success" do
@@ -21,10 +22,14 @@ describe Wayfarer::Networking::Follow do
     end
 
     context "when context returns Redirect" do
-      it "follows the redirect" do
-        expect(inner).to receive(:fetch).with(url).and_return(redirect).ordered
-        expect(inner).to receive(:fetch).with(redirect_url).and_return(success).ordered
+      it "follows redirect URL" do
+        allow(inner).to receive(:fetch).with(url).and_return(redirect)
+        allow(inner).to receive(:fetch).with(redirect_url).and_return(success)
+
         outer.fetch(url, follow: 2)
+
+        expect(inner).to have_received(:fetch).with(url).ordered
+        expect(inner).to have_received(:fetch).with(redirect_url).ordered
       end
     end
 

data/spec/wayfarer/networking/http_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+require_relative "strategy"
+
+describe Wayfarer::Networking::HTTP do
+  it_behaves_like "Network strategy", strategy: described_class,
+                                      browser: false,
+                                      request_headers: true,
+                                      response_headers: true,
+                                      status_code: true
+end

data/spec/{networking → wayfarer/networking}/pool_spec.rb

@@ -3,12 +3,12 @@
 require "spec_helpers"
 
 describe Wayfarer::Networking::Pool do
-  subject(:pool) { Wayfarer::Networking::Pool.send(:new) }
+  subject(:pool) { described_class.send(:new) }
 
   after { pool.free }
 
   describe "#with" do
-    context "by default" do
+    context "with default" do
       it "yields HTTP" do
         pool.with do |context|
           expect(context.strategy).to be_a(Wayfarer::Networking::HTTP)
@@ -16,7 +16,7 @@ describe Wayfarer::Networking::Pool do
       end
     end
 
-    context "when using Ferrum", ferrum: true do
+    context "when using Ferrum", :ferrum do
       before { Wayfarer.config[:network][:agent] = :ferrum }
 
       it "yields Ferrum" do
@@ -26,7 +26,7 @@ describe Wayfarer::Networking::Pool do
       end
     end
 
-    context "when using Selenium", selenium: true do
+    context "when using Selenium", :selenium do
       before { Wayfarer.config[:network][:agent] = :selenium }
 
       it "yields Selenium" do
@@ -36,7 +36,7 @@ describe Wayfarer::Networking::Pool do
       end
     end
 
-    context "when using Capybara", ferrum: true do
+    context "when using Capybara", :ferrum do
       before do
         Wayfarer.config[:network][:agent] = :capybara
         Wayfarer.config[:capybara][:driver] = :cuprite
@@ -51,17 +51,19 @@ describe Wayfarer::Networking::Pool do
   end
 
   describe "#free" do
-    let(:strategy) { double(create: spy) }
+    let(:strategy) { double(create: nil, destroy: nil) } # rubocop:disable RSpec/VerifiedDoubles
 
     before do
-      pool.class.registry[:foobar] = double(new: strategy)
+      pool.class.registry[:foobar] = double(new: strategy) # rubocop:disable RSpec/VerifiedDoubles
+      pool.class.finalizer = ->(pool) { pool.reload(&:renew) }
+
       Wayfarer.config[:network][:agent] = :foobar
     end
 
     it "destroys the strategy" do
-      expect(strategy).to receive(:destroy)
-      pool.with {}
+      pool.with {} # rubocop:disable Lint/EmptyBlock
       pool.free
+      expect(strategy).to have_received(:destroy)
     end
   end
 end

data/spec/wayfarer/networking/selenium_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+require_relative "strategy"
+
+describe Wayfarer::Networking::Selenium, :selenium do
+  it_behaves_like "Network strategy", strategy: described_class,
+                                      browser: true,
+                                      request_headers: false,
+                                      response_headers: false,
+                                      status_code: false
+end

data/spec/{networking → wayfarer/networking}/strategy.rb

@@ -5,13 +5,15 @@ require "spec_helpers"
 RSpec.shared_examples "Network strategy" do |options|
   attr_accessor :context
 
-  before(:all) do
+  # rubocop:disable RSpec/BeforeAfterAll
+  before :all do
     self.context = Wayfarer::Networking::Context.new(options[:strategy].new)
   end
 
-  after(:all) do
+  after :all do
     context.renew
   end
+  # rubocop:enable RSpec/BeforeAfterAll
 
   describe "#renew_on" do
     it "returns an Array" do
@@ -21,17 +23,21 @@ RSpec.shared_examples "Network strategy" do |options|
 
   describe "Context" do
     describe "#fetch" do
-      it "returns Success" do
-        url = test_app_path("/hello_world")
+      it "returns Success", :aggregate_failures do
+        url = test_app_path("/status/200")
         result = context.fetch(url)
         expect(result).to be_a(Wayfarer::Networking::Result::Success)
         expect(result.page).to be_a(Wayfarer::Page)
       end
 
-      it "sets the URL" do
-        url = test_app_path("/status_code/404")
-        page = context.fetch(url).page
-        expect(page.url).to eq test_app_path("/status_code/404")
+      context "with 4xx response code" do
+        skip if options[:raises_on_error_response]
+
+        it "sets the URL" do
+          url = test_app_path("hello_world")
+          page = context.fetch(url).page
+          expect(page.url).to eq test_app_path("hello_world")
+        end
       end
 
       it "sets the response body" do
@@ -40,23 +46,26 @@ RSpec.shared_examples "Network strategy" do |options|
         expect(page.body).to match(/Hello world!/)
       end
 
-      it "sets the status code" do
-        skip unless options[:status_code]
+      context "with error responses" do
+        it "sets the status code" do
+          skip unless options[:status_code]
+          skip if options[:raises_on_error_response]
 
-        url = test_app_path("/status_code/418")
-        page = context.fetch(url).page
-        expect(page.status_code).to be(418)
+          url = test_app_path("status_code/404")
+          page = context.fetch(url).page
+          expect(page.status_code).to be(404)
+        end
       end
 
       it "sets response headers" do
         skip unless options[:response_headers]
 
-        url = test_app_path("/hello_world")
+        url = test_app_path("hello_world")
         page = context.fetch(url).page
         expect(page.headers["hello"]).to eq("world")
       end
 
-      context "Selenium" do
+      context "with Selenium" do
         before { skip unless context.strategy.is_a?(Wayfarer::Networking::Selenium) }
 
         it "sets a mock status code" do
@@ -74,21 +83,6 @@ RSpec.shared_examples "Network strategy" do |options|
         end
       end
 
-      describe "HTTP headers" do
-        before do
-          Wayfarer.config[:network][:http_headers] = { "User-Agent" => "Foobar" }
-          context.renew
-        end
-
-        it "uses configured HTTP headers" do
-          skip unless options[:request_headers]
-
-          url = test_app_path("/headers/HTTP_USER_AGENT")
-          page = context.fetch(url).page
-          expect(page.body).to match(/Foobar/)
-        end
-      end
-
       context "when encountering a redirect" do
         it "returns a Redirect" do
           skip if options[:browser]
@@ -103,29 +97,29 @@ RSpec.shared_examples "Network strategy" do |options|
 
     describe "#live" do
       context "when automating a browser" do
-        let(:url) { test_app_path("/body/foobar") }
+        subject(:page) { context.live.page }
+
+        let(:url) { test_app_path("hello_world") }
 
         before do
           skip unless options[:browser]
 
-          context.fetch(test_app_path("/hello_world"))
+          context.fetch(url)
           context.strategy.navigate(context.instance, url)
         end
 
-        subject(:page) { context.live.page }
-
         it "sets the URL" do
           expect(page.url).to eq(url)
         end
 
         it "sets the response body" do
-          expect(page.body).to match(/foobar/)
+          expect(page.body).to match(/Hello world/)
         end
 
         it "sets response headers" do
           skip unless options[:response_headers]
 
-          expect(page.headers["content-length"]).to eq("6")
+          expect(page.headers["content-length"]).to eq("12")
         end
 
         it "sets the status code" do
@@ -139,31 +133,16 @@ RSpec.shared_examples "Network strategy" do |options|
         it "returns nil" do
           skip if options[:browser]
 
-          expect(context.live).to be(nil)
+          expect(context.live).to be_nil
         end
       end
     end
 
     describe "#renew" do
-      it "replaces the instance", foo: true do
+      it "replaces the instance" do
         expect {
           context.renew
-        }.to(change { context.instance })
-      end
-    end
-  end
-
-  describe "Selenium" do
-    before { skip unless context.strategy.is_a?(Wayfarer::Networking::Selenium) }
-
-    describe "Client timeout" do
-      before do
-        Wayfarer.config[:selenium][:client_timeout] = 42
-        context.renew
-      end
-
-      it "sets the client timeout" do
-        expect(context.instance.send(:bridge).send(:http).read_timeout).to be(42)
+        }.to(change(context, :instance))
       end
     end
   end

data/spec/{page_spec.rb → wayfarer/page_spec.rb}

@@ -4,10 +4,10 @@ require "spec_helpers"
 
 describe Wayfarer::Page do
   describe "#mime_type" do
-    let(:headers) { { "Content-Type" => "text/html; charset=UTF-8" } }
-
     subject { build(:page, headers: headers).mime_type }
 
+    let(:headers) { { "Content-Type" => "text/html; charset=UTF-8" } }
+
     it { is_expected.to eq("text/html") }
   end
 
@@ -15,7 +15,7 @@ describe Wayfarer::Page do
     context "when Content-Type is absent" do
       subject { build(:page, :html, headers: {}).doc }
 
-      it { is_expected.to be(nil) }
+      it { is_expected.to be_nil }
     end
 
     context "when Content-Type is HTML" do

data/spec/{parsing → wayfarer/parsing}/json_spec.rb

@@ -3,7 +3,7 @@
 require "spec_helpers"
 
 describe Wayfarer::Parsing::JSON do
-  subject(:parser) { Wayfarer::Parsing::JSON }
+  subject(:parser) { described_class }
 
   describe ".parse" do
     it "returns a Hash" do

data/spec/{parsing/xml_spec.rb → wayfarer/parsing/xml_parse_spec.rb}

@@ -3,10 +3,11 @@
 require "spec_helpers"
 
 describe Wayfarer::Parsing::XML, ".parse" do
+  subject(:doc) { described_class.parse(xml, variant) }
+
   let(:xml) { "<span>Foobar</span>" }
-  subject(:doc) { Wayfarer::Parsing::XML.parse(xml, variant) }
 
-  context "HTML" do
+  context "with HTML" do
     let(:variant) { :html }
 
     specify do
@@ -14,7 +15,7 @@ describe Wayfarer::Parsing::XML, ".parse" do
     end
   end
 
-  context "XML" do
+  context "with XML" do
     let(:variant) { :xml }
 
     specify do

data/spec/{redis → wayfarer/redis}/barrier_spec.rb

@@ -2,9 +2,10 @@
 
 require "spec_helpers"
 
-describe Wayfarer::Redis::Barrier, redis: true do
+describe Wayfarer::Redis::Barrier, :redis do
+  subject(:barrier) { build(:barrier, task: task) }
+
   let(:task) { build(:task, :redis_pool) }
-  subject(:barrier) { Wayfarer::Redis::Barrier.new(task) }
 
   describe "#redis_key" do
     it "returns the expected Redis key" do
@@ -24,13 +25,13 @@ describe Wayfarer::Redis::Barrier, redis: true do
     context "with seen URL" do
       before { barrier.check!(task.url) }
 
-      it "returns true" do
+      specify do
         expect(barrier.check!(task.url)).to be(true)
       end
     end
 
     context "with unseen URL" do
-      it "returns false" do
+      specify do
         expect(barrier.check!(task.url)).to be(false)
       end
     end

data/spec/wayfarer/redis/counter_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Redis::Counter, :redis do
+  subject(:counter) { build(:counter, task: task) }
+
+  let(:task) { build(:task, :redis_pool) }
+
+  describe "#redis_key" do
+    specify do
+      expect(counter.redis_key).to eq("wayfarer-counter-batch")
+    end
+  end
+
+  describe "#increment" do
+    specify do
+      expect { counter.increment }.to change(counter, :value).by(1)
+    end
+  end
+
+  describe "#decrement" do
+    specify do
+      expect { counter.decrement }.to change(counter, :value).by(-1)
+    end
+  end
+
+  describe "#reset!" do
+    it "resets" do
+      3.times { counter.increment }
+      expect { counter.reset! }.to change(counter, :value).to(0)
+    end
+  end
+end

data/spec/{redis → wayfarer/redis}/pool_spec.rb

@@ -2,9 +2,10 @@
 
 require "spec_helpers"
 
-describe Wayfarer::Redis::Pool, redis: true do
+describe Wayfarer::Redis::Pool, :redis do
+  subject(:pool) { described_class.send(:new) }
+
   let(:conn) { spy }
-  subject(:pool) { Wayfarer::Redis::Pool.send(:new) }
 
   describe "::with" do
     before do