zenrows 0.2.1 → 0.3.0

data/test/zenrows/hooks_test.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class HooksTest < Minitest::Test
+  def setup
+    @hooks = Zenrows::Hooks.new
+  end
+
+  def test_register_with_block
+    called = false
+    @hooks.register(:on_response) { called = true }
+
+    @hooks.run(:on_response, nil, {})
+
+    assert called
+  end
+
+  def test_register_with_callable
+    called = false
+    callable = ->(resp, ctx) { called = true }
+    @hooks.register(:on_response, callable)
+
+    @hooks.run(:on_response, nil, {})
+
+    assert called
+  end
+
+  def test_register_raises_on_invalid_event
+    assert_raises ArgumentError do
+      @hooks.register(:invalid_event) {}
+    end
+  end
+
+  def test_register_raises_without_handler
+    assert_raises ArgumentError do
+      @hooks.register(:on_response)
+    end
+  end
+
+  def test_register_raises_on_non_callable
+    assert_raises ArgumentError do
+      @hooks.register(:on_response, "not callable")
+    end
+  end
+
+  def test_multiple_callbacks_for_same_event
+    results = []
+    @hooks.register(:on_response) { results << 1 }
+    @hooks.register(:on_response) { results << 2 }
+
+    @hooks.run(:on_response, nil, {})
+
+    assert_equal [1, 2], results
+  end
+
+  def test_add_subscriber
+    subscriber = Object.new
+    def subscriber.on_response(resp, ctx)
+      @called = true
+    end
+
+    def subscriber.called?
+      @called
+    end
+
+    @hooks.add_subscriber(subscriber)
+    @hooks.run(:on_response, nil, {})
+
+    assert_predicate subscriber, :called?
+  end
+
+  def test_subscriber_with_multiple_methods
+    subscriber = Object.new
+    subscriber.instance_variable_set(:@calls, [])
+    def subscriber.before_request(ctx)
+      @calls << :before
+    end
+
+    def subscriber.on_response(resp, ctx)
+      @calls << :response
+    end
+
+    def subscriber.calls
+      @calls
+    end
+
+    @hooks.add_subscriber(subscriber)
+    @hooks.run(:before_request, {})
+    @hooks.run(:on_response, nil, {})
+
+    assert_equal [:before, :response], subscriber.calls
+  end
+
+  def test_empty_when_no_hooks
+    assert_empty @hooks
+  end
+
+  def test_not_empty_after_register
+    @hooks.register(:on_response) {}
+
+    refute_empty @hooks
+  end
+
+  def test_not_empty_after_add_subscriber
+    @hooks.add_subscriber(Object.new)
+
+    refute_empty @hooks
+  end
+
+  def test_dup_creates_independent_copy
+    @hooks.register(:on_response) {}
+
+    copy = @hooks.dup
+    copy.register(:on_error) {}
+
+    # Original should not have on_error
+    refute_empty @hooks
+    refute_empty copy
+  end
+
+  def test_merge_combines_hooks
+    other = Zenrows::Hooks.new
+    results = []
+
+    @hooks.register(:on_response) { results << 1 }
+    other.register(:on_response) { results << 2 }
+
+    @hooks.merge(other)
+    @hooks.run(:on_response, nil, {})
+
+    assert_equal [1, 2], results
+  end
+
+  def test_merge_with_nil_is_noop
+    @hooks.register(:on_response) {}
+    @hooks.merge(nil)
+
+    refute_empty @hooks
+  end
+
+  def test_around_request_wraps_block
+    order = []
+
+    @hooks.register(:around_request) do |ctx, &block|
+      order << :before
+      result = block.call
+      order << :after
+      result
+    end
+
+    result = @hooks.run_around({}) do
+      order << :inside
+      :result
+    end
+
+    assert_equal [:before, :inside, :after], order
+    assert_equal :result, result
+  end
+
+  def test_multiple_around_hooks_chain
+    order = []
+
+    @hooks.register(:around_request) do |ctx, &block|
+      order << :outer_before
+      result = block.call
+      order << :outer_after
+      result
+    end
+
+    @hooks.register(:around_request) do |ctx, &block|
+      order << :inner_before
+      result = block.call
+      order << :inner_after
+      result
+    end
+
+    @hooks.run_around({}) do
+      order << :core
+      :result
+    end
+
+    assert_equal [:outer_before, :inner_before, :core, :inner_after, :outer_after], order
+  end
+
+  def test_run_around_without_hooks
+    result = @hooks.run_around({}) { :result }
+
+    assert_equal :result, result
+  end
+
+  def test_valid_events
+    assert_equal [:before_request, :after_request, :on_response, :on_error, :around_request],
+      Zenrows::Hooks::EVENTS
+  end
+
+  def test_run_passes_arguments_to_callbacks
+    received_args = nil
+    @hooks.register(:on_response) { |resp, ctx| received_args = [resp, ctx] }
+
+    @hooks.run(:on_response, :response, {key: :value})
+
+    assert_equal [:response, {key: :value}], received_args
+  end
+
+  def test_returns_self_for_chaining
+    result = @hooks.register(:on_response) {}
+
+    assert_same @hooks, result
+
+    result = @hooks.add_subscriber(Object.new)
+
+    assert_same @hooks, result
+  end
+end

data/test/zenrows/instrumented_client_test.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class InstrumentedClientTest < Minitest::Test
+  def setup
+    @hooks = Zenrows::Hooks.new
+    @mock_http = MockHttpClient.new
+    @context_base = {options: {js_render: true}, backend: :http_rb}
+  end
+
+  def test_get_delegates_to_http_client
+    client = Zenrows::InstrumentedClient.new(@mock_http, hooks: @hooks, context_base: @context_base)
+    client.get("https://example.com")
+
+    assert_equal [[:get, "https://example.com", {}]], @mock_http.calls
+  end
+
+  def test_post_delegates_to_http_client
+    client = Zenrows::InstrumentedClient.new(@mock_http, hooks: @hooks, context_base: @context_base)
+    client.post("https://example.com", body: "data")
+
+    assert_equal [[:post, "https://example.com", {body: "data"}]], @mock_http.calls
+  end
+
+  def test_runs_before_request_hook
+    before_called = false
+    @hooks.register(:before_request) { |ctx| before_called = true }
+
+    client = Zenrows::InstrumentedClient.new(@mock_http, hooks: @hooks, context_base: @context_base)
+    client.get("https://example.com")
+
+    assert before_called
+  end
+
+  def test_runs_on_response_hook
+    received_response = nil
+    received_context = nil
+    @hooks.register(:on_response) do |resp, ctx|
+      received_response = resp
+      received_context = ctx
+    end
+
+    client = Zenrows::InstrumentedClient.new(@mock_http, hooks: @hooks, context_base: @context_base)
+    client.get("https://example.com")
+
+    assert_instance_of MockResponse, received_response
+    assert_equal :get, received_context[:method]
+    assert_equal "https://example.com", received_context[:url]
+    assert_equal "example.com", received_context[:host]
+  end
+
+  def test_runs_after_request_hook
+    after_called = false
+    @hooks.register(:after_request) { |ctx| after_called = true }
+
+    client = Zenrows::InstrumentedClient.new(@mock_http, hooks: @hooks, context_base: @context_base)
+    client.get("https://example.com")
+
+    assert after_called
+  end
+
+  def test_runs_on_error_hook_and_reraises
+    error = StandardError.new("Connection failed")
+    received_error = nil
+    received_context = nil
+
+    @hooks.register(:on_error) do |err, ctx|
+      received_error = err
+      received_context = ctx
+    end
+
+    # Create a mock that raises
+    error_http = Object.new
+    error_http.define_singleton_method(:get) { |*| raise error }
+
+    client = Zenrows::InstrumentedClient.new(error_http, hooks: @hooks, context_base: @context_base)
+
+    raised = assert_raises StandardError do
+      client.get("https://example.com")
+    end
+
+    assert_equal error, raised
+    assert_equal error, received_error
+    assert_equal "https://example.com", received_context[:url]
+  end
+
+  def test_runs_around_request_hook
+    order = []
+
+    @hooks.register(:around_request) do |ctx, &block|
+      order << :before
+      result = block.call
+      order << :after
+      result
+    end
+
+    client = Zenrows::InstrumentedClient.new(@mock_http, hooks: @hooks, context_base: @context_base)
+    client.get("https://example.com")
+
+    assert_equal [:before, :after], order
+  end
+
+  def test_hook_execution_order
+    order = []
+
+    @hooks.register(:before_request) { order << :before }
+    @hooks.register(:around_request) do |ctx, &block|
+      order << :around_before
+      result = block.call
+      order << :around_after
+      result
+    end
+    @hooks.register(:on_response) { order << :on_response }
+    @hooks.register(:after_request) { order << :after }
+
+    client = Zenrows::InstrumentedClient.new(@mock_http, hooks: @hooks, context_base: @context_base)
+    client.get("https://example.com")
+
+    assert_equal [:before, :around_before, :on_response, :around_after, :after], order
+  end
+
+  def test_method_missing_delegates_to_http
+    client = Zenrows::InstrumentedClient.new(@mock_http, hooks: @hooks, context_base: @context_base)
+    result = client.custom_method(:arg1, :arg2)
+
+    assert_equal :result, result
+    assert_equal [[:custom_method, :arg1, :arg2]], @mock_http.calls
+  end
+
+  def test_respond_to_missing
+    client = Zenrows::InstrumentedClient.new(@mock_http, hooks: @hooks, context_base: @context_base)
+
+    assert_respond_to client, :custom_method
+  end
+
+  def test_context_includes_zenrows_headers
+    received_headers = nil
+    @hooks.register(:on_response) { |resp, ctx| received_headers = ctx[:zenrows_headers] }
+
+    response = MockResponse.new(200, {
+      "Concurrency-Limit" => "25",
+      "X-Request-Cost" => "5.0"
+    })
+    @mock_http.stub_response(:get, "https://example.com", response)
+
+    client = Zenrows::InstrumentedClient.new(@mock_http, hooks: @hooks, context_base: @context_base)
+    client.get("https://example.com")
+
+    assert_equal 25, received_headers[:concurrency_limit]
+    assert_in_delta(5.0, received_headers[:request_cost])
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: zenrows
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Ernest Bursa
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http
@@ -66,6 +66,10 @@ files:
 - lib/zenrows/configuration.rb
 - lib/zenrows/css_extractor.rb
 - lib/zenrows/errors.rb
+- lib/zenrows/hooks.rb
+- lib/zenrows/hooks/context.rb
+- lib/zenrows/hooks/log_subscriber.rb
+- lib/zenrows/instrumented_client.rb
 - lib/zenrows/js_instructions.rb
 - lib/zenrows/proxy.rb
 - lib/zenrows/railtie.rb
@@ -83,13 +87,24 @@ files:
 - sig/zenrows/configuration.rbs
 - sig/zenrows/css_extractor.rbs
 - sig/zenrows/errors.rbs
+- sig/zenrows/hook_configurator.rbs
+- sig/zenrows/hooks.rbs
+- sig/zenrows/hooks/context.rbs
+- sig/zenrows/hooks/log_subscriber.rbs
+- sig/zenrows/instrumented_client.rbs
 - sig/zenrows/js_instructions.rbs
 - sig/zenrows/proxy.rbs
 - test/test_helper.rb
 - test/zenrows/api_client_test.rb
 - test/zenrows/api_response_test.rb
+- test/zenrows/client_hooks_test.rb
 - test/zenrows/client_test.rb
+- test/zenrows/configuration_hooks_test.rb
 - test/zenrows/css_extractor_test.rb
+- test/zenrows/hooks/context_test.rb
+- test/zenrows/hooks/log_subscriber_test.rb
+- test/zenrows/hooks_test.rb
+- test/zenrows/instrumented_client_test.rb
 - test/zenrows/js_instructions_test.rb
 - test/zenrows/proxy_test.rb
 - test/zenrows_test.rb
@@ -116,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Ruby client for ZenRows web scraping API via proxy mode
 test_files: []