wayfarer 0.4.6 → 0.4.8

data/spec/wayfarer/routing/path_consumer_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+RSpec.describe Wayfarer::Routing::PathConsumer do
+  subject(:consumer) { described_class.new(input_path) }
+
+  let(:input_path) { "users/42" }
+
+  let(:dummy_matcher_class) do
+    Class.new(Wayfarer::Routing::Matchers::Path) do
+      attr_reader :pattern
+
+      def initialize(pattern) # rubocop:disable Lint/MissingSuper
+        @pattern = pattern
+      end
+    end
+  end
+
+  let(:match_data) do
+    instance_double(MatchData, to_s: "/users/42", named_captures: { "id" => "42" })
+  end
+
+  let(:pattern_double) do
+    instance_double(Mustermann::AST::Pattern, peek_match: match_data)
+  end
+
+  let(:matcher) { dummy_matcher_class.new(pattern_double) }
+
+  let(:fake_route) { instance_double(Wayfarer::Routing::Route, matcher: matcher) }
+
+  describe "initial state" do
+    it { is_expected.to have_attributes(path: "/users/42") }
+
+    it "starts with one consumption state" do
+      expect(consumer.send(:states).size).to eq 1
+    end
+
+    it "has no offset and is valid", :aggregate_failures do
+      state = consumer.send(:current_state)
+      expect(state.offset).to be_nil
+      expect(state.params).to eq({})
+      expect(state.valid?).to be true
+    end
+  end
+
+  describe "#valid?" do
+    context "when nothing is consumed" do
+      it { is_expected.to be_valid }
+    end
+
+    context "when fully consumed" do
+      before { consumer.push(fake_route) }
+
+      it { is_expected.to be_valid }
+    end
+
+    context "when partially consumed and not at start" do
+      before do
+        allow(match_data).to receive_messages(to_s: "/users", named_captures: {})
+        consumer.push(fake_route)
+      end
+
+      it { is_expected.not_to be_valid }
+    end
+
+    context "when current state is invalid" do
+      before do
+        allow(pattern_double).to receive(:peek_match).and_return(nil)
+        consumer.push(fake_route)
+      end
+
+      it { is_expected.not_to be_valid }
+    end
+  end
+
+  describe "#push" do
+    context "when route matcher is not a Path" do
+      let(:matcher) { Object.new }
+
+      it "does not change offset or validity" do
+        expect {
+          consumer.push(instance_double(Wayfarer::Routing::Route, matcher: matcher))
+        }.not_to(change { consumer.send(:current_state).offset })
+
+        expect(consumer).to be_valid
+      end
+    end
+
+    context "when route matcher is a Path and the sub_path matches" do
+      before { consumer.push(fake_route) }
+
+      it "updates offset and merges captured params" do
+        current = consumer.send(:current_state)
+        expect(current.offset).to eq("/users/42".length)
+        expect(current.params).to eq("id" => "42")
+        expect(current.valid?).to be true
+      end
+    end
+
+    context "when route matcher is a Path but it fails to match" do
+      before do
+        allow(pattern_double).to receive(:peek_match).and_return(nil)
+        consumer.push(fake_route)
+      end
+
+      it "invalidates the new state" do
+        expect(consumer.send(:current_state).valid?).to be false
+      end
+    end
+  end
+
+  describe "#pop" do
+    before { consumer.push(fake_route) }
+
+    it "reverts to the previous state" do
+      expect {
+        consumer.pop
+      }.to change { consumer.send(:states).size }.by(-1)
+      expect(consumer.send(:current_state).offset).to be_nil
+    end
+  end
+end

data/spec/wayfarer/routing/path_finder_spec.rb

@@ -0,0 +1,409 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::PathFinder do
+  subject(:result) { described_class.result(route, task) }
+
+  let(:route) { Wayfarer::Routing::RootRoute.new }
+  let(:task) { build(:task, :uri, url: input_url) }
+
+  shared_examples "matches" do |url, action, params = Wayfarer::Routing::Route::EMPTY_PARAMS|
+    let(:input_url) { url }
+
+    specify do
+      expect(result).to be_a(Wayfarer::Routing::Result::Match)
+      expect(result.action).to eq(action)
+      expect(result.params).to eq(params)
+    end
+  end
+
+  shared_examples "mismatches" do |url|
+    let(:input_url) { url }
+
+    it { is_expected.to be_a(Wayfarer::Routing::Result::Mismatch) }
+  end
+
+  context "without child routes" do
+    it_behaves_like "mismatches", "https://example.com/foo"
+    it_behaves_like "mismatches", "http://w3c.org#foobar"
+    it_behaves_like "mismatches", "localhost"
+    it_behaves_like "mismatches", "https://example.com:8080/foo"
+    it_behaves_like "mismatches", "http://127.0.0.1/foo"
+    it_behaves_like "mismatches", "./foo"
+  end
+
+  context "with single root action" do
+    before { route.to(:bar) }
+
+    it_behaves_like "matches", "https://example.com", :bar
+    it_behaves_like "matches", "https://example.com/foo", :bar
+    it_behaves_like "matches", "http://localhost?foo=bar", :bar
+    it_behaves_like "matches", "http://localhost#foobar", :bar
+    it_behaves_like "matches", "https://example.com:3000?test=123", :bar
+  end
+
+  context "with multiple root actions" do
+    before { route.to(:alpha).to(:beta) }
+
+    it_behaves_like "matches", "https://example.com", :beta
+    it_behaves_like "matches", "https://example.com/foo", :beta
+    it_behaves_like "matches", "http://localhost?foo=bar", :beta
+    it_behaves_like "matches", "http://localhost#foobar", :beta
+    it_behaves_like "matches", "https://example.com/#top", :beta
+  end
+
+  context "with literal root path with root action" do
+    before { route.path("/").to(:root) }
+
+    it_behaves_like "matches", "https://example.com", :root
+    it_behaves_like "matches", "https://example.com/", :root
+    it_behaves_like "matches", "https://example.com:8000", :root
+    it_behaves_like "matches", "https://example.com:8000/", :root
+    it_behaves_like "matches", "http://localhost?foo=bar", :root
+    it_behaves_like "matches", "http://localhost#foobar", :root
+    it_behaves_like "matches", "https://example.com//", :root
+
+    it_behaves_like "mismatches", "https://example.com/test"
+    it_behaves_like "mismatches", "https://w3c.org/foo/bar"
+  end
+
+  context "with path segments" do
+    before { route.path("/").path(":segment").path("/").to(:root) }
+
+    it_behaves_like "matches", "https://example.com/test", :root, { "segment" => "test" }
+    it_behaves_like "matches", "https://example.com/test/", :root, { "segment" => "test" }
+    it_behaves_like "matches", "http://localhost/test?foo=bar", :root, { "segment" => "test" }
+    it_behaves_like "matches", "http://localhost/test/#foobar", :root, { "segment" => "test" }
+    it_behaves_like "matches", "https://example.com/%20/", :root, { "segment" => "%20" }
+
+    it_behaves_like "mismatches", "https://example.com/foo/bar"
+    it_behaves_like "mismatches", "http://localhost:8000/foo/bar"
+  end
+
+  context "with multiple child rules" do
+    before do
+      route.path("foo").to(:foo)
+      route.path("bar").to(:bar)
+    end
+
+    it_behaves_like "matches", "http://0.0.0.0/foo", :foo
+    it_behaves_like "matches", "http://0.0.0.0/bar", :bar
+    it_behaves_like "matches", "http://0.0.0.0/foo/", :foo
+
+    it_behaves_like "mismatches", "http://0.0.0.0/qux"
+  end
+
+  context "when matching a specific URL exactly" do
+    before { route.url("https://example.com").to(:index) }
+
+    it_behaves_like "matches", "https://example.com", :index
+    it_behaves_like "matches", "https://example.com/", :index
+
+    it_behaves_like "mismatches", "http://example.com"
+    it_behaves_like "mismatches", "https://example.com?foo=bar"
+    it_behaves_like "mismatches", "https://example.com#fragmen"
+    it_behaves_like "mismatches", "https://example.com:8080"
+  end
+
+  context "with query parameters" do
+    before { route.query({ foo: "bar" }).to(:index) }
+
+    it_behaves_like "matches", "https://example.com?foo=bar", :index, { "foo" => "bar" }
+    it_behaves_like "matches", "https://example.com/test?bar=qux&foo=bar", :index, { "foo" => "bar" }
+    it_behaves_like "matches", "https://example.com?foo=bar&extra=1", :index, { "foo" => "bar" }
+
+    it_behaves_like "mismatches", "https://example.com"
+    it_behaves_like "mismatches", "https://example.com?foo=qux"
+  end
+
+  context "with multiple query parameters" do
+    before { route.to(:index).query({ foo: "bar" }).query({ page: 10 }) }
+
+    it_behaves_like "matches", "https://example.com?foo=bar&page=10", :index, { "foo" => "bar", "page" => "10" }
+    it_behaves_like "matches",
+                    "https://example.com/test?bar=qux&page=10&foo=bar",
+                    :index,
+                    { "foo" => "bar", "page" => "10" }
+    it_behaves_like "matches",
+                    "https://example.com?foo=bar&foo=bar&page=10",
+                    :index,
+                    { "foo" => "bar", "page" => "10" }
+
+    it_behaves_like "mismatches", "https://example.com?foo=qux"
+    it_behaves_like "mismatches", "https://example.com?page=10"
+    it_behaves_like "mismatches", "https://example.com?page=10&foo=qux"
+  end
+
+  context "with regular expression query parameter constraint" do
+    before { route.to(:alpha).query({ foo: /ooba/, page: 5..12 }).to(:beta) }
+
+    it_behaves_like "matches",
+                    "https://example.com?foo=foobar&page=9",
+                    :beta,
+                    { "foo" => "foobar", "page" => "9" }
+    it_behaves_like "matches",
+                    "https://example.com?foo=foobar&page=5",
+                    :beta,
+                    { "foo" => "foobar", "page" => "5" }
+    it_behaves_like "matches",
+                    "https://example.com?foo=foobar&page=12",
+                    :beta,
+                    { "foo" => "foobar", "page" => "12" }
+
+    it_behaves_like "mismatches", "https://example.com?foo=foobar&page=ten"
+    it_behaves_like "mismatches", "https://example.com?foo=foobar&page=4"
+    it_behaves_like "mismatches", "https://example.com?foo=foobar&page=13"
+    it_behaves_like "mismatches", "https://example.com?foobar=qux"
+    it_behaves_like "mismatches", "https://example.com?page=10"
+    it_behaves_like "mismatches", "https://example.com?page=10&foo=qux"
+  end
+
+  context "with scheme" do
+    before do
+      route.scheme(:https).to(:foo)
+      route.scheme(:http).to(:bar)
+    end
+
+    it_behaves_like "matches", "https://example.com", :foo
+    it_behaves_like "matches", "http://w3c.org", :bar
+    it_behaves_like "matches", "https://example.com/test", :foo
+
+    it_behaves_like "mismatches", "ftp://example.com"
+    # TODO: Route normalized URL
+    it_behaves_like "mismatches", "HTTP://w3c.org"
+  end
+
+  context "with custom route and potentially `nil` action" do
+    before do
+      route.host("example.com").custom do |root, uri|
+        root.to(:index) if uri.path == "/foo/bar"
+      end
+    end
+
+    it_behaves_like "matches", "https://example.com/foo/bar", :index
+
+    it_behaves_like "mismatches", "https://example.com"
+    it_behaves_like "mismatches", "https://example.com/foo/bar/"
+  end
+
+  context "with custom route and path segments" do
+    before do
+      route.host("example.com").custom do |root, _uri|
+        root.path(":alpha/:beta").to(:index)
+      end
+    end
+
+    it_behaves_like "matches", "https://example.com/foo/bar", :index, { "alpha" => "foo", "beta" => "bar" }
+
+    it_behaves_like "mismatches", "https://example.com"
+    it_behaves_like "mismatches", "https://example.com/foo/bar/baz"
+  end
+
+  context "with overriding action from custom route" do
+    before do
+      route.host("example.com").path(":foo").to(:alpha).custom do |root, _uri, _task|
+        root.path(":bar").to(:beta)
+      end
+    end
+
+    it_behaves_like "matches",
+                    "https://example.com/alpha/beta",
+                    :beta,
+                    { "foo" => "alpha", "bar" => "beta" }
+
+    it_behaves_like "mismatches", "https://example.com"
+    it_behaves_like "mismatches", "https://example.com/alpha/"
+  end
+
+  context "with regular expression host and multiple child rules" do
+    before do
+      route.host(/example.com/) do
+        path "users/:id", query: { display: "gallery" }, to: :gallery
+        path "users/:id", to: :user
+      end
+    end
+
+    it_behaves_like "matches", "https://example.com/users/123", :user, { "id" => "123" }
+    it_behaves_like "matches",
+                    "https://example.com/users/123?display=gallery",
+                    :gallery,
+                    { "id" => "123", "display" => "gallery" }
+    it_behaves_like "matches", "https://sub.example.com/users/456", :user, { "id" => "456" }
+
+    it_behaves_like "mismatches", "https://example.com"
+    it_behaves_like "mismatches", "https://example.com/users"
+    it_behaves_like "mismatches", "https://example.com/users/"
+    it_behaves_like "mismatches", "https://example.co/users/123"
+  end
+
+  context "with protocol-relative URL" do
+    before { route.host("example.com").to(:index) }
+
+    it_behaves_like "mismatches", "//example.com"
+    it_behaves_like "mismatches", "//example.com/foo"
+    it_behaves_like "mismatches", "//example.com:3000/subdir"
+    it_behaves_like "mismatches", "/only-path"
+  end
+
+  context "with duplicate query parameters" do
+    before { route.query({ foo: "bar" }).to(:index) }
+
+    it_behaves_like "matches", "https://example.com?foo=bar", :index, { "foo" => "bar" }
+    it_behaves_like "matches", "https://example.com?foo=bar&foo=baz", :index, { "foo" => "baz" }
+    it_behaves_like "matches", "https://example.com?foo=bar&foo=bar", :index, { "foo" => "bar" }
+    it_behaves_like "matches", "https://example.com?foo=bar&foo=", :index, { "foo" => "" }
+
+    it_behaves_like "mismatches", "https://example.com?foo="
+  end
+
+  context "with overlapping routes" do
+    before do
+      route.path("users").to(:users_index)
+      route.path("users").path(":id").to(:user_show)
+    end
+
+    it_behaves_like "matches", "https://example.com/users", :users_index
+    it_behaves_like "matches", "https://example.com/users/", :users_index
+    it_behaves_like "matches", "https://example.com/users?foo=bar", :users_index
+    it_behaves_like "matches", "https://example.com/users/123", :user_show, { "id" => "123" }
+    it_behaves_like "matches", "https://example.com/users?foo=bar&bar=baz", :users_index
+    it_behaves_like "matches", "https://example.com/users/456?foo=bar", :user_show, { "id" => "456" }
+
+    it_behaves_like "mismatches", "https://example.com"
+    it_behaves_like "mismatches", "https://example.com/"
+    it_behaves_like "mismatches", "https://example.com/users/123/extra"
+    it_behaves_like "mismatches", "https://example.com/users/123/extra/"
+  end
+
+  context "with file scheme" do
+    before { route.scheme("file").path("home").to(:local_file) }
+
+    it_behaves_like "matches", "file:///home", :local_file
+    it_behaves_like "matches", "file:///home/", :local_file
+
+    it_behaves_like "mismatches", "https:///home"
+    it_behaves_like "mismatches", "file:///Users"
+    it_behaves_like "mismatches", "file://home"
+  end
+
+  context "without URL scheme" do
+    before { route.path("localhost").to(:foo) }
+
+    it_behaves_like "mismatches", "localhost", :foo, {}
+    it_behaves_like "mismatches", "/localhost", :foo, {}
+    it_behaves_like "mismatches", "/localhost/", :foo, {}
+    it_behaves_like "mismatches", "//localhost", :foo, {}
+  end
+
+  context "with host" do
+    before { route.host("localhost").to(:foo) }
+
+    it_behaves_like "matches", "http://localhost", :foo
+    it_behaves_like "matches", "ftp://localhost/foo#bar", :foo
+    it_behaves_like "matches", "http://localhost:8080", :foo
+
+    it_behaves_like "mismatches", "https://127.0.0.1"
+    it_behaves_like "mismatches", "localhost:8000"
+    it_behaves_like "mismatches", "localhost"
+    it_behaves_like "mismatches", "/localhost"
+    it_behaves_like "mismatches", "/localhost/"
+  end
+
+  context "with multiple rules" do
+    before do
+      route.host(/example.com/, path: "/foo") do
+        path "/", to: :foo
+        path ":segment", to: :bar
+      end
+    end
+
+    it_behaves_like "matches", "ftp://sub.example.com/foo", :foo
+    it_behaves_like "matches", "ftp://sub.example.com/foo/qux", :bar, { "segment" => "qux" }
+
+    it_behaves_like "mismatches", "sub.example.com/foo"
+    it_behaves_like "mismatches", "sub.example.com/foo/qux"
+  end
+
+  describe "inline declaration" do
+    before do
+      route.path("/").path("/foo").path(":segment").path("/qux").to(:foo)
+    end
+
+    it_behaves_like "matches", "http://example.com/foo/bar/qux", :foo, "segment" => "bar"
+    it_behaves_like "matches", "http://example.com/foo/bar/qux/", :foo, "segment" => "bar"
+    it_behaves_like "matches", "http://example.com/foo/bar/qux#fragment", :foo, "segment" => "bar"
+    it_behaves_like "matches", "http://example.com//foobar//qux", :foo, "segment" => "bar"
+
+    it_behaves_like "mismatches", "http://example.com"
+    it_behaves_like "mismatches", "http://example.com/foo"
+    it_behaves_like "mismatches", "http://example.com/foo/qux"
+    it_behaves_like "mismatches", "http://sub.example.com/foo/qux"
+  end
+
+  describe "callback" do
+    subject(:result) { described_class.result(route, task, &callback) }
+
+    let(:calls) { [] }
+    let(:callback) do
+      lambda do |route, result, finder|
+        calls.push(route: route,
+                   matcher: route.matcher,
+                   result: result,
+                   params: finder.params_stack.to_h)
+      end
+    end
+
+    let(:route) do
+      Wayfarer::Routing::RootRoute.new.tap do |root|
+        root.host "example.com", scheme: :https do
+          path "contact", to: :contact
+          path "users/:id" do
+            to :foo
+
+            path "gallery", to: :bar
+          end
+        end
+      end
+    end
+
+    let(:task) { build(:task, :uri, url: url) }
+
+    context "with matching URL" do
+      let(:url) { "https://example.com/users/42" }
+
+      it { is_expected.to be_a(Wayfarer::Routing::Result::Match) }
+
+      it "invokes the callback during route matching" do
+        result
+
+        expect(calls).to contain_exactly(
+          a_hash_including(route: instance_of(Wayfarer::Routing::RootRoute)),
+          a_hash_including(matcher: instance_of(Wayfarer::Routing::Matchers::Host)),
+          a_hash_including(matcher: instance_of(Wayfarer::Routing::Matchers::Scheme)),
+          a_hash_including(matcher: instance_of(Wayfarer::Routing::Matchers::Path), result: false),
+          a_hash_including(matcher: instance_of(Wayfarer::Routing::Matchers::Path), result: true),
+          a_hash_including(route: instance_of(Wayfarer::Routing::TargetRoute))
+        )
+      end
+    end
+
+    context "with mismatching URL" do
+      let(:url) { "https://example.com/foo" }
+
+      it { is_expected.to be_a(Wayfarer::Routing::Result::Mismatch) }
+
+      it "invokes the callback during route matching" do
+        result
+
+        expect(calls).to contain_exactly(
+          a_hash_including(route: instance_of(Wayfarer::Routing::RootRoute)),
+          a_hash_including(matcher: instance_of(Wayfarer::Routing::Matchers::Host)),
+          a_hash_including(matcher: instance_of(Wayfarer::Routing::Matchers::Scheme)),
+          a_hash_including(matcher: instance_of(Wayfarer::Routing::Matchers::Path), result: false),
+          a_hash_including(matcher: instance_of(Wayfarer::Routing::Matchers::Path), result: false)
+        )
+      end
+    end
+  end
+end

data/spec/wayfarer/routing/root_route_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::RootRoute do
+  subject(:result) { route.invoke(task) }
+
+  let(:task) { build(:task, :uri, url: url) }
+
+  describe "#invoke" do
+    let(:route) do
+      described_class.new.tap do |root|
+        root.host test_app_hostname do
+          path "test", to: :index
+        end
+      end
+    end
+
+    context "with matching URL" do
+      let(:url) { test_app_path("test") }
+
+      it { is_expected.to be_a(Wayfarer::Routing::Result::Match) }
+    end
+
+    context "with mismatching URL" do
+      let(:url) { test_app_path("mismatch") }
+
+      it { is_expected.to be_a(Wayfarer::Routing::Result::Mismatch) }
+    end
+  end
+
+  describe "#evaluate" do
+    subject(:result) { route.evaluate(path_finder) }
+
+    let(:path_finder) { build(:path_finder, url: "http://example.com") }
+
+    context "with child routes" do
+      let(:route) do
+        described_class.new.tap { |root| root.to(:index) }
+      end
+
+      it { is_expected.to be(true) }
+    end
+
+    context "without child routes" do
+      let(:route) { described_class.new }
+
+      it { is_expected.to be(false) }
+    end
+  end
+end

data/spec/wayfarer/routing/route_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Routing::Route do
+  subject(:result) { root.invoke(task) }
+
+  let(:root) { Wayfarer::Routing::RootRoute.new }
+  let(:task) { build(:task, :uri, url: url) }
+
+  describe "#invoke" do
+    context "when matching" do
+      let(:url) { "http://example.com/foo/bar?page=42" }
+
+      before do
+        root.host "example.com", to: :overridden do
+          path "/:a/:b" do
+            to :overrider, query: { page: 42 }
+          end
+        end
+      end
+
+      it { is_expected.to be_a(Wayfarer::Routing::Result::Match) }
+
+      describe "action" do
+        subject { result.action }
+
+        it { is_expected.to be(:overrider) }
+      end
+
+      describe "params" do
+        subject { result.params }
+
+        it { is_expected.to eq("a" => "foo", "b" => "bar", "page" => "42") }
+      end
+    end
+
+    context "when mismatching" do
+      let(:url) { "http://w3c.org/foo/bar?page=42" }
+
+      before do
+        root.host "example.com", to: :overridden do
+          path "/:a/:b" do
+            query({ page: 42, to: :overrider })
+          end
+        end
+      end
+
+      it { is_expected.to be_a(Wayfarer::Routing::Result::Mismatch) }
+    end
+  end
+
+  describe "custom routing" do
+    let(:url) { "http://example.com" }
+
+    before do
+      root.custom do |route, uri|
+        if uri.to_s == "http://example.com"
+          route.to :foo
+        else
+          route.to :bar
+        end
+      end
+    end
+
+    it { is_expected.to be_a(Wayfarer::Routing::Result::Match) }
+
+    describe "action" do
+      subject { result.action }
+
+      it { is_expected.to be(:foo) }
+    end
+  end
+end