wayfarer 0.4.7 → 0.4.9

data/spec/middleware/dispatch_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Middleware::Dispatch do
-  let(:task) { build(:task) }
-  let(:action) { :action }
-  subject(:chain) { described_class.new }
-
-  before do
-    task[:controller] = spy
-    task[:action] = action
-
-    allow(task[:controller]).to receive(:run_callbacks).and_yield
-  end
-
-  describe "#call" do
-    it "runs callbacks" do
-      expect(task[:controller]).to receive(:run_callbacks).with(action)
-      subject.call(task)
-    end
-
-    context "when action is a Symbol" do
-      it "calls the method" do
-        expect(task[:controller]).to receive(action)
-        subject.call(task)
-      end
-    end
-
-    context "with handler" do
-      let(:action) { Class.new.include(Wayfarer::Handler) }
-
-      it "instantiates and calls" do
-        expect_any_instance_of(action).to receive(:call).with(task)
-        subject.call(task)
-      end
-    end
-
-    context "without action" do
-      let(:action) { nil }
-
-      it "instantiates and calls" do
-        expect { subject.call(task) }.to raise_error(ArgumentError)
-      end
-    end
-
-    context "without other action" do
-      let(:action) { Class.new }
-
-      it "instantiates and calls" do
-        expect { subject.call(task) }.to raise_error(ArgumentError)
-      end
-    end
-
-    it "yields" do
-      expect { |spy| subject.call(task, &spy) }.to yield_control
-    end
-  end
-end

data/spec/middleware/normalize_spec.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Middleware::Normalize do
-  let(:task) { build(:task) }
-  let(:uri) { Addressable::URI.parse(url) }
-  subject { described_class.new }
-
-  describe "::normalize" do
-    subject { described_class.normalize(uri).to_s }
-
-    context "without HTTP(S) URL" do
-      let(:url) { "localhost:3000" }
-
-      it { is_expected.to eq(url) }
-    end
-
-    context "with HTTP URL" do
-      let(:url) { "http://example.com" }
-
-      it { is_expected.to eq("http://example.com/") }
-    end
-  end
-
-  describe "#call" do
-    let(:url) { task.url }
-    before { task[:uri] = uri }
-
-    context "when already assigned" do
-      before { task[:normalized_url] = Object.new }
-
-      specify do
-        expect { |spy| subject.call(task, &spy) }.to yield_control
-      end
-
-      it "doesn't normalize URL" do
-        expect { subject.call(task) }.not_to(change { task[:normalized_url] })
-      end
-    end
-
-    context "with invalid URL" do
-      before do
-        # I can't come up with a URL that normalize_url raises on but
-        # Addressable::URI doesn't, hence the stub
-        allow(described_class).to receive(:normalize).with(uri).and_return(nil)
-      end
-
-      specify do
-        expect { |spy| subject.call(task, &spy) }.not_to yield_control
-      end
-
-      specify do
-        expect(Wayfarer::Logging.logger).to receive(:add).with(Logger::INFO, "Failed to normalize HTTP(S) URL")
-
-        subject.call(task)
-      end
-    end
-  end
-end

data/spec/middleware/uri_parser_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Middleware::UriParser, "#call" do
-  let(:task) { build(:task) }
-  subject { described_class.new }
-
-  it "parses URLs" do
-    expect { subject.call(task) }.to change { task[:uri] }.to(Addressable::URI.parse(task.url))
-  end
-
-  it "normalizes URLs" do
-    task = build(:task, url: "http://example.com")
-
-    expect { subject.call(task) }.to change { task[:uri].to_s }.to("http://example.com/")
-  end
-
-  specify do
-    expect { |spy| subject.call(task, &spy) }.to yield_control
-  end
-
-  context "with invalid URL" do
-    let(:task) { build(:task, url: "ht%0atp://localhost/") }
-
-    specify do
-      expect { |spy| subject.call(task, &spy) }.not_to yield_control
-    end
-
-    specify do
-      expect(Wayfarer::Logging.logger)
-        .to receive(:add).with(Logger::INFO, "Not processing invalid URL (Invalid scheme format: 'ht%0atp')")
-
-      subject.call(task)
-    end
-  end
-
-  describe described_class::API do
-    subject(:controller) do
-      Struct.new(:task).include(described_class).new(task)
-    end
-
-    describe "#uri" do
-      let(:uri) { Addressable::URI.parse(task.url) }
-
-      before { task[:uri] = uri }
-
-      it "returns the agent" do
-        expect(controller.uri).to be(uri)
-      end
-    end
-  end
-end

data/spec/networking/capybara_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-require_relative "strategy"
-
-describe Wayfarer::Networking::Capybara, ferrum: true do
-  include_examples "Network strategy", strategy: described_class,
-                                       browser: true,
-                                       request_headers: false,
-                                       response_headers: true,
-                                       status_code: true
-end

data/spec/networking/ferrum_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-require_relative "strategy"
-
-describe Wayfarer::Networking::Ferrum, ferrum: true do
-  include_examples "Network strategy", strategy: described_class,
-                                       browser: true,
-                                       request_headers: true,
-                                       response_headers: true,
-                                       status_code: true
-end

data/spec/networking/http_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-require_relative "strategy"
-
-describe Wayfarer::Networking::HTTP do
-  include_examples "Network strategy", strategy: described_class,
-                                       browser: false,
-                                       request_headers: true,
-                                       response_headers: true,
-                                       status_code: true
-end

data/spec/networking/selenium_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-require_relative "strategy"
-
-describe Wayfarer::Networking::Selenium, selenium: true do
-  include_examples "Network strategy", strategy: described_class,
-                                       browser: true,
-                                       request_headers: false,
-                                       response_headers: false,
-                                       status_code: false
-end

data/spec/redis/counter_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helpers"
-
-describe Wayfarer::Redis::Counter, redis: true do
-  let(:callback) { -> {} }
-  let(:task) { build(:task, :redis_pool) }
-  subject(:counter) { Wayfarer::Redis::Counter.new(task, &callback) }
-
-  describe "#redis_key" do
-    it "returns the expected Redis key" do
-      expect(counter.redis_key).to eq("wayfarer-counter-batch")
-    end
-  end
-
-  describe "#increment" do
-    it "increments" do
-      expect { counter.increment }.to change { counter.value }.by(1)
-    end
-  end
-
-  describe "#decrement" do
-    it "decrements" do
-      expect { counter.decrement }.to change { counter.value }.by(-1)
-    end
-
-    context "when reaching zero" do
-      let(:callback) { -> { @callback_called = true } }
-
-      before { counter.increment }
-
-      it "runs callback" do
-        expect { counter.decrement }.to change { @callback_called }.to(true).from(nil)
-      end
-    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/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