wayfarer 0.4.6 → 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) }
 
+      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
-        Wayfarer.config.network.renew_on = [other_error]
+        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,28 +3,33 @@
 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
       before { allow(inner).to receive(:fetch).and_return(success) }
 
       it "returns the page" do
-        expect(outer.fetch(url)).to be(page)
+        expect(outer.fetch(url, follow: 3)).to be(page)
       end
     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
 
@@ -34,7 +39,7 @@ describe Wayfarer::Networking::Follow do
 
         expect {
           outer.fetch(url, follow: 0)
-        }.to raise_error(Wayfarer::Networking::RedirectsExhaustedError)
+        }.to raise_error(described_class::RedirectsExhaustedError)
       end
     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,8 +16,8 @@ describe Wayfarer::Networking::Pool do
       end
     end
 
-    context "when using Ferrum", ferrum: true do
-      before { Wayfarer.config.network.agent = :ferrum }
+    context "when using Ferrum", :ferrum do
+      before { Wayfarer.config[:network][:agent] = :ferrum }
 
       it "yields Ferrum" do
         pool.with do |context|
@@ -26,8 +26,8 @@ describe Wayfarer::Networking::Pool do
       end
     end
 
-    context "when using Selenium", selenium: true do
-      before { Wayfarer.config.network.agent = :selenium }
+    context "when using Selenium", :selenium do
+      before { Wayfarer.config[:network][:agent] = :selenium }
 
       it "yields Selenium" do
         pool.with do |context|
@@ -36,10 +36,10 @@ 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
+        Wayfarer.config[:network][:agent] = :capybara
+        Wayfarer.config[:capybara][:driver] = :cuprite
       end
 
       it "yields Capybara" do
@@ -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)
-      Wayfarer.config.network.agent = :foobar
+      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/wayfarer/page_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Page do
+  describe "#mime_type" do
+    subject { build(:page, headers: headers).mime_type }
+
+    let(:headers) { { "Content-Type" => "text/html; charset=UTF-8" } }
+
+    it { is_expected.to eq("text/html") }
+  end
+
+  describe "#doc" do
+    context "when Content-Type is absent" do
+      subject { build(:page, :html, headers: {}).doc }
+
+      it { is_expected.to be_nil }
+    end
+
+    context "when Content-Type is HTML" do
+      subject(:page) { build(:page, :html).doc }
+
+      it { is_expected.to be_a(Nokogiri::HTML::Document) }
+    end
+
+    context "when Content-Type is XML" do
+      subject(:page) { build(:page, :xml).doc }
+
+      it { is_expected.to be_a(Nokogiri::XML::Document) }
+    end
+
+    context "when Content-Type is JSON" do
+      subject(:page) { build(:page, :json).doc }
+
+      it { is_expected.to be_a(Hash) }
+    end
+
+    context "with Content-Type parameters" do
+      subject(:page) { build(:page, headers: { "content-type" => "text/html; charset=UTF-8" }).doc }
+
+      it { is_expected.to be_a(Nokogiri::HTML::Document) }
+    end
+
+    context "when Content-Type is unsupported" do
+      subject(:page) { build(:page, headers: { "Content-Type" => "foo/bar" }).doc }
+
+      it { is_expected.to be_nil }
+    end
+  end
+
+  describe "#headers" do
+    subject(:headers) { build(:page, headers: { "Content-Type" => "text/html" }).headers }
+
+    it "downcases keys" do
+      expect(headers).to eq("content-type" => "text/html")
+    end
+
+    it "is case-sensitive" do
+      expect(headers["Content-Type"]).to be_nil
+    end
+  end
+
+  describe "#meta" do
+    subject(:page) { build(:page).meta }
+
+    it { is_expected.to be_a(MetaInspector::Document) }
+  end
+end

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/wayfarer/parsing/xml_parse_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Parsing::XML, ".parse" do
+  subject(:doc) { described_class.parse(xml, variant) }
+
+  let(:xml) { "<span>Foobar</span>" }
+
+  context "with HTML" do
+    let(:variant) { :html }
+
+    specify do
+      expect(doc).to be_a(Nokogiri::HTML::Document)
+    end
+  end
+
+  context "with XML" do
+    let(:variant) { :xml }
+
+    specify do
+      expect(doc).to be_a(Nokogiri::XML::Document)
+    end
+  end
+end

data/spec/wayfarer/redis/barrier_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Redis::Barrier, :redis do
+  subject(:barrier) { build(:barrier, task: task) }
+
+  let(:task) { build(:task, :redis_pool) }
+
+  describe "#redis_key" do
+    it "returns the expected Redis key" do
+      expect(barrier.redis_key).to eq("wayfarer-barrier-batch")
+    end
+  end
+
+  describe "#reset!" do
+    it "resets seen URLs" do
+      barrier.check!(task.url)
+      barrier.reset!
+      expect(barrier.check!(task.url)).to be(false)
+    end
+  end
+
+  describe "#check!" do
+    context "with seen URL" do
+      before { barrier.check!(task.url) }
+
+      specify do
+        expect(barrier.check!(task.url)).to be(true)
+      end
+    end
+
+    context "with unseen URL" do
+      specify do
+        expect(barrier.check!(task.url)).to be(false)
+      end
+    end
+  end
+end