wayfarer 0.4.0 → 0.4.1

data/spec/middleware/fetch_spec.rb

@@ -3,11 +3,16 @@
 require "spec_helpers"
 
 describe Wayfarer::Middleware::Fetch do
+  let(:klass) { Class.new(Wayfarer::Base) }
+  let(:job) { klass.new }
   let(:task) { build(:task) }
-  let(:adapter) { spy }
+  let(:agent) { spy }
   subject(:fetch) { Wayfarer::Middleware::Fetch.new }
 
-  before { allow(fetch.pool).to receive(:with).and_yield(adapter) }
+  before do
+    task.job = job
+    allow(fetch.pool).to receive(:with).and_yield(agent)
+  end
 
   describe "#call" do
     it "assigns the task" do
@@ -16,27 +21,34 @@ describe Wayfarer::Middleware::Fetch do
       }.to change { fetch.task }.to(task)
     end
 
-    it "assigns the adapter" do
+    it "assigns the agent" do
       expect {
         fetch.call(task)
-      }.to change { task.metadata.adapter }.to(adapter)
+      }.to change { task.metadata.agent }.to(agent)
     end
 
     it "retrieves the page" do
-      expect(adapter).to receive(:fetch).with(task.url)
+      expect(agent).to receive(:fetch).with(task.url)
       fetch.call(task)
     end
 
+    it "runs callbacks" do
+      expect { |spy|
+        klass.before_fetch(&spy)
+        fetch.call(task)
+      }.to yield_control
+    end
+
     context "when encountering an HTTP redirect" do
       let(:redirect_url) { "https://redirect.com" }
 
       let(:result) do
-        Wayfarer::Networking::Result::Redirect.new(task.url, redirect_url)
+        Wayfarer::Networking::Result::Redirect.new(redirect_url)
       end
 
       before do
         task.metadata.staged_urls = Set.new
-        allow(adapter).to receive(:fetch).with(task.url).and_return(result)
+        allow(agent).to receive(:fetch).with(task.url).and_return(result)
       end
 
       it "stages the redirect URL" do
@@ -55,7 +67,7 @@ describe Wayfarer::Middleware::Fetch do
       let(:result) { Wayfarer::Networking::Result::Success.new(page) }
 
       before do
-        allow(adapter).to receive(:fetch).with(task.url).and_return(result)
+        allow(agent).to receive(:fetch).with(task.url).and_return(result)
       end
 
       it "assigns the page" do

data/spec/middleware/router_spec.rb

@@ -27,6 +27,13 @@ describe Wayfarer::Middleware::Router do
         expect(task.metadata.action).to be(:index)
         expect(task.metadata.params).to eq({})
       end
+
+      describe "params" do
+        it "is a HashWithIndifferentAccess" do
+          router.call(task)
+          expect(task.metadata.params).to be_a(ActiveSupport::HashWithIndifferentAccess)
+        end
+      end
     end
 
     context "when URL does not match a route" do

data/spec/middleware/worker_spec.rb

@@ -5,8 +5,6 @@ require "spec_helpers"
 describe Wayfarer::Middleware::Worker do
   let(:task) { build(:task) }
 
-  before { task.metadata.action = :index }
-
   let(:job) do
     Class.new(Wayfarer::Base) do
       def index
@@ -15,6 +13,11 @@ describe Wayfarer::Middleware::Worker do
     end
   end
 
+  before do
+    task.metadata.action = :index
+    allow_any_instance_of(job).to receive(:arguments).and_return([task])
+  end
+
   describe "::route" do
     it "returns a route" do
       expect(job.route).to be_a(Wayfarer::Routing::Route)
@@ -22,11 +25,6 @@ describe Wayfarer::Middleware::Worker do
   end
 
   describe "#call" do
-    it "assigns the task" do
-      worker = job.new
-      expect { worker.call(task) }.to change { worker.task }.to(task)
-    end
-
     it "calls the action method" do
       worker = job.new
       expect(worker).to receive(:index)
@@ -41,7 +39,7 @@ describe Wayfarer::Middleware::Worker do
   describe "#chain" do
     it "returns its middleware chain" do
       worker = job.new
-      expect(worker.chain.middlewares).to eq([*Wayfarer.core_middleware, worker])
+      expect(worker.chain.middlewares).to eq([*Wayfarer.middleware, worker])
     end
   end
 
@@ -53,37 +51,76 @@ describe Wayfarer::Middleware::Worker do
     end
   end
 
-  describe "#page" do
-    let(:page) { Object.new }
-    let(:worker) { job.new }
+  describe "#params" do
+    it "delegates to task metadata" do
+      worker = job.new
+      expect(worker.task.metadata).to receive(:params)
+      worker.params
+    end
+  end
 
-    before do
-      task.metadata.page = page
-      worker.task = task
+  describe "#agent" do
+    it "delegates to task metadata" do
+      worker = job.new
+      expect(worker.task.metadata).to receive(:agent)
+      worker.agent
     end
+  end
+
+  describe "#browser" do
+    it "returns the context's instance" do
+      worker = job.new
+      context = spy
+      expect(worker.task.metadata).to receive(:agent).and_return(context)
+      expect(context).to receive(:instance)
+      worker.browser
+    end
+  end
+
+  describe "#page" do
+    let(:worker) { job.new }
+    let(:page) { Object.new }
 
     it "returns the page" do
+      task.metadata.page = page
       expect(worker.page).to be(page)
     end
 
     context "with live keyword" do
-      let(:adapter) { spy }
-      let(:body) { "foobar" }
-      let(:live) { Object.new }
+      let(:agent) { spy }
+      let(:result) { Wayfarer::Networking::Result::Success.new(page) }
 
-      before do
-        task.metadata.adapter = adapter
-        allow(adapter).to receive(:live).with(page).and_return(live)
-      end
+      before { task.metadata.agent = agent }
+
+      context "when agent returns Result" do
+        before { allow(agent).to receive(:live).and_return(result) }
+
+        it "returns the page" do
+          expect(worker.page(live: true)).to be(page)
+        end
 
-      it "returns a live page" do
-        expect(worker.page(live: true)).to be(live)
+        it "replaces the existing page" do
+          expect {
+            worker.page(live: true)
+          }.to change { task.metadata.page }.to(page)
+        end
       end
 
-      it "replaces the existing page" do
-        expect {
-          worker.page(live: true)
-        }.to change { task.metadata.page }.to(live)
+      context "when agent returns nil" do
+        before do
+          task.metadata.page = page
+          allow(agent).to receive(:live).and_return(nil)
+        end
+
+        it "returns the existing page" do
+          expect(worker.page(live: true)).to be(page)
+        end
+
+        it "does not replace the existing page" do
+          expect {
+            worker.page(live: true)
+          }.not_to(change { task.metadata.page })
+        end
       end
     end
   end

data/spec/networking/capybara_spec.rb

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

data/spec/networking/context_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+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) }
+
+  before do
+    allow(strategy).to receive(:renew_on).and_return([renewing_error])
+    allow(strategy).to receive(:create).and_return(instance)
+  end
+
+  describe "#new" do
+    it "assigns the strategy" do
+      expect(context.strategy).to be(strategy)
+    end
+
+    it "assigns the instance" do
+      expect(context.strategy).to be(strategy)
+    end
+  end
+
+  describe "#fetch" do
+    let(:url) { Object.new }
+
+    it "fetches" do
+      expect(strategy).to receive(:fetch).with(instance, url)
+      context.fetch(url)
+    end
+
+    context "with renewing exception raised" 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)
+      end
+    end
+
+    context "with non-renewing exception raised" do
+      before do
+        allow(strategy).to receive(:fetch).and_raise(StandardError)
+      end
+
+      it "reraises" do
+        expect(context).not_to receive(:renew)
+
+        expect {
+          context.fetch(url)
+        }.to raise_error(StandardError)
+      end
+    end
+  end
+
+  describe "#live" do
+    let(:page) { Object.new }
+
+    it "calls live" do
+      expect(strategy).to receive(:live).with(instance)
+      context.live
+    end
+
+    context "with renewing exception raised" 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)
+      end
+
+      context "when renewing raises" do
+        let(:other_error) { Class.new(StandardError) }
+
+        before do
+          allow(context).to receive(:renew).and_raise(other_error)
+        end
+
+        it "reraises the original exception" do
+          expect {
+            context.live
+          }.to raise_error(renewing_error)
+        end
+      end
+    end
+
+    context "with non-renewing exception raised" do
+      before do
+        allow(strategy).to receive(:live).and_raise(StandardError)
+      end
+
+      it "reraises" do
+        expect(context).not_to receive(:renew)
+
+        expect {
+          context.live(page)
+        }.to raise_error(StandardError)
+      end
+    end
+  end
+
+  describe "#renew" do
+    it "destroys" do
+      expect(strategy).to receive(:destroy).with(instance)
+      context.renew
+    end
+  end
+
+  describe "#instance" do
+    it "creates an instance" do
+      expect(strategy).to receive(:create).and_return(instance)
+      expect(context.instance).to be(instance)
+    end
+  end
+end

data/spec/networking/ferrum_spec.rb

@@ -1,28 +1,12 @@
 # frozen_string_literal: true
 
 require "spec_helpers"
-require_relative "adapter"
+require_relative "strategy"
 
 describe Wayfarer::Networking::Ferrum, ferrum: true do
-  subject(:adapter) { Wayfarer::Networking::Ferrum.new }
-
-  after { adapter.free }
-
-  include_examples "Network adapter", browser: true,
-                                      capybara: true,
-                                      request_headers: true
-
-  describe "#fetch" do
-    it "sets the status code" do
-      url = test_app_path("/status_code/418")
-      page = adapter.fetch(url).page
-      expect(page.status_code).to be(418)
-    end
-
-    it "sets response headers" do
-      url = test_app_path("/hello_world")
-      page = adapter.fetch(url).page
-      expect(page.headers["hello"]).to eq("world")
-    end
-  end
+  include_examples "Network strategy", strategy: described_class,
+                                       browser: true,
+                                       request_headers: true,
+                                       response_headers: true,
+                                       status_code: true
 end

data/spec/networking/http_spec.rb

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

data/spec/networking/pool_spec.rb

@@ -9,34 +9,59 @@ describe Wayfarer::Networking::Pool do
 
   describe "#with" do
     context "by default" do
-      it "yields NetHTTP" do
-        pool.with do |adapter|
-          expect(adapter).to be_a(Wayfarer::Networking::Healer)
-          expect(adapter.adapter).to be_a(Wayfarer::Networking::NetHTTP)
+      it "yields HTTP" do
+        pool.with do |context|
+          expect(context.strategy).to be_a(Wayfarer::Networking::HTTP)
         end
       end
     end
 
     context "when using Ferrum", ferrum: true do
-      before { Wayfarer.config.adapter = :ferrum }
+      before { Wayfarer.config.network.agent = :ferrum }
 
       it "yields Ferrum" do
-        pool.with do |adapter|
-          expect(adapter).to be_a(Wayfarer::Networking::Healer)
-          expect(adapter.adapter).to be_a(Wayfarer::Networking::Ferrum)
+        pool.with do |context|
+          expect(context.strategy).to be_a(Wayfarer::Networking::Ferrum)
         end
       end
     end
 
     context "when using Selenium", selenium: true do
-      before { Wayfarer.config.adapter = :selenium }
+      before { Wayfarer.config.network.agent = :selenium }
 
       it "yields Selenium" do
-        pool.with do |adapter|
-          expect(adapter).to be_a(Wayfarer::Networking::Healer)
-          expect(adapter.adapter).to be_a(Wayfarer::Networking::Selenium)
+        pool.with do |context|
+          expect(context.strategy).to be_a(Wayfarer::Networking::Selenium)
         end
       end
     end
+
+    context "when using Capybara", ferrum: true do
+      before do
+        Wayfarer.config.network.agent = :capybara
+        Wayfarer.config.capybara.driver = :cuprite
+      end
+
+      it "yields Capybara" do
+        pool.with do |context|
+          expect(context.strategy).to be_a(Wayfarer::Networking::Capybara)
+        end
+      end
+    end
+  end
+
+  describe "#free" do
+    let(:strategy) { double(create: spy) }
+
+    before do
+      pool.class.registry[:foobar] = double(new: strategy)
+      Wayfarer.config.network.agent = :foobar
+    end
+
+    it "destroys the strategy" do
+      expect(strategy).to receive(:destroy)
+      pool.with {}
+      pool.free
+    end
   end
 end

data/spec/networking/selenium_spec.rb

@@ -1,28 +1,12 @@
 # frozen_string_literal: true
 
 require "spec_helpers"
-require_relative "adapter"
+require_relative "strategy"
 
 describe Wayfarer::Networking::Selenium, selenium: true do
-  subject(:adapter) { Wayfarer::Networking::Selenium.new }
-
-  after { adapter.free }
-
-  include_examples "Network adapter", browser: true,
-                                      capybara: true,
-                                      request_headers: false
-
-  describe "#fetch" do
-    it "sets a fake status code" do
-      url = test_app_path("/status_code/404")
-      page = adapter.fetch(url).page
-      expect(page.status_code).to be(Wayfarer::Networking::Selenium::FAKE_STATUS_CODE)
-    end
-
-    it "sets fake response headers" do
-      url = test_app_path("/hello_world")
-      page = adapter.fetch(url).page
-      expect(page.headers).to eq(Wayfarer::Networking::Selenium::FAKE_RESPONSE_HEADERS)
-    end
-  end
+  include_examples "Network strategy", strategy: described_class,
+                                       browser: true,
+                                       request_headers: false,
+                                       response_headers: false,
+                                       status_code: false
 end

data/spec/networking/strategy.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+RSpec.shared_examples "Network strategy" do |options|
+  attr_accessor :context
+
+  before(:all) do
+    self.context = Wayfarer::Networking::Context.new(options[:strategy].new)
+  end
+
+  after(:all) do
+    context.renew
+  end
+
+  describe "#renew_on" do
+    it "returns an Array" do
+      expect(context.strategy.renew_on).to be_an(Array)
+    end
+  end
+
+  describe "Context" do
+    describe "#fetch" do
+      it "returns Success" do
+        url = test_app_path("/hello_world")
+        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")
+      end
+
+      it "sets the response body" do
+        url = test_app_path("/hello_world")
+        page = context.fetch(url).page
+        expect(page.body).to match(/Hello world!/)
+      end
+
+      it "sets the status code" do
+        skip unless options[:status_code]
+
+        url = test_app_path("/status_code/418")
+        page = context.fetch(url).page
+        expect(page.status_code).to be(418)
+      end
+
+      it "sets response headers" do
+        skip unless options[:response_headers]
+
+        url = test_app_path("/hello_world")
+        page = context.fetch(url).page
+        expect(page.headers["hello"]).to eq("world")
+      end
+
+      context "Selenium" do
+        before { skip unless context.strategy.is_a?(Wayfarer::Networking::Selenium) }
+
+        it "sets a mock status code" do
+          skip if options[:status_code]
+
+          url = test_app_path("/status_code/418")
+          page = context.fetch(url).page
+          expect(page.status_code).to be(options[:strategy]::MOCK_STATUS_CODE)
+        end
+
+        it "sets mock response headers" do
+          url = test_app_path("/hello_world")
+          page = context.fetch(url).page
+          expect(page.headers).to eq(options[:strategy]::MOCK_RESPONSE_HEADERS)
+        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]
+
+          url = test_app_path("/redirect?times=3")
+          result = context.fetch(url)
+          expect(result).to be_a(Wayfarer::Networking::Result::Redirect)
+          expect(result.redirect_url).to eq test_app_path("/redirect?times=2")
+        end
+      end
+    end
+
+    describe "#live" do
+      context "when automating a browser" do
+        let(:url) { test_app_path("/body/foobar") }
+
+        before do
+          skip unless options[:browser]
+
+          context.fetch(test_app_path("/hello_world"))
+          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/)
+        end
+
+        it "sets response headers" do
+          skip unless options[:response_headers]
+
+          expect(page.headers["content-length"]).to eq("6")
+        end
+
+        it "sets the status code" do
+          skip unless options[:status_code]
+
+          expect(page.status_code).to be(200)
+        end
+      end
+
+      context "when using plain HTTP" do
+        it "returns nil" do
+          skip if options[:browser]
+
+          expect(context.live).to be(nil)
+        end
+      end
+    end
+
+    describe "#renew" do
+      it "replaces the instance", foo: true 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)
+      end
+    end
+  end
+end

data/spec/redis/pool_spec.rb

@@ -8,7 +8,7 @@ describe Wayfarer::Redis::Pool, redis: true do
 
   describe "::with" do
     before do
-      Wayfarer.config.redis_factory = -> { conn }
+      Wayfarer.config.redis.factory = ->(_) { conn }
     end
 
     it "instantiates the factory and yields" do