wayfarer 0.0.3 → 0.4.3

data/spec/integration/callbacks_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-require "spec_helpers"
-
-describe Wayfarer, integration: true do
-  describe "Callbacks" do
-    subject(:job) do
-      Class.new(Wayfarer::Job) do
-        config.reraise_exceptions = true
-      end
-    end
-
-    describe "ActiveJob-inherited callbacks" do
-      they "fire" do
-        job.class_eval do
-          before_perform { fail }
-        end
-
-        expect {
-          job.perform_now
-        }.to raise_error
-      end
-    end
-
-    describe "Own callbacks" do
-      describe "::before_crawl" do
-        it "fires" do
-          job.class_eval { before_crawl { fail } }
-
-          expect { job.perform_now }.to raise_error
-        end
-      end
-
-      describe "::after_crawl" do
-        it "fires" do
-          job.class_eval { after_crawl { fail } }
-
-          expect { job.perform_now }.to raise_error
-        end
-      end
-    end
-  end
-end

data/spec/integration/locals_spec.rb

@@ -1,106 +0,0 @@
-# frozen_string_literal: true
-require "spec_helpers"
-
-describe Wayfarer, integration: true do
-  describe "Locals" do
-    subject(:job) do
-      Class.new(Wayfarer::Job) do
-        config.reraise_exceptions = true
-      end
-    end
-
-    describe "Initial local values" do
-      let(:entry) { test_app("/hello_world") }
-
-      they "do not change" do
-        job.class_eval do
-          route.path "/hello_world", to: :foobar
-
-          let(:foo) { {} }
-
-          def foobar
-            foo[:bar] = :qux
-          end
-        end
-
-        expect {
-          job.perform_now(entry)
-        }.not_to change { job.locals[:foo] }
-      end
-
-      context "when declared with ::let" do
-        they "get replaced with thread-safe counterparts" do
-          job.class_eval do
-            route.path "/hello_world", to: :foobar
-
-            let(:hash) { {} }
-            let(:array) { [] }
-            let(:fixnum) { 123 }
-            let(:tru) { true }
-            let(:fuls) { false }
-
-            def foobar
-              fail unless hash.is_a? Concurrent::Hash
-              fail unless array.is_a? Concurrent::Array
-              fail unless fixnum.is_a? Concurrent::AtomicFixnum
-              fail unless tru.is_a? Concurrent::AtomicBoolean
-              fail unless fuls.is_a? Concurrent::AtomicBoolean
-            end
-          end
-
-          expect {
-            job.perform_now(entry)
-          }.not_to raise_error
-        end
-      end
-    end
-
-    describe "Locals" do
-      let(:entry) { test_app("/graph/index.html") }
-
-      they "can be mutated within actions" do
-        job.class_eval do
-          route.path "/graph/index.html", to: :index
-          route.path "/graph/details/a.html", to: :detail
-
-          let(:hash) { {} }
-
-          def index
-            hash[:foo] = 42
-            stage page.links
-          end
-
-          def detail
-            fail unless hash[:foo] == 42
-          end
-        end
-
-        expect {
-          job.perform_now(entry)
-        }.not_to raise_error
-      end
-
-      they "are accessible within callbacks" do
-        job.class_eval do
-          route.path "/graph/index.html", to: :index
-
-          let(:hash) { { foo: :bar} }
-
-          before_crawl do
-            fail unless hash[:foo] == :bar
-          end
-
-          after_crawl do
-            fail unless hash[:foo] == :qux
-          end
-
-          def index
-            hash[:foo] = :qux
-          end
-        end
-
-        expect { job.perform_now(entry) }.not_to raise_error
-      end
-    end
-  end
-end

data/spec/integration/peeking_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require "spec_helpers"
-
-describe Wayfarer, integration: true do
-  subject(:job) do
-    Class.new(Wayfarer::Job) do
-      config.reraise_exceptions = true
-    end
-  end
-
-  let(:entry) { test_app("/graph/index.html") }
-
-  describe "Peeking" do
-    it "works" do
-      job.class_eval do
-        route.path "/graph/index.html", to: :index
-        route.path "/graph/details/a.html", to: :detail
-
-        def index
-          peek = yield "http://localhost:9876/graph/details/a.html"
-          fail unless peek == :ok
-        end
-
-        def detail
-          :ok
-        end
-      end
-
-      expect {
-        job.perform_now(entry)
-      }.not_to raise_error
-    end
-  end
-
-  describe "Recursive peeking" do
-    it "does not work" do
-      job.class_eval do
-        route.path "/graph/index.html", to: :index
-        route.path "/graph/details/a.html", to: :a
-        route.path "/graph/details/a.html", to: :b
-
-        def index
-          peek = yield "http://localhost:9876/graph/details/a.html"
-          fail unless peek == :ok
-        end
-
-        def a
-          yield "http://localhost:9876/graph/details/b.html" or :ok
-        end
-
-        def b
-          yield "http://localhost:9876/graph/details/a.html"
-        end
-      end
-
-      expect {
-        job.perform_now(entry)
-      }.not_to raise_error
-    end
-  end
-end

data/spec/job_spec.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-require "spec_helpers"
-
-describe Wayfarer::Job do
-  subject(:job) { Class.new(Wayfarer::Job) }
-
-  describe "::prepare" do
-    it "copies the router" do
-      job.class_eval do
-        route.host "example.com", to: :foobar
-      end
-
-      prepared_job = job.prepare
-
-      expect(prepared_job.router).not_to be job.router
-
-      uri = URI("http://example.com")
-      expect(prepared_job.router.routes?(uri)).to be true
-    end
-
-    it "copies locals" do
-      job.class_eval do
-        let(:foo) { { bar: :qux } }
-        let(:baz) { 42 }
-      end
-
-      prepared_job = job.prepare
-
-      expect(prepared_job.locals).not_to be job.locals
-
-      expect(prepared_job.locals[:foo]).to be_a Concurrent::Hash
-      expect(prepared_job.locals[:baz]).to be_a Concurrent::AtomicFixnum
-    end
-
-    it "defines instance accessors for locals" do
-      job.class_eval do
-        let(:foo) { { bar: :qux } }
-        let(:baz) { 42 }
-      end
-
-      prepared_job = job.prepare
-
-      expect(prepared_job).to respond_to(:foo)
-      expect(prepared_job).to respond_to(:baz)
-    end
-  end
-
-  describe "::config" do
-    it "allows manipulating the configuration" do
-      expect {
-        job.config { |c| c.http_adapter = :selenium }
-      }.to change { job.config.http_adapter }.to(:selenium)
-    end
-
-    it "does not manipulate the global configuration" do
-      expect {
-        job.config { |c| c.http_adapter = :selenium }
-      }.not_to change { Wayfarer.config.http_adapter }
-    end
-  end
-
-  describe "#halt" do
-    it "sets the halting flag" do
-      job_instance = job.new
-
-      expect {
-        job_instance.send(:halt)
-      }.to change { job_instance.halts? }.from(false).to(true)
-    end
-  end
-
-  describe "#stage" do
-    it "stages URIs" do
-      job_instance = job.new
-      job_instance.page = Page.new(uri: URI("https://yahoo.com/qux"))
-
-      uris = %w(
-        http://google.com
-        http://example.com
-      )
-
-      expected = uris.map { |u| URI(u) }
-
-      expect {
-        job_instance.send(:stage, *uris)
-      }.to change { job_instance.staged_uris }.from([]).to(expected)
-    end
-
-    it "expands relative URIs" do
-      job_instance = job.new
-      job_instance.page = Page.new(uri: URI("https://yahoo.com/qux"))
-
-      uris = %w(
-        /foo/bar
-        bar/qux.html
-        barfoo
-      )
-
-      expected = %w(
-        https://yahoo.com/qux/foo/bar
-        https://yahoo.com/qux/bar/qux.html
-        https://yahoo.com/qux/barfoo
-      ).map { |u| URI(u) }
-
-      expect {
-        job_instance.send(:stage, *uris)
-      }.to change { job_instance.staged_uris }.from([]).to(expected)
-    end
-
-    context "with non-HTTP(s) URIs" do
-      it "ignores them and does not raise an exception" do
-        job_instance = job.new
-
-        expect {
-          job_instance.send(:stage, "ftp://example.com")
-        }.not_to raise_error
-
-        expect(job_instance.staged_uris).to be_empty
-      end
-    end
-  end
-end

data/spec/processor_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-require "spec_helpers"
-
-describe Wayfarer::Processor do
-  let(:job) { Class.new(Wayfarer::Job) }
-  let(:frontier) { Frontiers::MemoryFrontier.new(job.config) }
-  let(:dispatcher) { Dispatcher.new(job) }
-  subject(:processor) { Processor.new(job, frontier, dispatcher) }
-
-  describe "#halt!" do
-    it "sets a halting flag" do
-      processor.halt!
-      expect(processor).to be_halted
-    end
-  end
-
-  describe "#halted?" do
-    context "when not halted" do
-      it "returns false" do
-        expect(processor.halted?).to be false
-      end
-    end
-
-    context "when halted" do
-      it "returns true" do
-        processor.halt!
-        expect(processor.halted?).to be true
-      end
-    end
-  end
-end

data/spec/routing/custom_rule_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-require "spec_helpers"
-
-describe Wayfarer::Routing::CustomRule do
-  let(:uri) { URI("http://example.com") }
-
-  describe "#matches?" do
-    context "with a block" do
-      context "when block is truthy" do
-        subject(:rule) { CustomRule.new -> (uri) { uri.is_a?(URI) } }
-
-        it "returns true" do
-          expect(rule.matches?(uri)).to be true
-        end
-      end
-
-      context "when block is fals-y" do
-        subject(:rule) { CustomRule.new -> (_) { false } }
-
-        it "returns true" do
-          expect(rule.matches?(uri)).to be false
-        end
-      end
-    end
-  end
-end

data/spec/routing/host_rule_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-require "spec_helpers"
-
-describe Wayfarer::Routing::HostRule do
-  subject(:rule) { HostRule.new(str_or_regexp) }
-
-  describe "#matches?" do
-    describe "String matching" do
-      let(:str_or_regexp) { "example.com" }
-
-      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://google.com/bar/qux") }
-
-        it "returns false" do
-          expect(rule.matches?(uri)).to be false
-        end
-      end
-    end
-
-    describe "RegExp matching" do
-      let(:str_or_regexp) { /example.com/ }
-
-      context "with matching URI" do
-        let(:uri) { URI("http://sub.example.com") }
-
-        it "returns true" do
-          expect(rule.matches?(uri)).to be true
-        end
-      end
-
-      context "with mismatching URI" do
-        let(:uri) { URI("http://example.sub.com") }
-
-        it "returns false" do
-          expect(rule.matches?(uri)).to be false
-        end
-      end
-    end
-  end
-end

data/spec/routing/path_rule_spec.rb

@@ -1,66 +0,0 @@
-# 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/protocol_rule_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-require "spec_helpers"
-
-describe Wayfarer::Routing::ProtocolRule do
-  describe "#matches?" do
-    context "with a string" do
-      subject(:rule) { ProtocolRule.new(:http) }
-
-      context "with matching URI" do
-        let(:uri) { URI("http://example.com") }
-
-        it "returns true" do
-          expect(rule.matches?(uri)).to be true
-        end
-      end
-
-      context "with mismatching URI" do
-        let(:uri) { URI("https://example.com") }
-
-        it "returns true" do
-          expect(rule.matches?(uri)).to be false
-        end
-      end
-    end
-  end
-end

data/spec/routing/query_rule_spec.rb

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