wayfarer 0.4.0 → 0.4.1

data/spec/config_spec.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Config do
-  describe "::defaults" do
-    it "returns the default config" do
-      config = Wayfarer::Config.default
-      expect(config.adapter).to be(:net_http)
-      expect(config.adapter_pool_size).to be(3)
-      expect(config.adapter_pool_timeout).to eq(ConnectionPool::DEFAULTS[:timeout])
-      expect(config.ferrum_options).to eq({})
-      expect(config.selenium_argv).to eq(%i[chrome])
-      expect(config.redis_url).to eq("redis://localhost:6379")
-      expect(config.redis_factory).not_to be(nil)
-    end
-  end
-
-  describe "::from_environment" do
-    let(:env) { {} }
-    subject(:config) { Wayfarer::Config.from_environment(env) }
-
-    describe "#adapter" do
-      context "by default" do
-        it "returns :net_http" do
-          expect(config.adapter).to be(:net_http)
-        end
-      end
-
-      context "with env var set" do
-        before { env["WAYFARER_ADAPTER"] = "ferrum" }
-
-        it "symbolizes the env var" do
-          expect(config.adapter).to be(:ferrum)
-        end
-      end
-    end
-
-    describe "#adapter_pool_size" do
-      context "by default" do
-        it "returns the default config value" do
-          expect(config.adapter_pool_size).to be(3)
-        end
-      end
-
-      context "with env var set" do
-        before { env["WAYFARER_POOL_SIZE"] = "1234" }
-
-        it "parses the env var to a number" do
-          expect(config.adapter_pool_size).to be(1234)
-        end
-      end
-    end
-
-    describe "#adapter_pool_timeout" do
-      context "by default" do
-        it "returns the default config value" do
-          expect(config.adapter_pool_timeout).to be(ConnectionPool::DEFAULTS[:timeout])
-        end
-      end
-
-      context "with env var set" do
-        let(:env) { { "WAYFARER_POOL_TIMEOUT" => "1000" } }
-
-        it "parses the env var to a number" do
-          expect(config.adapter_pool_timeout).to be(1000)
-        end
-      end
-    end
-
-    describe "#ferrum_options" do
-      context "by default" do
-        it "is empty" do
-          expect(config.ferrum_options).to eq({})
-        end
-      end
-
-      context "with env var set" do
-        before { env["WAYFARER_FERRUM_OPTIONS"] = "url:http://chrome:3000,headless:false" }
-
-        it "parses the env var to a Hash" do
-          expect(config.ferrum_options).to eq(url: "http://chrome:3000", headless: false)
-        end
-      end
-    end
-
-    describe "#selenium_argv" do
-      context "by default" do
-        it "is [:chrome]" do
-          expect(config.selenium_argv).to eq(%i[chrome])
-        end
-      end
-
-      context "with env var set" do
-        before { env["WAYFARER_SELENIUM_ARGV"] = "firefox" }
-
-        it "parses the env var to an array" do
-          expect(config.selenium_argv).to eq(%w[firefox])
-        end
-      end
-    end
-
-    describe "#redis_url" do
-      context "by default" do
-        it "is redis://localhost:6379" do
-          expect(config.redis_url).to eq("redis://localhost:6379")
-        end
-      end
-
-      context "with env var set" do
-        before { env["WAYFARER_REDIS_URL"] = "redis://redis:6379" }
-
-        it "reads the env var" do
-          expect(config.redis_url).to eq("redis://redis:6379")
-        end
-      end
-    end
-
-    describe "#http_headers" do
-      context "by default" do
-        it "is {}" do
-          expect(config.http_headers).to eq({})
-        end
-      end
-
-      context "with env var set" do
-        before { env["WAYFARER_HTTP_HEADERS"] = "user-agent:foo,authorization:bar" }
-
-        it "reads the env var" do
-          expect(config.http_headers).to eq("user-agent": "foo",
-                                            authorization: "bar")
-        end
-      end
-    end
-  end
-
-  describe "#redis_factory" do
-    let(:config) { Wayfarer::Config.default }
-
-    it "instantiates Redis clients" do
-      expect(config.redis_factory.call).to be_a(Redis)
-    end
-  end
-end

data/spec/networking/adapter.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-RSpec.shared_examples "Network adapter" do |options|
-  describe "::renew_on" do
-    it "returns an Array" do
-      expect(adapter.class.renew_on).to be_an(Array)
-    end
-  end
-
-  describe "#fetch" do
-    it "returns Success" do
-      url = test_app_path("/hello_world")
-      result = adapter.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 = adapter.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 = adapter.fetch(url).page
-      expect(page.body).to match(/Hello world!/)
-    end
-  end
-
-  describe "#live" do
-    context "when automating a browser" do
-      before { skip unless options[:browser] }
-
-      it "returns a live page" do
-        adapter.fetch(test_app_path("/hello_world"))
-
-        url = test_app_path("/body/foobar")
-        case adapter
-        when Wayfarer::Networking::Selenium then adapter.browser.navigate.to(url)
-        when Wayfarer::Networking::Ferrum then adapter.browser.goto(url)
-        end
-
-        page = adapter.live(nil)
-        expect(page.url).to eq(url)
-        expect(page.body).to match(/foobar/)
-        # Response headers and status code cannot be tested here, because
-        # Selenium does not support them.
-      end
-    end
-
-    context "when using plain HTTP" do
-      before { skip if options[:browser] }
-
-      it "returns the same page" do
-        page = build(:page)
-        expect(adapter.live(page)).to be(page)
-      end
-    end
-  end
-
-  describe "#body" do
-    it "returns the body" do
-      url = test_app_path("/hello_world")
-      adapter.fetch(url).page
-      expect(adapter.body).to match(/Hello world!/)
-    end
-  end
-
-  describe "#free" do
-    it "frees the browser" do
-      skip unless options[:browser]
-
-      expect {
-        adapter.free
-      }.to change { adapter.browser }.to(nil)
-    end
-
-    it "frees the Capybara session" do
-      skip unless options[:capybara]
-
-      adapter.capybara
-
-      expect {
-        adapter.free
-      }.to change { adapter.instance_variable_get(:@capybara) }.to(nil)
-    end
-  end
-
-  describe "#renew" do
-    it "does not raise" do
-      expect { adapter.renew }.not_to raise_error
-    end
-
-    it "renews the browser" do
-      skip unless options[:browser]
-
-      expect {
-        adapter.renew
-      }.to(change { adapter.browser })
-    end
-
-    it "frees the Capybara session" do
-      skip unless options[:capybara]
-
-      adapter.capybara
-
-      expect {
-        adapter.renew
-      }.to change { adapter.instance_variable_get(:@capybara) }.to(nil)
-    end
-  end
-
-  describe "#capybara" do
-    before { skip unless options[:capybara] }
-
-    it "returns a Capybara driver" do
-      expect(adapter.capybara).to be_a(Capybara::Session)
-    end
-  end
-
-  describe "HTTP headers" do
-    before { Wayfarer.config.http_headers = { "User-Agent" => "Foobar" } }
-
-    it "uses configured HTTP headers" do
-      skip unless options[:request_headers]
-
-      url = test_app_path("/headers/HTTP_USER_AGENT")
-      page = adapter.fetch(url).page
-      expect(page.body).to match(/Foobar/)
-    end
-  end
-end

data/spec/networking/healer_spec.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Networking::Healer do
-  let(:error) { Class.new(StandardError) }
-  let(:renew_on) { [error] }
-
-  let(:adapter) do
-    double.tap do |adapter|
-      allow(adapter.class).to receive(:renew_on).and_return([error])
-    end
-  end
-
-  subject(:healer) do
-    Wayfarer::Networking::Healer.new(adapter)
-  end
-
-  describe "#fetch" do
-    context "when proxied call raises renewing error" do
-      before do
-        allow(adapter).to receive(:fetch).and_raise(error)
-      end
-
-      it "renews its adapter and re-raises" do
-        expect(adapter).to receive(:renew)
-        expect {
-          healer.fetch(URI("https://example.com"))
-        }.to raise_error(error)
-      end
-    end
-
-    context "when proxied call raises non-renewing error" do
-      before do
-        allow(adapter).to receive(:fetch).and_raise(StandardError.new)
-      end
-
-      it "does not renew its adapter and intercept" do
-        expect(adapter).not_to receive(:renew)
-        expect {
-          healer.fetch(URI("https://example.com"))
-        }.to raise_error(StandardError)
-      end
-    end
-  end
-end

data/spec/networking/net_http_spec.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-require_relative "adapter"
-
-describe Wayfarer::Networking::NetHTTP do
-  subject(:adapter) { Wayfarer::Networking::NetHTTP.send(:new) }
-
-  after { adapter.free }
-
-  include_examples "Network adapter", browser: false,
-                                      capybara: false,
-                                      request_headers: true
-
-  describe "#fetch" do
-    it "sets the status code" do
-      url = test_app_path("/status_code/404")
-      page = adapter.fetch(url).page
-      expect(page.status_code).to be 404
-    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
-
-    context "when encountering a redirect" do
-      it "returns a Redirect" do
-        url = test_app_path("/redirect?times=3")
-        result = adapter.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
-end