wayfarer 0.0.3 → 0.4.0

data/spec/networking/pool_spec.rb

@@ -0,0 +1,42 @@
+# 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 NetHTTP" do
+        pool.with do |adapter|
+          expect(adapter).to be_a(Wayfarer::Networking::Healer)
+          expect(adapter.adapter).to be_a(Wayfarer::Networking::NetHTTP)
+        end
+      end
+    end
+
+    context "when using Ferrum", ferrum: true do
+      before { Wayfarer.config.adapter = :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)
+        end
+      end
+    end
+
+    context "when using Selenium", selenium: true do
+      before { Wayfarer.config.adapter = :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)
+        end
+      end
+    end
+  end
+end

data/spec/networking/selenium_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+require_relative "adapter"
+
+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
+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/custom_matcher_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::CustomMatcher do
+  let(:url) { URI("http://example.com") }
+
+  describe "#match" do
+    context "with a block" do
+      context "when block is truthy" do
+        subject(:matcher) do
+          Wayfarer::Routing::CustomMatcher.new ->(_) { true }
+        end
+
+        it "returns true" do
+          expect(matcher).to match(url)
+        end
+      end
+
+      context "when block is falsy" do
+        subject(:matcher) do
+          Wayfarer::Routing::CustomMatcher.new ->(_) { false }
+        end
+
+        it "returns true" do
+          expect(matcher).not_to match(url)
+        end
+      end
+    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::CustomMatcher)
+      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::URLMatcher)
+      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::HostMatcher)
+      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::PathMatcher)
+      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::QueryMatcher)
+      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::SchemeMatcher)
+      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::SuffixMatcher)
+      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::CustomMatcher)
+      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::HostMatcher)
+
+      expect(root.children.first.children.count).to be(1)
+      expect(root.children.first.children.first.matcher).to be_a(Wayfarer::Routing::PathMatcher)
+    end
+  end
+end

data/spec/routing/host_matcher_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::HostMatcher do
+  subject(:matcher) { Wayfarer::Routing::HostMatcher.new(str_or_regexp) }
+
+  describe "#matches?" do
+    describe "String matching" do
+      let(:str_or_regexp) { "example.com" }
+
+      context "with matching URL" do
+        let(:url) { URI("http://example.com/foo/bar") }
+
+        it "returns true" do
+          expect(matcher).to match(url)
+        end
+      end
+
+      context "with mismatching URL" do
+        let(:url) { URI("http://google.com/bar/qux") }
+
+        it "returns false" do
+          expect(matcher).not_to match(url)
+        end
+      end
+    end
+
+    describe "RegExp matching" do
+      let(:str_or_regexp) { /example.com/ }
+
+      context "with matching URL" do
+        let(:url) { URI("http://sub.example.com") }
+
+        it "returns true" do
+          expect(matcher).to match(url)
+        end
+      end
+
+      context "with mismatching URL" do
+        let(:url) { URI("http://example.sub.com") }
+
+        it "returns false" do
+          expect(matcher).not_to match(url)
+        end
+      end
+    end
+  end
+end

data/spec/routing/integration_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::DSL do
+  let(:route) { Wayfarer::Routing::RootRoute.new }
+
+  it "matches URLs" do
+    route.path "/"
+
+    result = route.invoke(URI("https://example.com/"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(URI("https://example.com/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+  end
+
+  it "matches URLs" do
+    route.host "example.com", path: "/foo"
+
+    result = route.invoke(URI("https://example.com/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+  end
+
+  it "matches URLs" do
+    route.host "example.com", path: "/foo" do
+      query page: 1..10
+    end
+
+    result = route.invoke(URI("https://example.com/foo?page=4"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(URI("https://example.com/foo?page=11"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(URI("https://example.com/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(URI("https://example.com?page=2"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+  end
+
+  it "matches URLs" do
+    route.host "example.com", path: "/foo" do
+      query page: 1..10
+    end
+
+    result = route.invoke(URI("https://example.com/foo?page=4"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(URI("https://example.com/foo?page=11"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(URI("https://example.com/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(URI("https://example.com?page=2"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+  end
+
+  it "matches URLs" do
+    route.host "example.com" do
+      path "/contact"
+      path "/users/:id"
+    end
+
+    result = route.invoke(URI("https://example.com/contact"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(URI("https://example.com/contact/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(URI("https://example.com/users/123"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(URI("https://example.com/users/123/images"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(URI("https://example.com/users"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+  end
+
+  it "matches URLs" do
+    route.host "example.com" do
+      path "/contact"
+      path "/users/:user_id" do
+        path "/images/:id"
+        path "/friends"
+      end
+    end
+
+    result = route.invoke(URI("https://example.com/contact"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(URI("https://example.com/users/123"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(URI("https://example.com/users/123/images/23"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(URI("https://example.com/users/123/images/23/foo"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+
+    result = route.invoke(URI("https://example.com/users/123/friends"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Match)
+
+    result = route.invoke(URI("https://example.com/users/123/foobar"))
+    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+  end
+end

data/spec/routing/path_finder_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::PathFinder do
+  let(:route) do
+    Wayfarer::Routing::RootRoute.new.to(:foobar) do
+      host "example.com", path: "/:a/:b"
+    end
+  end
+
+  subject(:result) { Wayfarer::Routing::PathFinder.result(route, URI(url)) }
+
+  describe "::result" do
+    context "with matching URL" do
+      let(:url) { "https://example.com/alpha/beta" }
+
+      it "returns a Match" do
+        expect(result).to be_a(Wayfarer::Routing::Result::Match)
+        expect(result.action).to be(:foobar)
+        expect(result.params).to eq("a" => "alpha", "b" => "beta")
+      end
+    end
+
+    context "with mismatching URL" do
+      let(:url) { "https://yahoo.com/alpha/zyklon" }
+
+      it "returns a Mismatch" do
+        expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+      end
+    end
+  end
+end

data/spec/routing/path_matcher_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::PathMatcher, mri: true do
+  let(:route) { Wayfarer::Routing::RootRoute.new }
+  subject(:matcher) { Wayfarer::Routing::PathMatcher.new(path, route) }
+
+  describe "#match?" do
+    context "with matching URL" do
+      let(:path) { "/{alpha}/{beta}" }
+
+      it "returns true" do
+        expect(matcher).to match(URI("http://example.com/foo/bar"))
+      end
+    end
+
+    context "with mismatching URL" do
+      let(:path) { "/{alpha}/{beta}" }
+
+      it "returns false" do
+        expect(matcher).not_to match(URI("http://example.com/foo"))
+      end
+    end
+
+    context "with mismatching URL" do
+      let(:path) { "/" }
+
+      it "returns false" do
+        expect(matcher).not_to match(URI("http://example.com/foo"))
+      end
+    end
+  end
+
+  describe "#params" do
+    let(:path) { "/{alpha}/{beta}" }
+
+    it "returns the correct parameters" do
+      url = URI("http://example.com/foo/bar")
+      expect(matcher.params(url)).to eq("alpha" => "foo", "beta" => "bar")
+    end
+  end
+end