wayfarer 0.4.6 → 0.4.8

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,13 +2,14 @@
 
 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
-      Wayfarer.config.redis.factory = ->(_) { conn }
+      Wayfarer.config[:redis][:factory] = ->(_) { conn }
     end
 
     it "instantiates the factory and yields" 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

data/spec/wayfarer/routing/matchers/custom_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+require_relative "matcher"
+
+describe Wayfarer::Routing::Matchers::Custom do
+  subject(:matcher) { described_class.new(delegate) }
+
+  let(:url) { "https://example.com" }
+  let(:path_finder) { build(:path_finder, url: url) }
+
+  shared_examples "returns root" do
+    subject(:result) { matcher.evaluate(path_finder) }
+
+    it { is_expected.to be_a(Wayfarer::Routing::RootRoute) }
+  end
+
+  context "when matching" do
+    let(:delegate) { ->(route, _uri, _task) { route.to(:foobar) } }
+
+    it_behaves_like "returns root"
+    it_behaves_like "params", {}
+  end
+
+  context "when mismatching" do
+    let(:delegate) { ->(route, _uri, _task) { route } }
+
+    it_behaves_like "returns root"
+    it_behaves_like "params", {}
+  end
+
+  describe "#to_h" do
+    subject { matcher.to_h }
+
+    let(:delegate) { -> {} }
+
+    it { is_expected.to eq(custom: "Proc") }
+  end
+end

data/spec/wayfarer/routing/matchers/host_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+require_relative "matcher"
+
+describe Wayfarer::Routing::Matchers::Host do
+  # rubocop:disable RSpec/DescribedClass
+  subject(:matcher) { Wayfarer::Routing::Matchers::Host.new(str_or_regexp) }
+  # rubocop:enable RSpec/DescribedClass
+
+  let(:path_finder) { build(:path_finder, url: url) }
+
+  context String do
+    let(:str_or_regexp) { "example.com" }
+
+    context "when matching" do
+      let(:url) { "http://example.com/foo/bar" }
+
+      it_behaves_like "matches", true
+      it_behaves_like "params", {}
+    end
+
+    context "when mismatching" do
+      let(:url) { "http://google.com/bar/qux" }
+
+      it_behaves_like "matches", false
+      it_behaves_like "params", {}
+    end
+  end
+
+  context Regexp do
+    let(:str_or_regexp) { /example.com/ }
+
+    context "when matching" do
+      let(:url) { "http://sub.example.com" }
+
+      it_behaves_like "matches", true
+      it_behaves_like "params", {}
+    end
+
+    context "when mismatching" do
+      let(:url) { "http://example.sub.com" }
+
+      it_behaves_like "matches", false
+      it_behaves_like "params", {}
+    end
+  end
+
+  describe "#to_h" do
+    subject { matcher.to_h }
+
+    let(:str_or_regexp) { "" }
+
+    it { is_expected.to eq(name: str_or_regexp) }
+  end
+end

data/spec/wayfarer/routing/matchers/matcher.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+RSpec.shared_examples "matches" do |expected|
+  subject(:result) { matcher.evaluate(path_finder) }
+
+  it { is_expected.to be(expected) }
+end
+
+RSpec.shared_examples "params" do |expected_params|
+  describe "params" do
+    subject { matcher.params(path_finder) }
+
+    it { is_expected.to eq(expected_params) }
+  end
+end

data/spec/wayfarer/routing/matchers/path_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+require_relative "matcher"
+
+describe Wayfarer::Routing::Matchers::Path do
+  subject(:matcher) { described_class.new(path) }
+
+  let(:route) { Wayfarer::Routing::RootRoute.new }
+  let(:path_finder) { build(:path_finder, url: "http://example.com/alpha/beta") }
+
+  context "with valid consumer state" do
+    let(:path) { ":foo/:bar" }
+    let(:route) { Wayfarer::Routing::RootRoute.new.path(path) }
+
+    before do
+      path_finder.enter(route)
+    end
+
+    it_behaves_like "matches", true
+    it_behaves_like "params", { "foo" => "alpha", "bar" => "beta" }
+  end
+
+  context "with invalid consumer state" do
+    let(:path) { ":foo/:bar/:qux" }
+    let(:route) { Wayfarer::Routing::RootRoute.new.path(path) }
+
+    before do
+      path_finder.enter(route)
+    end
+
+    it_behaves_like "matches", false
+    it_behaves_like "params", {}
+  end
+
+  describe "#to_h" do
+    subject { matcher.to_h }
+
+    let(:path) { "/" }
+
+    it { is_expected.to eq(pattern: path) }
+  end
+end

data/spec/wayfarer/routing/matchers/query_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+require_relative "matcher"
+
+describe Wayfarer::Routing::Matchers::Query do
+  # rubocop:disable RSpec/DescribedClass
+  subject(:matcher) { Wayfarer::Routing::Matchers::Query.new(fields) }
+  # rubocop:enable RSpec/DescribedClass
+
+  let(:path_finder) { build(:path_finder, url: url) }
+
+  context String do
+    let(:fields) { { arg: "foo" } }
+
+    context "when matching" do
+      let(:url) { "http://example.com?arg=foo" }
+
+      it_behaves_like "matches", true
+      it_behaves_like "params", { "arg" => "foo" }
+    end
+
+    context "when mismatching" do
+      let(:url) { "http://example.com?arg=bar" }
+
+      it_behaves_like "matches", false
+      it_behaves_like "params", {}
+    end
+  end
+
+  context Integer do
+    let(:fields) { { arg: 0 } }
+
+    context "when matching" do
+      let(:url) { "http://example.com?arg=0" }
+
+      it_behaves_like "matches", true
+      it_behaves_like "params", { "arg" => "0" }
+    end
+
+    %w[http://example.com?arg=1 http://example.com?arg=foo].each do |url|
+      context "when mismatching" do
+        let(:url) { url }
+
+        it_behaves_like "matches", false
+        it_behaves_like "params", {}
+      end
+    end
+  end
+
+  context Regexp do
+    let(:fields) { { arg: /foo/ } }
+
+    context "when matching" do
+      let(:url) { "http://example.com?arg=foobar" }
+
+      it_behaves_like "matches", true
+      it_behaves_like "params", { "arg" => "foobar" }
+    end
+
+    context "when mismatching" do
+      let(:url) { "http://example.com?arg=bar" }
+
+      it_behaves_like "matches", false
+      it_behaves_like "params", {}
+    end
+  end
+
+  context Range do
+    let(:fields) { { arg: 1..10 } }
+
+    context "when absent" do
+      let(:url) { "http://example.com" }
+
+      it_behaves_like "matches", false
+      it_behaves_like "params", {}
+    end
+
+    context "when matching" do
+      let(:url) { "http://example.com?arg=5" }
+
+      it_behaves_like "matches", true
+      it_behaves_like "params", { "arg" => "5" }
+    end
+
+    %w[http://example.com?arg=11 http://example.com?arg=foo&bar=qux].each do |url|
+      context "when mismatching" do
+        let(:url) { url }
+
+        it_behaves_like "matches", false
+        it_behaves_like "params", {}
+      end
+    end
+  end
+
+  context "with multiple fields" do
+    let(:fields) do
+      { foo: 1..5, bar: /baz/, qux: "zot", toto: 2 }
+    end
+
+    context "when matching" do
+      let(:url) { "http://example.com?foo=4&bar=bazqux&qux=zot&toto=2" }
+
+      it_behaves_like "matches", true
+      it_behaves_like "params", "foo" => "4", "bar" => "bazqux", "qux" => "zot", "toto" => "2"
+    end
+
+    context "when mismatching" do
+      let(:url) { "http://example.com?foo=bar&bar=qux&qux=6&toto=0" }
+
+      it_behaves_like "matches", false
+      it_behaves_like "params", {}
+    end
+  end
+
+  describe "#to_h" do
+    subject { matcher.to_h }
+
+    let(:fields) { { foo: "bar", bar: 42, qux: /foo/, zet: 1..3 } }
+
+    it { is_expected.to eq(foo: "bar", bar: 42, qux: "/foo/", zet: { min: 1, max: 3 }) }
+  end
+end

data/spec/wayfarer/routing/matchers/scheme_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+require_relative "matcher"
+
+describe Wayfarer::Routing::Matchers::Scheme do
+  # rubocop:disable RSpec/DescribedClass
+  subject(:matcher) { Wayfarer::Routing::Matchers::Scheme.new(scheme) }
+  # rubocop:enable RSpec/DescribedClass
+
+  let(:url) { "http://example.com" }
+  let(:path_finder) { build(:path_finder, url: url) }
+
+  context Symbol do
+    context "when matching" do
+      let(:scheme) { :http }
+
+      it_behaves_like "matches", true
+      it_behaves_like "params", {}
+    end
+
+    context "when mismatching" do
+      let(:scheme) { :https }
+
+      it_behaves_like "matches", false
+      it_behaves_like "params", {}
+    end
+  end
+
+  context String do
+    context "when matching" do
+      let(:scheme) { "http" }
+
+      it_behaves_like "matches", true
+      it_behaves_like "params", {}
+    end
+
+    context "when mismatching" do
+      let(:scheme) { "https" }
+
+      it_behaves_like "matches", false
+      it_behaves_like "params", {}
+    end
+  end
+end

data/spec/wayfarer/routing/matchers/url_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+require_relative "matcher"
+
+describe Wayfarer::Routing::Matchers::URL do
+  subject(:matcher) { described_class.new(matcher_url) }
+
+  let(:url) { "http://example.com/foo/bar" }
+  let(:path_finder) { build(:path_finder, url: url) }
+
+  context "when matching" do
+    let(:matcher_url) { url }
+
+    it_behaves_like "matches", true
+    it_behaves_like "params", {}
+  end
+
+  context "when mismatching" do
+    let(:matcher_url) { "https://example.com" }
+
+    it_behaves_like "matches", false
+    it_behaves_like "params", {}
+  end
+
+  describe "#to_h" do
+    subject { matcher.to_h }
+
+    let(:matcher_url) { "https://example.com" }
+
+    it { is_expected.to eq(url: matcher_url) }
+  end
+end