wayfarer 0.4.7 → 0.4.9

data/spec/{networking → wayfarer/networking}/follow_spec.rb

@@ -3,13 +3,14 @@
 require "spec_helpers"
 
 describe Wayfarer::Networking::Follow do
+  subject(:outer) { described_class.new(inner) }
+
   let(:page) { build(:page) }
   let(:url) { test_app_path("/foo") }
   let(:redirect_url) { test_app_path("/redirect") }
   let(:success) { Wayfarer::Networking::Result::Success.new(page) }
   let(:redirect) { Wayfarer::Networking::Result::Redirect.new(redirect_url) }
   let(:inner) { spy }
-  subject(:outer) { described_class.new(inner) }
 
   describe "#fetch" do
     context "when context returns Success" do
@@ -21,10 +22,14 @@ describe Wayfarer::Networking::Follow do
     end
 
     context "when context returns Redirect" do
-      it "follows the redirect" do
-        expect(inner).to receive(:fetch).with(url).and_return(redirect).ordered
-        expect(inner).to receive(:fetch).with(redirect_url).and_return(success).ordered
+      it "follows redirect URL" do
+        allow(inner).to receive(:fetch).with(url).and_return(redirect)
+        allow(inner).to receive(:fetch).with(redirect_url).and_return(success)
+
         outer.fetch(url, follow: 2)
+
+        expect(inner).to have_received(:fetch).with(url).ordered
+        expect(inner).to have_received(:fetch).with(redirect_url).ordered
       end
     end
 

data/spec/wayfarer/networking/http_spec.rb

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

data/spec/{networking → wayfarer/networking}/pool_spec.rb

@@ -3,12 +3,12 @@
 require "spec_helpers"
 
 describe Wayfarer::Networking::Pool do
-  subject(:pool) { Wayfarer::Networking::Pool.send(:new) }
+  subject(:pool) { described_class.send(:new) }
 
   after { pool.free }
 
   describe "#with" do
-    context "by default" do
+    context "with default" do
       it "yields HTTP" do
         pool.with do |context|
           expect(context.strategy).to be_a(Wayfarer::Networking::HTTP)
@@ -16,7 +16,7 @@ describe Wayfarer::Networking::Pool do
       end
     end
 
-    context "when using Ferrum", ferrum: true do
+    context "when using Ferrum", :ferrum do
       before { Wayfarer.config[:network][:agent] = :ferrum }
 
       it "yields Ferrum" do
@@ -26,7 +26,7 @@ describe Wayfarer::Networking::Pool do
       end
     end
 
-    context "when using Selenium", selenium: true do
+    context "when using Selenium", :selenium do
       before { Wayfarer.config[:network][:agent] = :selenium }
 
       it "yields Selenium" do
@@ -36,7 +36,7 @@ describe Wayfarer::Networking::Pool do
       end
     end
 
-    context "when using Capybara", ferrum: true do
+    context "when using Capybara", :ferrum do
       before do
         Wayfarer.config[:network][:agent] = :capybara
         Wayfarer.config[:capybara][:driver] = :cuprite
@@ -51,17 +51,19 @@ describe Wayfarer::Networking::Pool do
   end
 
   describe "#free" do
-    let(:strategy) { double(create: spy) }
+    let(:strategy) { double(create: nil, destroy: nil) } # rubocop:disable RSpec/VerifiedDoubles
 
     before do
-      pool.class.registry[:foobar] = double(new: strategy)
+      Wayfarer.config[:network][:agents][:foobar] = double(new: strategy) # rubocop:disable RSpec/VerifiedDoubles
+      pool.class.finalizer = ->(pool) { pool.reload(&:renew) }
+
       Wayfarer.config[:network][:agent] = :foobar
     end
 
     it "destroys the strategy" do
-      expect(strategy).to receive(:destroy)
-      pool.with {}
+      pool.with {} # rubocop:disable Lint/EmptyBlock
       pool.free
+      expect(strategy).to have_received(:destroy)
     end
   end
 end

data/spec/wayfarer/networking/selenium_spec.rb

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

data/spec/{networking → wayfarer/networking}/strategy.rb

@@ -5,33 +5,39 @@ require "spec_helpers"
 RSpec.shared_examples "Network strategy" do |options|
   attr_accessor :context
 
-  before(:all) do
+  # rubocop:disable RSpec/BeforeAfterAll
+  before :all do
     self.context = Wayfarer::Networking::Context.new(options[:strategy].new)
   end
 
-  after(:all) do
+  after :all do
     context.renew
   end
+  # rubocop:enable RSpec/BeforeAfterAll
 
-  describe "#renew_on" do
+  describe "::renew_on" do
     it "returns an Array" do
-      expect(context.strategy.renew_on).to be_an(Array)
+      expect(context.strategy.class.renew_on).to be_an(Array)
     end
   end
 
   describe "Context" do
     describe "#fetch" do
-      it "returns Success" do
-        url = test_app_path("/hello_world")
+      it "returns Success", :aggregate_failures do
+        url = test_app_path("/status/200")
         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")
+      context "with 4xx response code" do
+        skip if options[:raises_on_error_response]
+
+        it "sets the URL" do
+          url = test_app_path("hello_world")
+          page = context.fetch(url).page
+          expect(page.url).to eq test_app_path("hello_world")
+        end
       end
 
       it "sets the response body" do
@@ -40,23 +46,26 @@ RSpec.shared_examples "Network strategy" do |options|
         expect(page.body).to match(/Hello world!/)
       end
 
-      it "sets the status code" do
-        skip unless options[:status_code]
+      context "with error responses" do
+        it "sets the status code" do
+          skip unless options[:status_code]
+          skip if options[:raises_on_error_response]
 
-        url = test_app_path("/status_code/418")
-        page = context.fetch(url).page
-        expect(page.status_code).to be(418)
+          url = test_app_path("status_code/404")
+          page = context.fetch(url).page
+          expect(page.status_code).to be(404)
+        end
       end
 
       it "sets response headers" do
         skip unless options[:response_headers]
 
-        url = test_app_path("/hello_world")
+        url = test_app_path("hello_world")
         page = context.fetch(url).page
         expect(page.headers["hello"]).to eq("world")
       end
 
-      context "Selenium" do
+      context "with Selenium" do
         before { skip unless context.strategy.is_a?(Wayfarer::Networking::Selenium) }
 
         it "sets a mock status code" do
@@ -74,21 +83,6 @@ RSpec.shared_examples "Network strategy" do |options|
         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]
@@ -103,29 +97,29 @@ RSpec.shared_examples "Network strategy" do |options|
 
     describe "#live" do
       context "when automating a browser" do
-        let(:url) { test_app_path("/body/foobar") }
+        subject(:page) { context.live.page }
+
+        let(:url) { test_app_path("hello_world") }
 
         before do
           skip unless options[:browser]
 
-          context.fetch(test_app_path("/hello_world"))
+          context.fetch(url)
           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/)
+          expect(page.body).to match(/Hello world/)
         end
 
         it "sets response headers" do
           skip unless options[:response_headers]
 
-          expect(page.headers["content-length"]).to eq("6")
+          expect(page.headers["content-length"]).to eq("12")
         end
 
         it "sets the status code" do
@@ -139,31 +133,16 @@ RSpec.shared_examples "Network strategy" do |options|
         it "returns nil" do
           skip if options[:browser]
 
-          expect(context.live).to be(nil)
+          expect(context.live).to be_nil
         end
       end
     end
 
     describe "#renew" do
-      it "replaces the instance", foo: true do
+      it "replaces the instance" 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)
+        }.to(change(context, :instance))
       end
     end
   end

data/spec/{page_spec.rb → wayfarer/page_spec.rb}

@@ -4,10 +4,10 @@ require "spec_helpers"
 
 describe Wayfarer::Page do
   describe "#mime_type" do
-    let(:headers) { { "Content-Type" => "text/html; charset=UTF-8" } }
-
     subject { build(:page, headers: headers).mime_type }
 
+    let(:headers) { { "Content-Type" => "text/html; charset=UTF-8" } }
+
     it { is_expected.to eq("text/html") }
   end
 
@@ -15,7 +15,7 @@ describe Wayfarer::Page do
     context "when Content-Type is absent" do
       subject { build(:page, :html, headers: {}).doc }
 
-      it { is_expected.to be(nil) }
+      it { is_expected.to be_nil }
     end
 
     context "when Content-Type is HTML" do

data/spec/{parsing → wayfarer/parsing}/json_spec.rb

@@ -3,7 +3,7 @@
 require "spec_helpers"
 
 describe Wayfarer::Parsing::JSON do
-  subject(:parser) { Wayfarer::Parsing::JSON }
+  subject(:parser) { described_class }
 
   describe ".parse" do
     it "returns a Hash" do

data/spec/{parsing/xml_spec.rb → wayfarer/parsing/xml_parse_spec.rb}

@@ -3,10 +3,11 @@
 require "spec_helpers"
 
 describe Wayfarer::Parsing::XML, ".parse" do
+  subject(:doc) { described_class.parse(xml, variant) }
+
   let(:xml) { "<span>Foobar</span>" }
-  subject(:doc) { Wayfarer::Parsing::XML.parse(xml, variant) }
 
-  context "HTML" do
+  context "with HTML" do
     let(:variant) { :html }
 
     specify do
@@ -14,7 +15,7 @@ describe Wayfarer::Parsing::XML, ".parse" do
     end
   end
 
-  context "XML" do
+  context "with XML" do
     let(:variant) { :xml }
 
     specify do

data/spec/{redis → wayfarer/redis}/barrier_spec.rb

@@ -2,9 +2,10 @@
 
 require "spec_helpers"
 
-describe Wayfarer::Redis::Barrier, redis: true do
+describe Wayfarer::Redis::Barrier, :redis do
+  subject(:barrier) { build(:barrier, task: task) }
+
   let(:task) { build(:task, :redis_pool) }
-  subject(:barrier) { Wayfarer::Redis::Barrier.new(task) }
 
   describe "#redis_key" do
     it "returns the expected Redis key" do
@@ -24,13 +25,13 @@ describe Wayfarer::Redis::Barrier, redis: true do
     context "with seen URL" do
       before { barrier.check!(task.url) }
 
-      it "returns true" do
+      specify do
         expect(barrier.check!(task.url)).to be(true)
       end
     end
 
     context "with unseen URL" do
-      it "returns false" do
+      specify do
         expect(barrier.check!(task.url)).to be(false)
       end
     end

data/spec/wayfarer/redis/counter_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Redis::Counter, :redis do
+  subject(:counter) { build(:counter, task: task) }
+
+  let(:task) { build(:task, :redis_pool) }
+
+  describe "#redis_key" do
+    specify do
+      expect(counter.redis_key).to eq("wayfarer-counter-batch")
+    end
+  end
+
+  describe "#increment" do
+    specify do
+      expect { counter.increment }.to change(counter, :value).by(1)
+    end
+  end
+
+  describe "#decrement" do
+    specify 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 → wayfarer/redis}/pool_spec.rb

@@ -2,9 +2,10 @@
 
 require "spec_helpers"
 
-describe Wayfarer::Redis::Pool, redis: true do
+describe Wayfarer::Redis::Pool, :redis do
+  subject(:pool) { described_class.send(:new) }
+
   let(:conn) { spy }
-  subject(:pool) { Wayfarer::Redis::Pool.send(:new) }
 
   describe "::with" do
     before do

data/spec/{routing → wayfarer/routing}/dsl_spec.rb

@@ -4,18 +4,17 @@ require "spec_helpers"
 
 describe Wayfarer::Routing::DSL do
   subject(:root) { Wayfarer::Routing::RootRoute.new }
+
   let(:child) { root.children.first }
+  let(:path_finder) { build(:path_finder, url: "http://example.com/alpha/beta") }
 
   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)
+      expect(root.to(:foobar)).to be(child)
 
-      %w[http://example.com http://w3c.org http://google.com].each do |url|
-        expect(child.matcher.match(url)).to be(true)
-      end
+      expect(child.action(path_finder)).to be(:foobar)
+      expect(child.matcher).to be_nil
+      expect(child.parent).to be(root)
     end
   end
 
@@ -23,7 +22,7 @@ describe Wayfarer::Routing::DSL 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.matcher.url.to_s).to eq("http://example.com")
       expect(child.parent).to be(root)
     end
   end
@@ -41,14 +40,14 @@ describe Wayfarer::Routing::DSL 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.matcher.pattern.expand).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(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)
@@ -64,28 +63,19 @@ describe Wayfarer::Routing::DSL do
     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(root.custom { |_url, root| root }).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
+  describe "routing tree" do
     it "constructs the expected tree" do
       root.host "example.com", path: "/foo" do
-        query foo: 4, bar: 2
+        query({ foo: 4, bar: 2 })
       end
 
       expect(root.children.count).to be(1)

data/spec/wayfarer/routing/hash_stack_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+RSpec.describe Wayfarer::Routing::HashStack do
+  subject(:hash_stack) { described_class.new(initial_state) }
+
+  let(:initial_state) { { foo: "bar" } }
+
+  describe "::empty" do
+    subject { described_class.empty.to_h }
+
+    it { is_expected.to be_empty }
+  end
+
+  describe "#to_h" do
+    it { is_expected.to have_attributes(to_h: { foo: "bar" }) }
+
+    context "with push" do
+      before { hash_stack.push(bar: "baz") }
+
+      it { is_expected.to have_attributes(to_h: { foo: "bar", bar: "baz" }) }
+    end
+
+    context "with multiple pushes" do
+      before do
+        hash_stack.push(bar: "baz")
+        hash_stack.push(baz: "qux")
+      end
+
+      it { is_expected.to have_attributes(to_h: { foo: "bar", bar: "baz", baz: "qux" }) }
+    end
+  end
+
+  describe "#push" do
+    before { hash_stack.push(bar: "baz") }
+
+    it "does not mutate previous stack entries" do
+      expect {
+        hash_stack.pop
+      }.to change(hash_stack, :to_h).from({ foo: "bar", bar: "baz" }).to({ foo: "bar" })
+    end
+  end
+
+  describe "#pop" do
+    context "with one element on the stack" do
+      before { hash_stack.pop }
+
+      it "raises when popping past the bottom" do
+        expect { hash_stack.pop }.to raise_error(described_class::EmptyStackError)
+      end
+    end
+
+    context "with multiple elements" do
+      before do
+        hash_stack.push(bar: "baz")
+        hash_stack.pop
+      end
+
+      it { is_expected.to have_attributes(to_h: { foo: "bar" }) }
+    end
+  end
+end

data/spec/wayfarer/routing/integration_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::DSL do # rubocop:disable RSpec/SpecFilePathFormat
+  let(:route) { Wayfarer::Routing::RootRoute.new }
+
+  shared_examples "routes" do |matches:, mismatches:|
+    def invoke(route, url)
+      route.invoke(build(:task, :uri, url: url))
+    end
+
+    matches.each do |url|
+      specify do
+        expect(invoke(route, url)).to be_a(Wayfarer::Routing::Result::Match)
+      end
+    end
+
+    mismatches.each do |url|
+      specify do
+        expect(invoke(route, url)).to be_a(Wayfarer::Routing::Result::Mismatch)
+      end
+    end
+  end
+
+  describe "root path matching" do
+    before { route.path "/" }
+
+    it_behaves_like "routes",
+                    matches: ["https://example.com/"],
+                    mismatches: ["https://example.com/foo"]
+  end
+
+  describe "host and path" do
+    before { route.host "example.com", path: "/foo" }
+
+    it_behaves_like "routes",
+                    matches: ["https://example.com/foo"],
+                    mismatches: ["https://example.com/bar"]
+  end
+
+  describe "query constraints" do
+    before do
+      route.host "example.com", path: "/foo" do
+        query({ page: 1..10 })
+      end
+    end
+
+    it_behaves_like "routes",
+                    matches: ["https://example.com/foo?page=4"],
+                    mismatches: [
+                      "https://example.com/foo?page=11",
+                      "https://example.com/foo",
+                      "https://example.com?page=2"
+                    ]
+  end
+
+  describe "multiple paths under host" do
+    before do
+      route.host "example.com" do
+        path "/contact"
+        path "/users/:id"
+      end
+    end
+
+    it_behaves_like "routes",
+                    matches: [
+                      "https://example.com/contact",
+                      "https://example.com/users/123"
+                    ],
+                    mismatches: [
+                      "https://example.com/contact/foo",
+                      "https://example.com/users/123/images",
+                      "https://example.com/users"
+                    ]
+  end
+
+  describe "nested routing structure" do
+    before do
+      route.host "example.com" do
+        path "/contact"
+        path "/users/:user_id" do
+          path "/images/:id"
+          path "/friends"
+        end
+      end
+    end
+
+    it_behaves_like "routes",
+                    matches: [
+                      "https://example.com/contact",
+                      "https://example.com/users/123/images/23",
+                      "https://example.com/users/123/friends"
+                    ],
+                    mismatches: [
+                      "https://example.com/users/123",
+                      "https://example.com/users/123/images/23/foo",
+                      "https://example.com/users/123/foobar"
+                    ]
+  end
+end