wayfarer 0.0.3 → 0.4.3

data/spec/networking/pool_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Networking::Pool do
+  subject(:pool) { Wayfarer::Networking::Pool.send(:new) }
+
+  after { pool.free }
+
+  describe "#with" do
+    context "by default" do
+      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.network.agent = :ferrum }
+
+      it "yields Ferrum" do
+        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.network.agent = :selenium }
+
+      it "yields Selenium" do
+        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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+require_relative "strategy"
+
+describe Wayfarer::Networking::Selenium, selenium: true do
+  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/page_spec.rb

@@ -1,38 +1,47 @@
 # frozen_string_literal: true
+
 require "spec_helpers"
 
 describe Wayfarer::Page do
-  subject(:page) { fetch_page(test_app("/links/links.html")) }
-
   describe "#doc" do
+    context "when Content-Type is absent" do
+      subject(:page) { build(:page, :html, headers: {}) }
+
+      it "returns a Nokogiri::HTML::Document" do
+        expect(page.doc).to be_a(Nokogiri::HTML::Document)
+      end
+    end
+
     context "when Content-Type is HTML" do
+      subject(:page) { build(:page, :html) }
+
       it "returns a Nokogiri::HTML::Document" do
-        expect(page.doc).to be_a Nokogiri::HTML::Document
+        expect(page.doc).to be_a(Nokogiri::HTML::Document)
       end
     end
 
     context "when Content-Type is XML" do
-      subject(:page) { fetch_page(test_app("/xml/dummy.xml")) }
+      subject(:page) { build(:page, :xml) }
 
       it "returns a Nokogiri::XML::Document" do
-        expect(page.doc).to be_a Nokogiri::XML::Document
+        expect(page.doc).to be_a(Nokogiri::XML::Document)
       end
     end
 
     context "when Content-Type is JSON" do
-      subject(:page) { fetch_page(test_app("/json/dummy.json")) }
+      subject(:page) { build(:page, :json) }
 
       it "returns a Hash" do
-        expect(page.doc).to be_a Hash
+        expect(page.doc).to be_a(Hash)
       end
     end
   end
 
-  describe "Forwarding" do
-    it "forwards calls to Pismo", mri_only: true do
-      Pismo::Document::ATTRIBUTE_METHODS.each do |method|
-        expect(page).to respond_to(method)
-      end
+  describe "#meta" do
+    subject(:page) { build(:page, :html) }
+
+    it "returns a MetaInspector document" do
+      expect(page.meta).to be_a(MetaInspector::Document)
     end
   end
 end

data/spec/{parsers/json_parser_spec.rb → parsing/json_spec.rb}

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
+
 require "spec_helpers"
 
-describe Wayfarer::Parsers::JSONParser do
-  subject(:parser) { Parsers::JSONParser }
+describe Wayfarer::Parsing::JSON do
+  subject(:parser) { Wayfarer::Parsing::JSON }
 
   describe ".parse" do
     it "returns a Hash" do
-      json_str = <<-json
+      json_str = <<-JSON
         {
           "id": 1,
           "name": "Foo",
@@ -20,7 +21,7 @@ describe Wayfarer::Parsers::JSONParser do
             "retail": 20
           }
         }
-      json
+      JSON
 
       doc = parser.parse(json_str)
 

data/spec/{parsers/xml_parser_spec.rb → parsing/xml_spec.rb}

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+
 require "spec_helpers"
 
-describe Wayfarer::Parsers::XMLParser do
-  subject(:parser) { Parsers::XMLParser }
+describe Wayfarer::Parsing::XML do
+  subject(:parser) { Wayfarer::Parsing::XML }
 
   describe ".parse_html" do
     it "returns a Nokogiri::HTML::Document" do

data/spec/redis/barrier_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Redis::Barrier, redis: true do
+  let(:url) { "https://example.com" }
+  subject(:barrier) { Wayfarer::Redis::Barrier.new("batch") }
+
+  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.seen?(url)
+      barrier.reset!
+      expect(barrier.seen?(url)).to be false
+    end
+  end
+
+  describe "#seen?" do
+    context "with seen URL" do
+      before { barrier.seen?(url) }
+
+      it "returns true" do
+        expect(barrier.seen?(url)).to be(true)
+      end
+    end
+
+    context "with unseen URL" do
+      it "returns false" do
+        expect(barrier.seen?(url)).to be(false)
+      end
+    end
+  end
+
+  describe "#peek" do
+    let(:seen_urls) { %w[https://yahoo.com https://google.com] }
+    let(:unseen_urls) { %w[https://w3c.org https://nasa.gov] }
+
+    before do
+      allow(Wayfarer::Redis::Version).to receive(:determine).and_return(redis_version)
+
+      seen_urls.each do |url|
+        barrier.seen?(url)
+      end
+    end
+
+    context "Redis >= 6.2.0" do
+      let(:redis_version) { [6, 2, 5] }
+
+      it "returns membership" do
+        urls = [*seen_urls, *unseen_urls]
+        expect(barrier.peek(urls)).to eq([true, true, false, false])
+      end
+    end
+
+    context "Redis < 6.2.0" do
+      let(:redis_version) { [2, 6, 10] }
+
+      it "returns membership" do
+        urls = [*seen_urls, *unseen_urls]
+        expect(barrier.peek(urls)).to eq([true, true, false, false])
+      end
+    end
+  end
+
+  describe "#unsee" do
+    it "removes a seen URL" do
+      barrier.seen?(url)
+      expect {
+        barrier.unsee(url)
+      }.to change { barrier.seen?(url) }.to(false)
+    end
+  end
+end

data/spec/redis/counter_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Redis::Counter, redis: true do
+  subject(:counter) { Wayfarer::Redis::Counter.new("batch") }
+
+  describe "#redis_key" do
+    it "returns the expected Redis key" do
+      expect(counter.redis_key).to eq("wayfarer-counter-batch")
+    end
+  end
+
+  describe "#increment" do
+    it "increments" do
+      expect { counter.increment }.to change { counter.value }.by(1)
+    end
+  end
+
+  describe "#decrement" do
+    it "decrements" 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/pool_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Redis::Pool, redis: true do
+  let(:conn) { spy }
+  subject(:pool) { Wayfarer::Redis::Pool.send(:new) }
+
+  describe "::with" do
+    before do
+      Wayfarer.config.redis.factory = ->(_) { conn }
+    end
+
+    it "instantiates the factory and yields" do
+      pool.with { |x| expect(x).to be(conn) }
+    end
+  end
+end

data/spec/redis/version_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Redis::Version, redis: true do
+  describe "::determine" do
+    it "returns Redis major, minor, patch version" do
+      Wayfarer::Redis::Version.instance_variable_set(:@determine, nil)
+      expect(Wayfarer::Redis::Version).to receive(:server_version).and_return("1.20.300")
+      expect(Wayfarer::Redis::Version.determine).to eq([1, 20, 300])
+    end
+  end
+end

data/spec/routing/dsl_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::DSL do
+  subject(:root) { Wayfarer::Routing::RootRoute.new }
+  let(:child) { root.children.first }
+
+  describe "#to" do
+    it "adds a child with an always-matching matcher" do
+      expect(root.to(:foobar)).to be_a(Wayfarer::Routing::Route)
+      expect(child.action).to be(:foobar)
+      expect(child.matcher).to be_a(Wayfarer::Routing::Matchers::Custom)
+      expect(child.parent).to be(root)
+
+      %w[http://example.com http://w3c.org http://google.com].each do |url|
+        expect(child.matcher.match(url)).to be(true)
+      end
+    end
+  end
+
+  describe "#url" do
+    it "adds a child with an URL matcher" do
+      expect(root.url("http://example.com")).to be_a(Wayfarer::Routing::Route)
+      expect(child.matcher).to be_a(Wayfarer::Routing::Matchers::URL)
+      expect(child.matcher.url).to eq("http://example.com")
+      expect(child.parent).to be(root)
+    end
+  end
+
+  describe "#host" do
+    it "adds a child with a host matcher" do
+      expect(root.host("example.com")).to be_a(Wayfarer::Routing::Route)
+      expect(child.matcher).to be_a(Wayfarer::Routing::Matchers::Host)
+      expect(child.matcher.host).to eq("example.com")
+      expect(child.parent).to be(root)
+    end
+  end
+
+  describe "#path" do
+    it "adds a child with a path matcher" do
+      expect(root.path("/foo/bar")).to be_a(Wayfarer::Routing::Route)
+      expect(child.matcher).to be_a(Wayfarer::Routing::Matchers::Path)
+      expect(child.matcher.path).to eq("/foo/bar")
+      expect(child.parent).to be(root)
+    end
+  end
+
+  describe "#query" do
+    it "adds a child with a query matcher" do
+      expect(root.query(foo: "bar")).to be_a(Wayfarer::Routing::Route)
+      expect(child.matcher).to be_a(Wayfarer::Routing::Matchers::Query)
+      expect(child.matcher.fields).to eq({ foo: "bar" })
+      expect(child.parent).to be(root)
+    end
+  end
+
+  describe "#scheme" do
+    it "adds a child with a scheme matcher" do
+      expect(root.scheme(:https)).to be_a(Wayfarer::Routing::Route)
+      expect(child.matcher).to be_a(Wayfarer::Routing::Matchers::Scheme)
+      expect(child.matcher.scheme).to be(:https)
+      expect(child.parent).to be(root)
+    end
+  end
+
+  describe "#suffix" do
+    it "adds a child with a suffix matcher" do
+      expect(root.suffix(".png")).to be_a(Wayfarer::Routing::Route)
+      expect(child.matcher).to be_a(Wayfarer::Routing::Matchers::Suffix)
+      expect(child.matcher.suffix).to eq(".png")
+      expect(child.parent).to be(root)
+    end
+  end
+
+  describe "#custom" do
+    it "adds a child with a custom matcher" do
+      expect(root.custom(->(_) { true })).to be_a(Wayfarer::Routing::Route)
+      expect(child.matcher).to be_a(Wayfarer::Routing::Matchers::Custom)
+      expect(child.matcher.delegate).to be_a(Proc)
+      expect(child.parent).to be(root)
+    end
+  end
+
+  describe "Complex routing tree" do
+    it "constructs the expected tree" do
+      root.host "example.com", path: "/foo" do
+        query foo: 4, bar: 2
+      end
+
+      expect(root.children.count).to be(1)
+      expect(root.children.first.matcher).to be_a(Wayfarer::Routing::Matchers::Host)
+
+      expect(root.children.first.children.count).to be(1)
+      expect(root.children.first.children.first.matcher).to be_a(Wayfarer::Routing::Matchers::Path)
+    end
+  end
+end