fetch 0.0.4 → 0.0.5

data/test/module/before_process_test.rb

@@ -0,0 +1,104 @@
+require "test_helper"
+
+class BeforeProcessTest < Minitest::Test
+  def test_before_process_callback_set_in_request
+    words = %w{one two}
+    words.each { |w| stub_request(:get, "http://test.com/#{w}").to_return(body: "got #{w}") }
+    
+    stub_request(:get, "http://test.com/two").to_return(body: "got two")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      words.each do |word|
+        request do |req|
+          req.url = "http://test.com/#{word}"
+          req.before_process do
+            actions << "before process #{word}"
+          end
+          req.process do |body|
+            actions << "process #{word}"
+          end
+        end
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["before process one", "process one", "before process two", "process two"], actions
+  end
+
+  def test_before_process_callback_scope_set_in_request
+    words = %w{one two}
+    words.each { |w| stub_request(:get, "http://test.com/#{w}").to_return(body: "got #{w}") }
+    
+    stub_request(:get, "http://test.com/two").to_return(body: "got two")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      words.each do |word|
+        request do |req|
+          req.url = "http://test.com/#{word}"
+          req.before_process do
+            actions << "before process #{word} (#{some_instance_method})"
+          end
+          req.process do |body|
+            actions << "process #{word}"
+          end
+        end
+      end
+      def some_instance_method
+        "ok"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["before process one (ok)", "process one", "before process two (ok)", "process two"], actions
+  end
+
+  def test_before_process_callback_set_in_module
+    words = %w{one two}
+    words.each { |w| stub_request(:get, "http://test.com/#{w}").to_return(body: "got #{w}") }
+    
+    stub_request(:get, "http://test.com/two").to_return(body: "got two")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      words.each do |word|
+        request do |req|
+          req.url = "http://test.com/#{word}"
+          req.process do |body|
+            actions << "process #{word}"
+          end
+        end
+      end
+
+      before_process do
+        actions << "before process"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["before process", "process one", "before process", "process two"], actions
+  end
+
+  def test_before_process_callback_scope_set_in_module
+    words = %w{one two}
+    words.each { |w| stub_request(:get, "http://test.com/#{w}").to_return(body: "got #{w}") }
+    
+    stub_request(:get, "http://test.com/two").to_return(body: "got two")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      words.each do |word|
+        request do |req|
+          req.url = "http://test.com/#{word}"
+          req.process do |body|
+            actions << "process #{word}"
+          end
+        end
+      end
+
+      before_process do
+        actions << "before process (#{some_instance_method})"
+      end
+
+      def some_instance_method
+        "ok"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["before process (ok)", "process one", "before process (ok)", "process two"], actions
+  end
+end

data/test/module/error_test.rb

@@ -0,0 +1,98 @@
+require "test_helper"
+
+class ErrorTest < Minitest::Test
+  def test_unhandled_process_error
+    stub_request(:get, "http://test.com/one").to_return(body: "ok")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "http://test.com/one"
+        req.process do |body|
+          this_wont_work
+        end
+      end
+    end
+    assert_raises NameError do
+      MockFetcher(mod).new.fetch
+    end
+  end
+
+  def test_process_error_handled_in_request
+    stub_request(:get, "http://test.com/one").to_return(body: "ok")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "http://test.com/one"
+        req.error do |e|
+          actions << "handled #{e.class.name}"
+        end
+        req.process do |body|
+          this_wont_work
+        end
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["handled NameError"], actions
+  end
+
+  def test_process_error_scope_handled_in_request
+    stub_request(:get, "http://test.com/one").to_return(body: "ok")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "http://test.com/one"
+        req.error do |e|
+          actions << "handled #{e.class.name} (#{some_instance_method})"
+        end
+        req.process do |body|
+          this_wont_work
+        end
+      end
+
+      def some_instance_method
+        "it worked"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["handled NameError (it worked)"], actions
+  end
+
+  def test_process_error_handled_in_module
+    stub_request(:get, "http://test.com/one").to_return(body: "ok")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "http://test.com/one"
+        req.process do |body|
+          this_wont_work
+        end
+      end
+      error do |e|
+        actions << "handled #{e.class.name}"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["handled NameError"], actions
+  end
+
+  def test_process_error_scope_handled_in_module
+    stub_request(:get, "http://test.com/one").to_return(body: "ok")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "http://test.com/one"
+        req.process do |body|
+          this_wont_work
+        end
+      end
+      error do |e|
+        actions << "handled #{e.class.name} (#{some_instance_method})"
+      end
+      def some_instance_method
+        "it worked"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["handled NameError (it worked)"], actions
+  end
+end

data/test/module/failure_test.rb

@@ -0,0 +1,96 @@
+require "test_helper"
+
+class FailureTest < Minitest::Test
+  def test_unhandled_http_failure
+    stub_request(:get, "http://test.com/one").to_return(body: "something went wrong", status: 500)
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "http://test.com/one"
+        req.process do |body|
+          actions << "body: #{body}"
+        end
+      end
+    end
+    assert_equal [], actions
+  end
+
+  def test_http_failure_handled_in_request
+    stub_request(:get, "http://test.com/one").to_return(body: "something went wrong", status: 500)
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "http://test.com/one"
+        req.failure do |code, url|
+          actions << "handled error #{code} from #{url}"
+        end
+        req.process do |body|
+          actions << "body: #{body}"
+        end
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["handled error 500 from http://test.com/one"], actions
+  end
+
+  def test_http_failure_scope_handled_in_request
+    stub_request(:get, "http://test.com/one").to_return(body: "something went wrong", status: 500)
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "http://test.com/one"
+        req.failure do |code, url|
+          actions << "handled error #{code} from #{url} (#{some_instance_method})"
+        end
+        req.process do |body|
+          actions << "body: #{body}"
+        end
+      end
+
+      def some_instance_method
+        "it worked"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["handled error 500 from http://test.com/one (it worked)"], actions
+  end
+
+  def test_http_failure_handled_in_module
+    stub_request(:get, "http://test.com/one").to_return(body: "something went wrong", status: 500)
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "http://test.com/one"
+        req.process do |body|
+          actions << "body: #{body}"
+        end
+      end
+      failure do |code, url|
+        actions << "handled error #{code} from #{url}"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["handled error 500 from http://test.com/one"], actions
+  end
+
+  def test_http_failure_scope_handled_in_module
+    stub_request(:get, "http://test.com/one").to_return(body: "something went wrong", status: 500)
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "http://test.com/one"
+        req.process do |body|
+          actions << "body: #{body}"
+        end
+      end
+      failure do |code, url|
+        actions << "handled error #{code} from #{url} (#{some_instance_method})"
+      end
+      def some_instance_method
+        "it worked"
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["handled error 500 from http://test.com/one (it worked)"], actions
+  end
+end

data/test/module/fetch_if_test.rb

@@ -0,0 +1,75 @@
+require "test_helper"
+
+class FetchIfTest < Minitest::Test
+  def test_positive_fetch_if_filter
+    stub_request(:get, "http://test.com/one").to_return(body: "got one")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      fetch_if { true }
+
+      request do |req|
+        req.url = "http://test.com/one"
+        req.process do |body|
+          actions << "body: #{body}"
+        end
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["body: got one"], actions
+  end
+
+  def test_negative_fetch_if_filter
+    stub_request(:get, "http://test.com/one").to_return(body: "got one")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      fetch_if { false }
+
+      request do |req|
+        req.url = "http://test.com/one"
+        req.process do |body|
+          actions << "body: #{body}"
+        end
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal [], actions
+  end
+
+  def test_nil_fetch_if_filter
+    stub_request(:get, "http://test.com/one").to_return(body: "got one")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      fetch_if { nil }
+
+      request do |req|
+        req.url = "http://test.com/one"
+        req.process do |body|
+          actions << "body: #{body}"
+        end
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal [], actions
+  end
+
+  def test_fetch_if_scope
+    stub_request(:get, "http://test.com/one").to_return(body: "got one")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      fetch_if { should_i_fetch? }
+
+      request do |req|
+        req.url = "http://test.com/one"
+        req.process do |body|
+          actions << "body: #{body}"
+        end
+      end
+
+      def should_i_fetch?
+        true
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["body: got one"], actions
+  end
+end

data/test/module/module_test.rb

@@ -0,0 +1,88 @@
+require "test_helper"
+
+class ModuleTest < Minitest::Test
+  def test_fetch_using_get
+    stub_request(:get, "http://test.com/one").to_return(body: "got one")
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.url = "http://test.com/one"
+        req.process do |body|
+          actions << "body: #{body}"
+        end
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["body: got one"], actions
+  end
+
+  def test_fetch_using_post
+    stub_request(:post, "http://test.com/create").to_return(->(req) { { body: "you posted: #{req.body}" } })
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      request do |req|
+        req.method = :post
+        req.url = "http://test.com/create"
+        req.body = { one: 1, two: 2 }
+        req.process do |body|
+          actions << "body: #{body}"
+        end
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["body: you posted: one=1&two=2"], actions
+  end
+
+  def test_empty_url
+    stub_request(:get, "http://test.com/one").to_return(body: "got one")
+
+    actions = []
+    mod = Class.new(Fetch::Module) do
+      2.times do
+        request do |req|
+          req.url = "http://test.com/one"
+          req.process do |body|
+            actions << "process: #{body}"
+          end
+        end
+      end
+      2.times do
+        request do |req|
+          req.process do |body|
+            actions << "process: #{body}"
+          end
+        end
+      end
+    end
+
+    updates = []
+    klass = Class.new(MockFetcher(mod)) do
+      progress do |percent|
+        updates << percent
+      end
+    end
+
+    klass.new.fetch
+    assert_equal ["process: got one", "process: got one"], actions
+    assert_equal [0, 50, 100], updates
+  end
+
+  def test_multiple_requests
+    words = %w{one two three}
+    words.each { |w| stub_request(:get, "http://test.com/#{w}").to_return(body: "got #{w}") }
+    actions = []
+
+    mod = Class.new(Fetch::Module) do
+      words.each do |w|
+        request do |req|
+          req.url = "http://test.com/#{w}"
+          req.process do |body|
+            actions << "body: #{body}"
+          end
+        end
+      end
+    end
+    MockFetcher(mod).new.fetch
+    assert_equal ["body: got one", "body: got two", "body: got three"], actions
+  end
+end