wayfarer 0.4.0 → 0.4.4

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

data/spec/routing/dsl_spec.rb

@@ -10,7 +10,7 @@ describe Wayfarer::Routing::DSL 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.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|
@@ -22,7 +22,7 @@ describe Wayfarer::Routing::DSL do
   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).to be_a(Wayfarer::Routing::Matchers::URL)
       expect(child.matcher.url).to eq("http://example.com")
       expect(child.parent).to be(root)
     end
@@ -31,7 +31,7 @@ describe Wayfarer::Routing::DSL do
   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).to be_a(Wayfarer::Routing::Matchers::Host)
       expect(child.matcher.host).to eq("example.com")
       expect(child.parent).to be(root)
     end
@@ -40,7 +40,7 @@ describe Wayfarer::Routing::DSL do
   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).to be_a(Wayfarer::Routing::Matchers::Path)
       expect(child.matcher.path).to eq("/foo/bar")
       expect(child.parent).to be(root)
     end
@@ -49,7 +49,7 @@ describe Wayfarer::Routing::DSL do
   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).to be_a(Wayfarer::Routing::Matchers::Query)
       expect(child.matcher.fields).to eq({ foo: "bar" })
       expect(child.parent).to be(root)
     end
@@ -58,7 +58,7 @@ describe Wayfarer::Routing::DSL do
   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).to be_a(Wayfarer::Routing::Matchers::Scheme)
       expect(child.matcher.scheme).to be(:https)
       expect(child.parent).to be(root)
     end
@@ -67,7 +67,7 @@ describe Wayfarer::Routing::DSL do
   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).to be_a(Wayfarer::Routing::Matchers::Suffix)
       expect(child.matcher.suffix).to eq(".png")
       expect(child.parent).to be(root)
     end
@@ -76,7 +76,7 @@ describe Wayfarer::Routing::DSL do
   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).to be_a(Wayfarer::Routing::Matchers::Custom)
       expect(child.matcher.delegate).to be_a(Proc)
       expect(child.parent).to be(root)
     end
@@ -89,10 +89,10 @@ describe Wayfarer::Routing::DSL do
       end
 
       expect(root.children.count).to be(1)
-      expect(root.children.first.matcher).to be_a(Wayfarer::Routing::HostMatcher)
+      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::PathMatcher)
+      expect(root.children.first.children.first.matcher).to be_a(Wayfarer::Routing::Matchers::Path)
     end
   end
 end

data/spec/routing/integration_spec.rb

@@ -8,17 +8,17 @@ describe Wayfarer::Routing::DSL do
   it "matches URLs" do
     route.path "/"
 
-    result = route.invoke(URI("https://example.com/"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/"))
     expect(result).to be_a(Wayfarer::Routing::Result::Match)
 
-    result = route.invoke(URI("https://example.com/foo"))
+    result = route.invoke(Addressable::URI.parse("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"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo"))
     expect(result).to be_a(Wayfarer::Routing::Result::Match)
   end
 
@@ -27,16 +27,16 @@ describe Wayfarer::Routing::DSL do
       query page: 1..10
     end
 
-    result = route.invoke(URI("https://example.com/foo?page=4"))
+    result = route.invoke(Addressable::URI.parse("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"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo?page=11"))
     expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
 
-    result = route.invoke(URI("https://example.com/foo"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo"))
     expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
 
-    result = route.invoke(URI("https://example.com?page=2"))
+    result = route.invoke(Addressable::URI.parse("https://example.com?page=2"))
     expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
   end
 
@@ -45,16 +45,16 @@ describe Wayfarer::Routing::DSL do
       query page: 1..10
     end
 
-    result = route.invoke(URI("https://example.com/foo?page=4"))
+    result = route.invoke(Addressable::URI.parse("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"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo?page=11"))
     expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
 
-    result = route.invoke(URI("https://example.com/foo"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/foo"))
     expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
 
-    result = route.invoke(URI("https://example.com?page=2"))
+    result = route.invoke(Addressable::URI.parse("https://example.com?page=2"))
     expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
   end
 
@@ -64,19 +64,19 @@ describe Wayfarer::Routing::DSL do
       path "/users/:id"
     end
 
-    result = route.invoke(URI("https://example.com/contact"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/contact"))
     expect(result).to be_a(Wayfarer::Routing::Result::Match)
 
-    result = route.invoke(URI("https://example.com/contact/foo"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/contact/foo"))
     expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
 
-    result = route.invoke(URI("https://example.com/users/123"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/users/123"))
     expect(result).to be_a(Wayfarer::Routing::Result::Match)
 
-    result = route.invoke(URI("https://example.com/users/123/images"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/users/123/images"))
     expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
 
-    result = route.invoke(URI("https://example.com/users"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/users"))
     expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
   end
 
@@ -89,22 +89,22 @@ describe Wayfarer::Routing::DSL do
       end
     end
 
-    result = route.invoke(URI("https://example.com/contact"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/contact"))
     expect(result).to be_a(Wayfarer::Routing::Result::Match)
 
-    result = route.invoke(URI("https://example.com/users/123"))
+    result = route.invoke(Addressable::URI.parse("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"))
+    result = route.invoke(Addressable::URI.parse("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"))
+    result = route.invoke(Addressable::URI.parse("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"))
+    result = route.invoke(Addressable::URI.parse("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"))
+    result = route.invoke(Addressable::URI.parse("https://example.com/users/123/foobar"))
     expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
   end
 end

data/spec/routing/{custom_matcher_spec.rb → matchers/custom_spec.rb}

@@ -2,14 +2,14 @@
 
 require "spec_helpers"
 
-describe Wayfarer::Routing::CustomMatcher do
-  let(:url) { URI("http://example.com") }
+describe Wayfarer::Routing::Matchers::Custom do
+  let(:url) { Addressable::URI.parse("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 }
+          Wayfarer::Routing::Matchers::Custom.new ->(_) { true }
         end
 
         it "returns true" do
@@ -19,7 +19,7 @@ describe Wayfarer::Routing::CustomMatcher do
 
       context "when block is falsy" do
         subject(:matcher) do
-          Wayfarer::Routing::CustomMatcher.new ->(_) { false }
+          Wayfarer::Routing::Matchers::Custom.new ->(_) { false }
         end
 
         it "returns true" do

data/spec/routing/{host_matcher_spec.rb → matchers/host_spec.rb}

@@ -2,15 +2,15 @@
 
 require "spec_helpers"
 
-describe Wayfarer::Routing::HostMatcher do
-  subject(:matcher) { Wayfarer::Routing::HostMatcher.new(str_or_regexp) }
+describe Wayfarer::Routing::Matchers::Host do
+  subject(:matcher) { Wayfarer::Routing::Matchers::Host.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") }
+        let(:url) { Addressable::URI.parse("http://example.com/foo/bar") }
 
         it "returns true" do
           expect(matcher).to match(url)
@@ -18,7 +18,7 @@ describe Wayfarer::Routing::HostMatcher do
       end
 
       context "with mismatching URL" do
-        let(:url) { URI("http://google.com/bar/qux") }
+        let(:url) { Addressable::URI.parse("http://google.com/bar/qux") }
 
         it "returns false" do
           expect(matcher).not_to match(url)
@@ -30,7 +30,7 @@ describe Wayfarer::Routing::HostMatcher do
       let(:str_or_regexp) { /example.com/ }
 
       context "with matching URL" do
-        let(:url) { URI("http://sub.example.com") }
+        let(:url) { Addressable::URI.parse("http://sub.example.com") }
 
         it "returns true" do
           expect(matcher).to match(url)
@@ -38,7 +38,7 @@ describe Wayfarer::Routing::HostMatcher do
       end
 
       context "with mismatching URL" do
-        let(:url) { URI("http://example.sub.com") }
+        let(:url) { Addressable::URI.parse("http://example.sub.com") }
 
         it "returns false" do
           expect(matcher).not_to match(url)

data/spec/routing/{path_matcher_spec.rb → matchers/path_spec.rb}

@@ -2,16 +2,16 @@
 
 require "spec_helpers"
 
-describe Wayfarer::Routing::PathMatcher, mri: true do
+describe Wayfarer::Routing::Matchers::Path, mri: true do
   let(:route) { Wayfarer::Routing::RootRoute.new }
-  subject(:matcher) { Wayfarer::Routing::PathMatcher.new(path, route) }
+  subject(:matcher) { Wayfarer::Routing::Matchers::Path.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"))
+        expect(matcher).to match(Addressable::URI.parse("http://example.com/foo/bar"))
       end
     end
 
@@ -19,7 +19,7 @@ describe Wayfarer::Routing::PathMatcher, mri: true do
       let(:path) { "/{alpha}/{beta}" }
 
       it "returns false" do
-        expect(matcher).not_to match(URI("http://example.com/foo"))
+        expect(matcher).not_to match(Addressable::URI.parse("http://example.com/foo"))
       end
     end
 
@@ -27,7 +27,7 @@ describe Wayfarer::Routing::PathMatcher, mri: true do
       let(:path) { "/" }
 
       it "returns false" do
-        expect(matcher).not_to match(URI("http://example.com/foo"))
+        expect(matcher).not_to match(Addressable::URI.parse("http://example.com/foo"))
       end
     end
   end
@@ -36,7 +36,7 @@ describe Wayfarer::Routing::PathMatcher, mri: true do
     let(:path) { "/{alpha}/{beta}" }
 
     it "returns the correct parameters" do
-      url = URI("http://example.com/foo/bar")
+      url = Addressable::URI.parse("http://example.com/foo/bar")
       expect(matcher.params(url)).to eq("alpha" => "foo", "beta" => "bar")
     end
   end

data/spec/routing/{query_matcher_spec.rb → matchers/query_spec.rb}

@@ -2,14 +2,14 @@
 
 require "spec_helpers"
 
-describe Wayfarer::Routing::QueryMatcher do
-  subject(:matcher) { Wayfarer::Routing::QueryMatcher.new(constraints) }
+describe Wayfarer::Routing::Matchers::Query do
+  subject(:matcher) { Wayfarer::Routing::Matchers::Query.new(constraints) }
 
   describe "String constraints" do
     let(:constraints) { Hash[arg: "foo"] }
 
     context "with matching query field value" do
-      let(:url) { URI("http://example.com?arg=foo") }
+      let(:url) { Addressable::URI.parse("http://example.com?arg=foo") }
 
       it "returns true" do
         expect(matcher).to match(url)
@@ -17,7 +17,7 @@ describe Wayfarer::Routing::QueryMatcher do
     end
 
     context "with mismatching query field value" do
-      let(:url) { URI("http://example.com?arg=bar") }
+      let(:url) { Addressable::URI.parse("http://example.com?arg=bar") }
 
       it "returns false" do
         expect(matcher).not_to match(url)
@@ -29,7 +29,7 @@ describe Wayfarer::Routing::QueryMatcher do
     let(:constraints) { Hash[arg: 0] }
 
     context "with matching query field value" do
-      let(:url) { URI("http://example.com?arg=0") }
+      let(:url) { Addressable::URI.parse("http://example.com?arg=0") }
 
       it "returns true" do
         expect(matcher).to match(url)
@@ -37,7 +37,7 @@ describe Wayfarer::Routing::QueryMatcher do
     end
 
     context "with mismatching query field value" do
-      let(:url) { URI("http://example.com?arg=1") }
+      let(:url) { Addressable::URI.parse("http://example.com?arg=1") }
 
       it "returns false" do
         expect(matcher).not_to match(url)
@@ -45,7 +45,7 @@ describe Wayfarer::Routing::QueryMatcher do
     end
 
     context "with non-numeric query field value" do
-      let(:url) { URI("http://example.com?arg=foo") }
+      let(:url) { Addressable::URI.parse("http://example.com?arg=foo") }
 
       it "returns false" do
         expect(matcher).not_to match(url)
@@ -57,7 +57,7 @@ describe Wayfarer::Routing::QueryMatcher do
     let(:constraints) { Hash[arg: /foo/] }
 
     context "with matching query field value" do
-      let(:url) { URI("http://example.com?arg=foo") }
+      let(:url) { Addressable::URI.parse("http://example.com?arg=foo") }
 
       it "returns true" do
         expect(matcher).to match(url)
@@ -65,7 +65,7 @@ describe Wayfarer::Routing::QueryMatcher do
     end
 
     context "with mismatching query field value" do
-      let(:url) { URI("http://example.com?arg=bar") }
+      let(:url) { Addressable::URI.parse("http://example.com?arg=bar") }
 
       it "returns false" do
         expect(matcher).not_to match(url)
@@ -77,7 +77,7 @@ describe Wayfarer::Routing::QueryMatcher do
     let(:constraints) { Hash[arg: 1..10] }
 
     context "with matching query field value" do
-      let(:url) { URI("http://example.com?arg=5") }
+      let(:url) { Addressable::URI.parse("http://example.com?arg=5") }
 
       it "returns true" do
         expect(matcher).to match(url)
@@ -85,7 +85,7 @@ describe Wayfarer::Routing::QueryMatcher do
     end
 
     context "with mismatching query field value" do
-      let(:url) { URI("http://example.com?arg=11") }
+      let(:url) { Addressable::URI.parse("http://example.com?arg=11") }
 
       it "returns false" do
         expect(matcher).not_to match(url)
@@ -93,7 +93,7 @@ describe Wayfarer::Routing::QueryMatcher do
     end
 
     context "with non-numeric query field value" do
-      let(:url) { URI("http://example.com?arg=foo") }
+      let(:url) { Addressable::URI.parse("http://example.com?arg=foo") }
 
       it "returns false" do
         expect(matcher).not_to match(url)
@@ -107,7 +107,7 @@ describe Wayfarer::Routing::QueryMatcher do
     end
 
     context "with matching query field values" do
-      let(:url) { URI("http://example.com?foo=4&bar=bazqux&qux=zot&toto=2") }
+      let(:url) { Addressable::URI.parse("http://example.com?foo=4&bar=bazqux&qux=zot&toto=2") }
 
       it "returns true" do
         expect(matcher).to match(url)
@@ -115,7 +115,7 @@ describe Wayfarer::Routing::QueryMatcher do
     end
 
     context "with mismatching query field values" do
-      let(:url) { URI("http://example.com?foo=bar&bar=qux&qux=6toto=0") }
+      let(:url) { Addressable::URI.parse("http://example.com?foo=bar&bar=qux&qux=6toto=0") }
 
       it "returns false" do
         expect(matcher).not_to match(url)
@@ -129,7 +129,7 @@ describe Wayfarer::Routing::QueryMatcher do
     end
 
     it "returns the correct parameters" do
-      url = URI("http://example.com?foo=4&bar=bazqux&qux=zot&toto=2")
+      url = Addressable::URI.parse("http://example.com?foo=4&bar=bazqux&qux=zot&toto=2")
       expect(matcher.params(url)).to \
         eq("foo" => "4", "bar" => "bazqux", "qux" => "zot", "toto" => "2")
     end

data/spec/routing/{scheme_matcher_spec.rb → matchers/scheme_spec.rb}

@@ -2,12 +2,12 @@
 
 require "spec_helpers"
 
-describe Wayfarer::Routing::SchemeMatcher do
+describe Wayfarer::Routing::Matchers::Scheme do
   describe "#match" do
-    subject(:matcher) { Wayfarer::Routing::SchemeMatcher.new(:http) }
+    subject(:matcher) { Wayfarer::Routing::Matchers::Scheme.new(:http) }
 
     context "with matching URL" do
-      let(:url) { URI("http://example.com") }
+      let(:url) { Addressable::URI.parse("http://example.com") }
 
       it "returns true" do
         expect(matcher).to match(url)
@@ -15,7 +15,7 @@ describe Wayfarer::Routing::SchemeMatcher do
     end
 
     context "with mismatching URL" do
-      let(:url) { URI("https://example.com") }
+      let(:url) { Addressable::URI.parse("https://example.com") }
 
       it "returns true" do
         expect(matcher).not_to match(url)

data/spec/routing/{suffix_matcher_spec.rb → matchers/suffix_spec.rb}

@@ -2,8 +2,8 @@
 
 require "spec_helpers"
 
-describe Wayfarer::Routing::SuffixMatcher do
-  subject(:matcher) { Wayfarer::Routing::SuffixMatcher.new(".png") }
+describe Wayfarer::Routing::Matchers::Suffix do
+  subject(:matcher) { Wayfarer::Routing::Matchers::Suffix.new(".png") }
 
   describe "#match" do
     context "with matching URL" do
@@ -13,7 +13,7 @@ describe Wayfarer::Routing::SuffixMatcher do
           https://example.com/a/b.png/c.png
           http://example.com/foobar.html.png
           https://example.com/foo.png/bar.png
-        ].map { |u| URI(u) }
+        ].map { |u| Addressable::URI.parse(u) }
 
         urls.each do |url|
           expect(matcher).to match(url)
@@ -30,7 +30,7 @@ describe Wayfarer::Routing::SuffixMatcher do
           http://example.com.html
           http://example.com/foobar.html
           https://example.com/foo.png/bar.png.html
-        ].map { |u| URI(u) }
+        ].map { |u| Addressable::URI.parse(u) }
 
         urls.each do |url|
           expect(matcher).not_to match(url)