wayfarer 0.4.6 → 0.4.8

data/spec/routing/integration_spec.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Routing::DSL do
-  let(:route) { Wayfarer::Routing::RootRoute.new }
-
-  it "matches URLs" do
-    route.path "/"
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Match)
-
-    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(Addressable::URI.parse("https://example.com/foo"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Match)
-  end
-
-  it "matches URLs" do
-    route.host "example.com", path: "/foo" do
-      query page: 1..10
-    end
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/foo?page=4"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Match)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/foo?page=11"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/foo"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com?page=2"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-  end
-
-  it "matches URLs" do
-    route.host "example.com", path: "/foo" do
-      query page: 1..10
-    end
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/foo?page=4"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Match)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/foo?page=11"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/foo"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com?page=2"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-  end
-
-  it "matches URLs" do
-    route.host "example.com" do
-      path "/contact"
-      path "/users/:id"
-    end
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/contact"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Match)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/contact/foo"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/users/123"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Match)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/users/123/images"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/users"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-  end
-
-  it "matches URLs" do
-    route.host "example.com" do
-      path "/contact"
-      path "/users/:user_id" do
-        path "/images/:id"
-        path "/friends"
-      end
-    end
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/contact"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Match)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/users/123"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-
-    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(Addressable::URI.parse("https://example.com/users/123/images/23/foo"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-
-    result = route.invoke(Addressable::URI.parse("https://example.com/users/123/friends"))
-    expect(result).to be_a(Wayfarer::Routing::Result::Match)
-
-    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/matchers/custom_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-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::Matchers::Custom.new ->(_) { true }
-        end
-
-        it "returns true" do
-          expect(matcher).to match(url)
-        end
-      end
-
-      context "when block is falsy" do
-        subject(:matcher) do
-          Wayfarer::Routing::Matchers::Custom.new ->(_) { false }
-        end
-
-        it "returns true" do
-          expect(matcher).not_to match(url)
-        end
-      end
-    end
-  end
-end

data/spec/routing/matchers/host_spec.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-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) { Addressable::URI.parse("http://example.com/foo/bar") }
-
-        it "returns true" do
-          expect(matcher).to match(url)
-        end
-      end
-
-      context "with mismatching URL" do
-        let(:url) { Addressable::URI.parse("http://google.com/bar/qux") }
-
-        it "returns false" do
-          expect(matcher).not_to match(url)
-        end
-      end
-    end
-
-    describe "RegExp matching" do
-      let(:str_or_regexp) { /example.com/ }
-
-      context "with matching URL" do
-        let(:url) { Addressable::URI.parse("http://sub.example.com") }
-
-        it "returns true" do
-          expect(matcher).to match(url)
-        end
-      end
-
-      context "with mismatching URL" do
-        let(:url) { Addressable::URI.parse("http://example.sub.com") }
-
-        it "returns false" do
-          expect(matcher).not_to match(url)
-        end
-      end
-    end
-  end
-end

data/spec/routing/matchers/path_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Routing::Matchers::Path, mri: true do
-  let(:route) { Wayfarer::Routing::RootRoute.new }
-  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(Addressable::URI.parse("http://example.com/foo/bar"))
-      end
-    end
-
-    context "with mismatching URL" do
-      let(:path) { "/{alpha}/{beta}" }
-
-      it "returns false" do
-        expect(matcher).not_to match(Addressable::URI.parse("http://example.com/foo"))
-      end
-    end
-
-    context "with mismatching URL" do
-      let(:path) { "/" }
-
-      it "returns false" do
-        expect(matcher).not_to match(Addressable::URI.parse("http://example.com/foo"))
-      end
-    end
-  end
-
-  describe "#params" do
-    let(:path) { "/{alpha}/{beta}" }
-
-    it "returns the correct parameters" do
-      url = Addressable::URI.parse("http://example.com/foo/bar")
-      expect(matcher.params(url)).to eq("alpha" => "foo", "beta" => "bar")
-    end
-  end
-end

data/spec/routing/matchers/query_spec.rb

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-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) { Addressable::URI.parse("http://example.com?arg=foo") }
-
-      it "returns true" do
-        expect(matcher).to match(url)
-      end
-    end
-
-    context "with mismatching query field value" do
-      let(:url) { Addressable::URI.parse("http://example.com?arg=bar") }
-
-      it "returns false" do
-        expect(matcher).not_to match(url)
-      end
-    end
-  end
-
-  describe "Integer constraints" do
-    let(:constraints) { Hash[arg: 0] }
-
-    context "with matching query field value" do
-      let(:url) { Addressable::URI.parse("http://example.com?arg=0") }
-
-      it "returns true" do
-        expect(matcher).to match(url)
-      end
-    end
-
-    context "with mismatching query field value" do
-      let(:url) { Addressable::URI.parse("http://example.com?arg=1") }
-
-      it "returns false" do
-        expect(matcher).not_to match(url)
-      end
-    end
-
-    context "with non-numeric query field value" do
-      let(:url) { Addressable::URI.parse("http://example.com?arg=foo") }
-
-      it "returns false" do
-        expect(matcher).not_to match(url)
-      end
-    end
-  end
-
-  describe "Regexp constraints" do
-    let(:constraints) { Hash[arg: /foo/] }
-
-    context "with matching query field value" do
-      let(:url) { Addressable::URI.parse("http://example.com?arg=foo") }
-
-      it "returns true" do
-        expect(matcher).to match(url)
-      end
-    end
-
-    context "with mismatching query field value" do
-      let(:url) { Addressable::URI.parse("http://example.com?arg=bar") }
-
-      it "returns false" do
-        expect(matcher).not_to match(url)
-      end
-    end
-  end
-
-  describe "Range constraints" do
-    let(:constraints) { Hash[arg: 1..10] }
-
-    context "with matching query field value" do
-      let(:url) { Addressable::URI.parse("http://example.com?arg=5") }
-
-      it "returns true" do
-        expect(matcher).to match(url)
-      end
-    end
-
-    context "with mismatching query field value" do
-      let(:url) { Addressable::URI.parse("http://example.com?arg=11") }
-
-      it "returns false" do
-        expect(matcher).not_to match(url)
-      end
-    end
-
-    context "with non-numeric query field value" do
-      let(:url) { Addressable::URI.parse("http://example.com?arg=foo") }
-
-      it "returns false" do
-        expect(matcher).not_to match(url)
-      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(:url) { Addressable::URI.parse("http://example.com?foo=4&bar=bazqux&qux=zot&toto=2") }
-
-      it "returns true" do
-        expect(matcher).to match(url)
-      end
-    end
-
-    context "with mismatching query field values" do
-      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)
-      end
-    end
-  end
-
-  describe "#params" do
-    let(:constraints) do
-      Hash[foo: 1..5, bar: /baz/, qux: "zot", toto: 2]
-    end
-
-    it "returns the correct parameters" do
-      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
-  end
-end

data/spec/routing/matchers/scheme_spec.rb

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

data/spec/routing/matchers/suffix_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Routing::Matchers::Suffix do
-  subject(:matcher) { Wayfarer::Routing::Matchers::Suffix.new(".png") }
-
-  describe "#match" do
-    context "with matching URL" do
-      it "returns true" do
-        urls = %w[
-          http://example.com/foo.png
-          https://example.com/a/b.png/c.png
-          http://example.com/foobar.html.png
-          https://example.com/foo.png/bar.png
-        ].map { |u| Addressable::URI.parse(u) }
-
-        urls.each do |url|
-          expect(matcher).to match(url)
-        end
-      end
-    end
-
-    context "with mismatching URL" do
-      it "returns false" do
-        urls = %w[
-          http://example.png
-          http://example.com.png
-          https://example.com/a/b.png/c
-          http://example.com.html
-          http://example.com/foobar.html
-          https://example.com/foo.png/bar.png.html
-        ].map { |u| Addressable::URI.parse(u) }
-
-        urls.each do |url|
-          expect(matcher).not_to match(url)
-        end
-      end
-    end
-  end
-end

data/spec/routing/matchers/uri_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Routing::Matchers::URL do
-  subject(:matcher) do
-    Wayfarer::Routing::Matchers::URL.new("http://example.com/foo/bar")
-  end
-
-  describe "#match" do
-    context "with matching URL" do
-      let(:url) { Addressable::URI.parse("http://example.com/foo/bar") }
-
-      it "returns true" do
-        expect(matcher).to match(url)
-      end
-    end
-
-    context "with mismatching URL" do
-      let(:url) { Addressable::URI.parse("http://example.com/foo/qux") }
-
-      it "returns true" do
-        expect(matcher).not_to match(url)
-      end
-    end
-  end
-end

data/spec/routing/path_finder_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Routing::PathFinder do
-  let(:route) do
-    Wayfarer::Routing::RootRoute.new.to(:foobar) do
-      host "example.com", path: "/:a/:b"
-    end
-  end
-
-  subject(:result) { Wayfarer::Routing::PathFinder.result(route, Addressable::URI.parse(url)) }
-
-  describe "::result" do
-    context "with matching URL" do
-      let(:url) { "https://example.com/alpha/beta" }
-
-      it "returns a Match" do
-        expect(result).to be_a(Wayfarer::Routing::Result::Match)
-        expect(result.action).to be(:foobar)
-        expect(result.params).to eq("a" => "alpha", "b" => "beta")
-      end
-    end
-
-    context "with mismatching URL" do
-      let(:url) { "https://yahoo.com/alpha/zyklon" }
-
-      it "returns a Mismatch" do
-        expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-      end
-    end
-  end
-end

data/spec/routing/root_route_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Routing::Route do
-  let(:route) { Wayfarer::Routing::RootRoute.new }
-
-  describe "#matcher" do
-    subject(:matcher) { route.matcher }
-
-    context "with child routes" do
-      before { route.host("http://google.com") }
-
-      it "returns true" do
-        %w[http://example.com http://w3c.org http://google.com].each do |url|
-          expect(matcher).to match(Addressable::URI.parse(url))
-        end
-      end
-    end
-
-    context "without child routes" do
-      it "returns false" do
-        %w[http://example.com http://w3c.org http://google.com].each do |url|
-          expect(matcher).not_to match(Addressable::URI.parse(url))
-        end
-      end
-    end
-  end
-end

data/spec/routing/route_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Routing::Route do
-  subject(:root) { Wayfarer::Routing::RootRoute.new }
-
-  describe "#invoke" do
-    context "with matching matchers" do
-      it "returns a Match" do
-        root.host "example.com", to: :overridden do
-          path "/:a/:b" do
-            to :overrider, query: { page: 42 }
-          end
-        end
-
-        result = root.invoke(Addressable::URI.parse("http://example.com/foo/bar?page=42"))
-
-        expect(result).to be_a(Wayfarer::Routing::Result::Match)
-        expect(result.action).to be(:overrider)
-        expect(result.params).to eq({
-                                      "a" => "foo",
-                                      "b" => "bar",
-                                      "page" => "42"
-                                    })
-      end
-    end
-
-    context "with mismatching matchers" do
-      it "returns a Mismatch" do
-        root.host "example.com", to: :overridden do
-          path "/:a/:b" do
-            query({ page: 42 }, { to: :overrider })
-          end
-        end
-
-        result = root.invoke(Addressable::URI.parse("http://w3c.org/foo/bar?page=42"))
-
-        expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
-      end
-    end
-  end
-end

data/spec/routing/router_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Routing::Router do
-  subject(:router) do
-    described_class.new.tap do |router|
-      router.draw do |alpha, beta|
-        path alpha, to: :alpha
-        path beta, to: :beta
-      end
-    end
-  end
-
-  describe "#invoke" do
-    let(:url) { Addressable::URI.parse("https://example.com/alpha") }
-
-    it "evaluates routes" do
-      result = router.invoke(url, %w[/alpha /beta])
-      expect(result).to be_a(Wayfarer::Routing::Result::Match)
-      expect(result.action).to be(:alpha)
-    end
-  end
-end

data/spec/task_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Task do
-  subject(:task) { build(:task) }
-
-  describe "#metadata" do
-    it "returns an OpenStruct" do
-      expect(task.metadata).to be_an(OpenStruct)
-    end
-  end
-
-  describe "#barrier" do
-    it "returns its batch barrier" do
-      expect(task.barrier).to be_a(Wayfarer::Redis::Barrier)
-      expect(task.barrier.batch).to eq(task.batch)
-    end
-  end
-
-  describe "#counter" do
-    it "returns its batch counter" do
-      expect(task.counter).to be_a(Wayfarer::Redis::Counter)
-      expect(task.counter.batch).to eq(task.batch)
-    end
-  end
-
-  describe "#gc" do
-    it "returns a garbage collector" do
-      expect(task.gc).to be_a(Wayfarer::GC)
-      expect(task.gc.task).to be(task)
-    end
-  end
-end

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

@@ -3,6 +3,8 @@
 require "spec_helpers"
 
 describe Wayfarer::Stringify do
+  subject(:instance) { klass.new(1, 2.0, :three, "four") }
+
   let(:klass) do
     Class.new(Struct.new(:a, :b, :c, :d)) do
       include Wayfarer::Stringify
@@ -11,8 +13,6 @@ describe Wayfarer::Stringify do
     end
   end
 
-  subject(:instance) { klass.new(1, 2.0, :three, "four") }
-
   before { stub_const("Foobar", klass) }
 
   describe "#to_s" do