wayfarer 0.0.3 → 0.4.0

data/spec/routing/{query_rule_spec.rb → query_matcher_spec.rb}

@@ -1,25 +1,26 @@
 # frozen_string_literal: true
+
 require "spec_helpers"
 
-describe Wayfarer::Routing::QueryRule do
-  subject(:rule) { QueryRule.new(constraints) }
+describe Wayfarer::Routing::QueryMatcher do
+  subject(:matcher) { Wayfarer::Routing::QueryMatcher.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") }
+      let(:url) { URI("http://example.com?arg=foo") }
 
       it "returns true" do
-        expect(rule.matches?(uri)).to be true
+        expect(matcher).to match(url)
       end
     end
 
     context "with mismatching query field value" do
-      let(:uri) { URI("http://example.com?arg=bar") }
+      let(:url) { URI("http://example.com?arg=bar") }
 
       it "returns false" do
-        expect(rule.matches?(uri)).to be false
+        expect(matcher).not_to match(url)
       end
     end
   end
@@ -28,26 +29,26 @@ describe Wayfarer::Routing::QueryRule do
     let(:constraints) { Hash[arg: 0] }
 
     context "with matching query field value" do
-      let(:uri) { URI("http://example.com?arg=0") }
+      let(:url) { URI("http://example.com?arg=0") }
 
       it "returns true" do
-        expect(rule.matches?(uri)).to be true
+        expect(matcher).to match(url)
       end
     end
 
     context "with mismatching query field value" do
-      let(:uri) { URI("http://example.com?arg=1") }
+      let(:url) { URI("http://example.com?arg=1") }
 
       it "returns false" do
-        expect(rule.matches?(uri)).to be false
+        expect(matcher).not_to match(url)
       end
     end
 
     context "with non-numeric query field value" do
-      let(:uri) { URI("http://example.com?arg=foo") }
+      let(:url) { URI("http://example.com?arg=foo") }
 
       it "returns false" do
-        expect(rule.matches?(uri)).to be false
+        expect(matcher).not_to match(url)
       end
     end
   end
@@ -56,18 +57,18 @@ describe Wayfarer::Routing::QueryRule do
     let(:constraints) { Hash[arg: /foo/] }
 
     context "with matching query field value" do
-      let(:uri) { URI("http://example.com?arg=foo") }
+      let(:url) { URI("http://example.com?arg=foo") }
 
       it "returns true" do
-        expect(rule.matches?(uri)).to be true
+        expect(matcher).to match(url)
       end
     end
 
     context "with mismatching query field value" do
-      let(:uri) { URI("http://example.com?arg=bar") }
+      let(:url) { URI("http://example.com?arg=bar") }
 
       it "returns false" do
-        expect(rule.matches?(uri)).to be false
+        expect(matcher).not_to match(url)
       end
     end
   end
@@ -76,26 +77,26 @@ describe Wayfarer::Routing::QueryRule do
     let(:constraints) { Hash[arg: 1..10] }
 
     context "with matching query field value" do
-      let(:uri) { URI("http://example.com?arg=5") }
+      let(:url) { URI("http://example.com?arg=5") }
 
       it "returns true" do
-        expect(rule.matches?(uri)).to be true
+        expect(matcher).to match(url)
       end
     end
 
     context "with mismatching query field value" do
-      let(:uri) { URI("http://example.com?arg=11") }
+      let(:url) { URI("http://example.com?arg=11") }
 
       it "returns false" do
-        expect(rule.matches?(uri)).to be false
+        expect(matcher).not_to match(url)
       end
     end
 
     context "with non-numeric query field value" do
-      let(:uri) { URI("http://example.com?arg=foo") }
+      let(:url) { URI("http://example.com?arg=foo") }
 
       it "returns false" do
-        expect(rule.matches?(uri)).to be false
+        expect(matcher).not_to match(url)
       end
     end
   end
@@ -106,19 +107,31 @@ describe Wayfarer::Routing::QueryRule do
     end
 
     context "with matching query field values" do
-      let(:uri) { URI("http://example.com?foo=4&bar=bazqux&qux=zot&toto=2") }
+      let(:url) { URI("http://example.com?foo=4&bar=bazqux&qux=zot&toto=2") }
 
       it "returns true" do
-        expect(rule.matches?(uri)).to be true
+        expect(matcher).to match(url)
       end
     end
 
     context "with mismatching query field values" do
-      let(:uri) { URI("http://example.com?foo=bar&bar=qux&qux=6toto=0") }
+      let(:url) { URI("http://example.com?foo=bar&bar=qux&qux=6toto=0") }
 
       it "returns false" do
-        expect(rule.matches?(uri)).to be false
+        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 = URI("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/root_route_spec.rb

@@ -0,0 +1,29 @@
+# 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(URI(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(URI(url))
+        end
+      end
+    end
+  end
+end

data/spec/routing/route_spec.rb

@@ -0,0 +1,43 @@
+# 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(URI("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(URI("http://w3c.org/foo/bar?page=42"))
+
+        expect(result).to be_a(Wayfarer::Routing::Result::Mismatch)
+      end
+    end
+  end
+end

data/spec/routing/scheme_matcher_spec.rb

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

data/spec/routing/{filetypes_rule_spec.rb → suffix_matcher_spec.rb}

@@ -1,38 +1,39 @@
 # frozen_string_literal: true
+
 require "spec_helpers"
 
-describe Wayfarer::Routing::FiletypesRule do
-  subject(:rule) { FiletypesRule.new([:png, :js]) }
+describe Wayfarer::Routing::SuffixMatcher do
+  subject(:matcher) { Wayfarer::Routing::SuffixMatcher.new(".png") }
 
-  describe "#matches?" do
-    context "with matching URI" do
+  describe "#match" do
+    context "with matching URL" do
       it "returns true" do
-        uris = %w(
+        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| URI(u) }
+        ].map { |u| URI(u) }
 
-        uris.each do |uri|
-          expect(rule.matches?(uri)).to be true
+        urls.each do |url|
+          expect(matcher).to match(url)
         end
       end
     end
 
-    context "with mismatching URI" do
+    context "with mismatching URL" do
       it "returns false" do
-        uris = %w(
+        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| URI(u) }
+        ].map { |u| URI(u) }
 
-        uris.each do |uri|
-          expect(rule.matches?(uri)).to be false
+        urls.each do |url|
+          expect(matcher).not_to match(url)
         end
       end
     end

data/spec/routing/uri_matcher_spec.rb

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

data/spec/spec_helpers.rb

@@ -1,62 +1,89 @@
 # frozen_string_literal: true
-require_relative "../lib/wayfarer"
-
-require("bundler") && Bundler.require
 
-include Wayfarer
-include Wayfarer::HTTPAdapters
-include Wayfarer::Routing
-include Wayfarer::Frontiers
-
-if RUBY_PLATFORM == "java"
-  Wayfarer::Frontiers::MemoryBloomfilter  = \
-  Wayfarer::Frontiers::MemoryTrieFrontier = \
-  Wayfarer::Frontiers::RedisBloomfilter   = nil
-end
+require "factory_bot"
+require "pry"
+require "sinatra"
 
-Dir["./spec/shared/**/*.rb"].sort.each { |file| require file }
+require_relative "../lib/wayfarer"
+require_relative "support/test_app"
 
 module SpecHelpers
-  def jruby?
-    RUBY_PLATFORM == "java"
-  end
-
-  def test_app(path)
-    URI("http://localhost:9876#{path}")
+  def test_app_path(path)
+    File.join(test_app_host, path)
   end
 
-  def fetch_page(uri)
-    NetHTTPAdapter.instance.fetch(URI(uri))
+  def test_app_host
+    if ENV["CI"]
+      "http://test:9876"
+    else
+      "http://localhost:9876"
+    end
   end
 
-  def html_fragment(html)
-    Nokogiri::HTML.fragment(html)
+  def redis_host
+    if ENV["CI"]
+      "redis://redis:6379"
+    else
+      "redis://localhost:6379"
+    end
   end
 
-  def node_set(html)
-    html_fragment(html).css("*")
+  def write_file(path, contents)
+    FileUtils.mkdir_p(Pathname.new(path).dirname)
+    IO.write(path, contents)
   end
 end
 
 RSpec.configure do |config|
+  config.include(FactoryBot::Syntax::Methods)
+  config.include(ActiveJob::TestHelper)
   config.include(SpecHelpers)
 
-  config.before do
-    Wayfarer.config.reset!
-    Wayfarer.config.selenium_argv = [:phantomjs]
-  end
+  config.before(:suite) do
+    FactoryBot.find_definitions
 
-  config.before(integration: true) do
-    Wayfarer.logger.level = :fatal
-  end
+    mutex = Mutex.new
+    cvar = ConditionVariable.new
 
-  config.after(integration: true) do
-    Wayfarer.logger.level = :debug
+    Thread.new do
+      Rack::Handler::WEBrick.run(TestApp,
+                                 Host: "0.0.0.0",
+                                 Port: 9876,
+                                 Logger: WEBrick::Log.new("/dev/null"),
+                                 AccessLog: [],
+                                 StartCallback: proc { cvar.signal })
+    end
+
+    mutex.lock
+    cvar.wait(mutex)
   end
 
-  config.before(mri_only: true) do
-    skip("Not supported on JRuby") and fail if RUBY_PLATFORM == "java"
+  config.before do
+    Wayfarer.config = Wayfarer::Config.from_environment
+    Wayfarer.config.redis_url = redis_host
+
+    ::Redis.new(url: redis_host).flushall
+
+    ActiveJob::Base.queue_adapter = :test
+    ActiveJob::Base.logger = Logger.new(nil)
+    ActiveJob::Base.queue_adapter.enqueued_jobs.clear
+    ActiveJob::Base.queue_adapter.performed_jobs.clear
+
+    if ENV["CI"]
+      # For unknown reasons, Wayfarer::Networking::Ferrum#renew can take a very
+      # long time to instantiate a new ::Ferrum::Browser and requires the 60s
+      # timeout. TODO: Figure out what's going on
+      Wayfarer.config.ferrum_options = { url: "http://chrome:3000", timeout: 60 }
+      Wayfarer.config.selenium_argv = [:firefox, { url: "http://firefox:4444" }]
+    end
   end
 
-  config.alias_example_to :they
+  config.around(cli: true) do |example|
+    origin = Dir.pwd
+    tmp = Dir.mktmpdir
+    Dir.chdir(tmp)
+    example.run
+    FileUtils.rm_r(tmp)
+    Dir.chdir(origin)
+  end
 end

data/spec/stringify_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "spec_helpers"
+
+describe Wayfarer::Stringify do
+  let(:klass) do
+    Class.new(Struct.new(:a, :b, :c, :d)) do
+      include Wayfarer::Stringify
+
+      stringify :a, :c, :d
+    end
+  end
+
+  subject(:instance) { klass.new(1, 2.0, :three, "four") }
+
+  before { stub_const("Foobar", klass) }
+
+  describe "#to_s" do
+    it "returns the expected string" do
+      expect(instance.to_s).to eq('#<Foobar a=1, c=:three, d="four">')
+    end
+  end
+end

data/{support → spec/support}/test_app.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "sinatra"
 
 class TestApp < Sinatra::Base
   set :root, File.dirname(__FILE__)
@@ -9,11 +8,19 @@ class TestApp < Sinatra::Base
     status params[:code]
   end
 
+  get "/headers/:header" do
+    request.env[params[:header]]
+  end
+
   get "/hello_world" do
     headers "hello" => "world"
     "Hello world!"
   end
 
+  get "/body/:content" do
+    params[:content]
+  end
+
   get "/redirect_loop" do
     redirect to "/redirect_loop"
   end
@@ -37,7 +44,7 @@ class TestApp < Sinatra::Base
     send_file(static_file("xml/#{params[:file]}"))
   end
 
-  private
+private
 
   def static_file(file_path)
     File.expand_path(file_path, settings.public_folder)

data/spec/task_spec.rb

@@ -0,0 +1,27 @@
+# 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
+end

data/spec/wayfarer_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "spec_helpers"
 
 describe Wayfarer do
@@ -6,19 +7,7 @@ describe Wayfarer do
     it("is present") { expect(defined? Wayfarer::VERSION).not_to be nil }
   end
 
-  describe "::logger, ::logger=" do
-    it "returns and alters the logger" do
-      expect(Wayfarer.logger).to be_a Logger
-    end
-  end
-
   describe "::config" do
-    it "alters keys and values" do
-      Wayfarer.config.foo = :bar
-      expect(Wayfarer.config.foo).to be :bar
-
-      Wayfarer.config { |config| config.baz = :qux }
-      expect(Wayfarer.config.baz).to be :qux
-    end
+    it("returns a config") { expect(Wayfarer.config).to be_a(Wayfarer::Config) }
   end
 end