wayfarer-jruby 0.0.1

data/spec/routing/path_rule_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+require "spec_helpers"
+
+describe Wayfarer::Routing::PathRule, mri: true do
+  describe "#matches?" do
+    context "with a string" do
+      subject(:rule) { PathRule.new("/{alpha}/{beta}") }
+
+      context "with matching URI" do
+        let(:uri) { URI("http://example.com/foo/bar") }
+
+        it "returns true" do
+          expect(rule.matches?(uri)).to be true
+        end
+      end
+
+      context "with mismatching URI" do
+        let(:uri) { URI("http://example.com/foo") }
+
+        it "returns false" do
+          expect(rule.matches?(uri)).to be false
+        end
+      end
+    end
+
+    context "with a RegExp" do
+      subject(:rule) { PathRule.new(/\/(\w+)\/(\w+)/) }
+
+      context "with matching URI" do
+        let(:uri) { URI("http://example.com/foo/bar") }
+
+        it "returns true" do
+          expect(rule.matches?(uri)).to be true
+        end
+      end
+
+      context "with mismatching URI" do
+        let(:uri) { URI("http://example.com/foo") }
+
+        it "returns false" do
+          expect(rule.matches?(uri)).to be false
+        end
+      end
+    end
+  end
+
+  describe "#params" do
+    context "with a string" do
+      subject(:rule) { PathRule.new("/{alpha}/{beta}") }
+
+      it "returns the correct parameters" do
+        uri = URI("http://example.com/foo/bar")
+        expect(rule.params(uri)).to eq("alpha" => "foo", "beta" => "bar")
+      end
+    end
+
+    context "with a RegExp" do
+      subject(:rule) { PathRule.new(/\/(\w+)\/(\w+)/) }
+
+      it "returns the correct parameters" do
+        uri = URI("http://example.com/foo/bar")
+        expect(rule.params(uri)).to eq("0" => "foo", "1" => "bar")
+      end
+    end
+  end
+end

data/spec/routing/query_rule_spec.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+require "spec_helpers"
+
+describe Wayfarer::Routing::QueryRule do
+  subject(:rule) { QueryRule.new(constraints) }
+
+  describe "String constraints" do
+    let(:constraints) { Hash[arg: "foo"] }
+
+    context "with matching query field value" do
+      let(:uri) { URI("http://example.com?arg=foo") }
+
+      it "returns true" do
+        expect(rule.matches?(uri)).to be true
+      end
+    end
+
+    context "with mismatching query field value" do
+      let(:uri) { URI("http://example.com?arg=bar") }
+
+      it "returns false" do
+        expect(rule.matches?(uri)).to be false
+      end
+    end
+  end
+
+  describe "Integer constraints" do
+    let(:constraints) { Hash[arg: 0] }
+
+    context "with matching query field value" do
+      let(:uri) { URI("http://example.com?arg=0") }
+
+      it "returns true" do
+        expect(rule.matches?(uri)).to be true
+      end
+    end
+
+    context "with mismatching query field value" do
+      let(:uri) { URI("http://example.com?arg=1") }
+
+      it "returns false" do
+        expect(rule.matches?(uri)).to be false
+      end
+    end
+
+    context "with non-numeric query field value" do
+      let(:uri) { URI("http://example.com?arg=foo") }
+
+      it "returns false" do
+        expect(rule.matches?(uri)).to be false
+      end
+    end
+  end
+
+  describe "Regexp constraints" do
+    let(:constraints) { Hash[arg: /foo/] }
+
+    context "with matching query field value" do
+      let(:uri) { URI("http://example.com?arg=foo") }
+
+      it "returns true" do
+        expect(rule.matches?(uri)).to be true
+      end
+    end
+
+    context "with mismatching query field value" do
+      let(:uri) { URI("http://example.com?arg=bar") }
+
+      it "returns false" do
+        expect(rule.matches?(uri)).to be false
+      end
+    end
+  end
+
+  describe "Range constraints" do
+    let(:constraints) { Hash[arg: 1..10] }
+
+    context "with matching query field value" do
+      let(:uri) { URI("http://example.com?arg=5") }
+
+      it "returns true" do
+        expect(rule.matches?(uri)).to be true
+      end
+    end
+
+    context "with mismatching query field value" do
+      let(:uri) { URI("http://example.com?arg=11") }
+
+      it "returns false" do
+        expect(rule.matches?(uri)).to be false
+      end
+    end
+
+    context "with non-numeric query field value" do
+      let(:uri) { URI("http://example.com?arg=foo") }
+
+      it "returns false" do
+        expect(rule.matches?(uri)).to be false
+      end
+    end
+  end
+
+  describe "Compound constraints" do
+    let(:constraints) do
+      Hash[foo: 1..5, bar: /baz/, qux: "zot", toto: 2]
+    end
+
+    context "with matching query field values" do
+      let(:uri) { URI("http://example.com?foo=4&bar=bazqux&qux=zot&toto=2") }
+
+      it "returns true" do
+        expect(rule.matches?(uri)).to be true
+      end
+    end
+
+    context "with mismatching query field values" do
+      let(:uri) { URI("http://example.com?foo=bar&bar=qux&qux=6toto=0") }
+
+      it "returns false" do
+        expect(rule.matches?(uri)).to be false
+      end
+    end
+  end
+end

data/spec/routing/router_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require "spec_helpers"
+
+describe Wayfarer::Routing::Router do
+  subject(:router) { Router.new }
+
+  describe "#forbid" do
+    it "forbids URIs" do
+      router.forbid(host: "example.com")
+      expect(router.forbids?(URI("http://example.com"))).to be true
+
+      router.forbid { host "google.com" }
+
+      expect(router.forbids?(URI("http://google.com"))).to be true
+      expect(router.allows?(URI("http://google.com"))).to be false
+    end
+  end
+
+  describe "#route" do
+    context "with matching route" do
+      it "returns the registered payload and parameters" do
+        router.host "example.com", path: "/{barqux}", to: :foo
+
+        uri = URI("http://example.com/42")
+        method, params = router.route(uri)
+
+        expect(method).to be :foo
+        expect(params).to eq("barqux" => "42")
+      end
+    end
+
+    context "with mismatching route" do
+      it "returns false" do
+        router.host "example.com", path: "/{barqux}", to: :foo
+
+        uri = URI("http://google.com")
+
+        expect(router.route(uri)).to be false
+      end
+    end
+
+    context "with forbidden URI" do
+      it "returns false" do
+        router.host "example.com", path: "/{barqux}", to: :foo
+        router.forbid.host "example.com"
+
+        uri = URI("http://example.com")
+
+        expect(router.route(uri)).to be false
+      end
+    end
+
+    context "with nested conflicting target actions" do
+      it "returns the expected parameters" do
+        router.host "example.com", to: :foo do
+          path "/{barqux}", to: :bar
+        end
+
+        uri = URI("http://example.com/42")
+        method, params = router.route(uri)
+
+        expect(method).to be :bar
+        expect(params).to eq("barqux" => "42")
+      end
+    end
+  end
+end

data/spec/routing/rule_spec.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+require "spec_helpers"
+
+describe Wayfarer::Routing::Rule do
+  subject(:rule) { Rule.new }
+
+  describe "#initialize" do
+    it "evaluates the Proc in its instance context" do
+      this = nil
+      rule = Rule.new { this = self }
+      expect(this).to be rule
+    end
+
+    it "builds the expected Rule chain from options" do
+      rule = Rule.new(host: "example.com", query: { bar: 42 })
+
+      first  = rule.child_rules.first
+      second = first.child_rules.first
+      third  = second.child_rules.first
+
+      expect(first).to be_a HostRule
+      expect(second).to be_a QueryRule
+    end
+  end
+
+  describe "#params" do
+    it "returns an empty Hash" do
+      expect(rule.params(URI("http://example.com"))).to eq({})
+    end
+  end
+
+  describe "#matching_rule_chain" do
+    let(:uri) { URI("http://example.com/foo/bar") }
+
+    context "with matching Rule" do
+      let(:host_rule_a) { HostRule.new("example.com") }
+      let(:host_rule_b) { HostRule.new("google.com") }
+      let(:path_rule_a) { PathRule.new("/{alpha}/{beta}") }
+      let(:path_rule_b) { PathRule.new("/{gamma}/{delta}") }
+
+      before do
+        host_rule_a.send(:append_child_rule, path_rule_a)
+        host_rule_a.send(:append_child_rule, path_rule_b)
+
+        host_rule_b.send(:append_child_rule, path_rule_a)
+        host_rule_b.send(:append_child_rule, path_rule_b)
+      end
+
+      subject(:rule) do
+        rule = Rule.new
+        rule.send(:append_child_rule, host_rule_a)
+        rule.send(:append_child_rule, host_rule_b)
+        rule
+      end
+
+      it "returns the expected Array" do
+        expect(rule.matching_rule_chain(uri)).to eq [
+          rule, host_rule_a, path_rule_a
+        ]
+      end
+    end
+
+    context "without matching Rule" do
+      subject(:rule) do
+        rule = Rule.new
+        rule.host("yahoo.com")
+        rule.host("google.com")
+        rule
+      end
+
+      it "returns an empty Array" do
+        expect(rule.matching_rule_chain(uri)).to eq []
+      end
+    end
+  end
+
+  describe "#params_from_rule_chain" do
+    let(:uri) { URI("http://example.com/foo/bar") }
+
+    context "with matching Rule" do
+      subject(:rule_chain) do
+        rule = Rule.new
+        rule.host("example.com").path("/{alpha}/{beta}")
+        rule.host("example.com").path("/{foo}/{bar}")
+        rule.matching_rule_chain(uri)
+      end
+
+      it "returns the expected URI parameters" do
+        expect(rule.send(:params_from_rule_chain, rule_chain, uri)).to eq("alpha" => "foo", "beta" => "bar")
+      end
+    end
+  end
+
+  describe "#invoke" do
+    let(:uri) { URI("http://example.com/foo/bar") }
+
+    context "with matching Rule" do
+      subject(:rule) do
+        rule = Rule.new
+        rule.host("example.com").path("/{alpha}/{beta}")
+        rule
+      end
+
+      it "returns a truthy value" do
+        expect(rule.invoke(uri)).to be_truthy
+      end
+
+      it "returns the URI parameters" do
+        _, params = rule.invoke(uri)
+        expect(params).to eq("alpha" => "foo", "beta" => "bar")
+      end
+    end
+
+    context "with mismatching Rule" do
+      subject(:rule) do
+        rule = Rule.new
+        rule.host("google.com").path("/{alpha}/{beta}")
+        rule
+      end
+
+      it "returns false" do
+        expect(rule.invoke(uri)).to be false
+      end
+    end
+  end
+
+  describe "#uri" do
+    it "adds a URIRule as a sub-rule" do
+      rule.uri("http://example.com/foo/bar")
+      expect(rule.child_rules.first).to be_a URIRule
+    end
+
+    it "returns the added URIRule" do
+      expect(rule.uri("http://example.com/foo/bar")).to be_a URIRule
+    end
+  end
+
+  describe "#host" do
+    it "adds a HostRule as a sub-rule" do
+      rule.host("example.com")
+      expect(rule.child_rules.first).to be_a HostRule
+    end
+
+    it "returns the added HostRule" do
+      expect(rule.host("example.com")).to be_a HostRule
+    end
+  end
+
+  describe "#path" do
+    it "adds a PathRule as a sub-rule" do
+      rule.path("/foo/bar")
+      expect(rule.child_rules.first).to be_a PathRule
+    end
+
+    it "returns the added PathRule" do
+      expect(rule.path("/foo/bar")).to be_a PathRule
+    end
+  end
+
+  describe "#query" do
+    it "adds a QueryRule as a sub-rule" do
+      rule.query(foo: "bar")
+      expect(rule.child_rules.first).to be_a QueryRule
+    end
+
+    it "returns the added QueryRule" do
+      expect(rule.query(foo: "bar")).to be_a QueryRule
+    end
+  end
+
+  describe "#build_child_rule_chain_from_options" do
+    subject(:rule) do
+      rule = Rule.new
+      rule.build_child_rule_chain_from_options(opts)
+      rule
+    end
+
+    describe ":path option" do
+      let(:opts) { { path: "/foo" } }
+
+      it "adds a PathRule" do
+        expect(rule.child_rules.first).to be_a PathRule
+      end
+    end
+
+    describe ":query option" do
+      let(:opts) { { query: { bar: "qux" } } }
+
+      it "adds a QueryRule" do
+        expect(rule.child_rules.first).to be_a QueryRule
+      end
+    end
+
+    describe ":host option" do
+      let(:opts) { { host: "example.com" } }
+
+      it "adds a HostRule" do
+        expect(rule.child_rules.first).to be_a HostRule
+      end
+    end
+
+    context "with multiple options present" do
+      let(:opts) do
+        { host: "example.com", path: "/foo", query: { bar: "qux" } }
+      end
+
+      it "adds chained sub-rules" do
+        first  = rule.child_rules.first
+        second = first.child_rules.first
+        third  = second.child_rules.first
+
+        expect(first).to be_a HostRule
+        expect(second).to be_a PathRule
+        expect(third).to be_a QueryRule
+      end
+    end
+  end
+end