fbe 0.23.5 → 0.23.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 157b3bb591e16d535883feb11b531f9f64a9b87dd078f858345a7f91cc29185d
-  data.tar.gz: bb1b991edbcec6cf8caaedb11e32e8359d5f0487d1339572f0e43e4cf296354f
+  metadata.gz: 36afd4e19f2a84e050e41ba6395a35cbc1bd404c8f6c1971affd64aa4c9c9e27
+  data.tar.gz: 904a216825c9bb411036db7c2486e492a6a58ca6b77f26b05f39c37cae377867
 SHA512:
-  metadata.gz: 9821935ea70538efc8847b7368ed2af195f40f348f07ab432f52712bdafa85b5c629455079d8697ca0c7b5a969c93233d99d133ae5744a1c7c7f359a26483d89
-  data.tar.gz: 105e6d4f0934d8ce1b166e43417c258944f0e502ee6de1fa8487f9ccbe656f1f9f67c5a50a76403a98f89986576e44aad6bb9f12d75e8ee7a2d7e096b67ccdcb
+  metadata.gz: a3de96beb257378efe098e4ba1406a06dab673c6717ef249fd92bd31b92483f983847af33e6b34d00b707c4bddf2271f8afee4a597802e9c9d80300cd343625c
+  data.tar.gz: ce3036d1e93ca6585bc188724c9e34552ce5bc658c8d15ffe5e74d0cf59682322475941cac47e33c76338da5e07d84a44d4f0b0b407084c7918e26f7421b1a54

data/.github/workflows/typos.yml

@@ -16,6 +16,6 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v4
-      - uses: crate-ci/typos@v1.33.1
+      - uses: crate-ci/typos@v1.34.0
         with:
           config: .github/.typos.toml

data/lib/fbe/middleware/rate_limit.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Zerocracy
+# SPDX-License-Identifier: MIT
+
+require 'faraday'
+require 'json'
+require_relative '../../fbe'
+require_relative '../../fbe/middleware'
+
+# Faraday middleware that caches GitHub API rate limit information.
+#
+# This middleware intercepts calls to the /rate_limit endpoint and caches
+# the results locally. It tracks the remaining requests count and decrements
+# it for each API call. Every 100 requests, it refreshes the cached data
+# by allowing the request to pass through to the GitHub API.
+#
+# @example Usage in Faraday middleware stack
+#   connection = Faraday.new do |f|
+#     f.use Fbe::Middleware::RateLimit
+#   end
+#
+# Author:: Yegor Bugayenko (yegor256@gmail.com)
+# Copyright:: Copyright (c) 2024-2025 Zerocracy
+# License:: MIT
+class Fbe::Middleware::RateLimit < Faraday::Middleware
+  # Initializes the rate limit middleware.
+  #
+  # @param [Object] app The next middleware in the stack
+  def initialize(app)
+    super
+    @cached_response = nil
+    @remaining_count = nil
+    @request_counter = 0
+  end
+
+  # Processes the HTTP request and handles rate limit caching.
+  #
+  # @param [Faraday::Env] env The request environment
+  # @return [Faraday::Response] The response from cache or the next middleware
+  def call(env)
+    if env.url.path == '/rate_limit'
+      handle_rate_limit_request(env)
+    else
+      track_request
+      @app.call(env)
+    end
+  end
+
+  private
+
+  # Handles requests to the rate_limit endpoint.
+  #
+  # @param [Faraday::Env] env The request environment
+  # @return [Faraday::Response] Cached or fresh response
+  def handle_rate_limit_request(env)
+    if @cached_response.nil? || @request_counter >= 100
+      response = @app.call(env)
+      @cached_response = response.dup
+      @remaining_count = extract_remaining_count(response)
+      @request_counter = 0
+      response
+    else
+      response = @cached_response.dup
+      update_remaining_count(response)
+      Faraday::Response.new(response_env(env, response))
+    end
+  end
+
+  # Tracks non-rate_limit requests and decrements counter.
+  def track_request
+    return if @remaining_count.nil?
+    @remaining_count -= 1 if @remaining_count.positive?
+    @request_counter += 1
+  end
+
+  # Extracts the remaining count from the response body.
+  #
+  # @param [Faraday::Response] response The API response
+  # @return [Integer] The remaining requests count
+  def extract_remaining_count(response)
+    body = response.body
+    if body.is_a?(String)
+      begin
+        body = JSON.parse(body)
+      rescue JSON::ParserError
+        return 0
+      end
+    end
+    return 0 unless body.is_a?(Hash)
+    body.dig('rate', 'remaining') || 0
+  end
+
+  # Updates the remaining count in the response body.
+  #
+  # @param [Faraday::Response] response The cached response to update
+  def update_remaining_count(response)
+    body = response.body
+    original_was_string = body.is_a?(String)
+    if original_was_string
+      begin
+        body = JSON.parse(body)
+      rescue JSON::ParserError
+        return
+      end
+    end
+    return unless body.is_a?(Hash) && body['rate']
+    body['rate']['remaining'] = @remaining_count
+    return unless original_was_string
+    response.instance_variable_set(:@body, body.to_json)
+  end
+
+  # Creates a response environment for the cached response.
+  #
+  # @param [Faraday::Env] env The original request environment
+  # @param [Faraday::Response] response The cached response
+  # @return [Hash] Response environment hash
+  def response_env(env, response)
+    headers = response.headers.dup
+    headers['x-ratelimit-remaining'] = @remaining_count.to_s if @remaining_count
+    {
+      method: env.method,
+      url: env.url,
+      request_headers: env.request_headers,
+      request_body: env.request_body,
+      status: response.status,
+      response_headers: headers,
+      body: response.body
+    }
+  end
+end

data/lib/fbe/middleware/trace.rb

@@ -31,9 +31,12 @@ class Fbe::Middleware::Trace < Faraday::Middleware
   #
   # @param [Object] app The next middleware in the stack
   # @param [Array] trace The array to store trace entries
-  def initialize(app, trace)
+  # @param [Array<Symbol>] ignores The array of symbols (see Faraday::HttpCache::CACHE_STATUSES),
+  # which will be ignored
+  def initialize(app, trace, ignores: [])
     super(app)
     @trace = trace
+    @ignores = ignores
   end
 
   # Processes the HTTP request and records trace information.
@@ -47,6 +50,9 @@ class Fbe::Middleware::Trace < Faraday::Middleware
       started_at: Time.now
     }
     @app.call(env).on_complete do |response_env|
+      next if !@ignores.empty? &&
+              response_env[:http_cache_trace] &&
+              (response_env[:http_cache_trace] & @ignores).size.positive?
       finished = Time.now
       duration = finished - entry[:started_at]
       entry[:status] = response_env.status

data/lib/fbe/octo.rb

@@ -20,6 +20,7 @@ require 'verbose'
 require_relative '../fbe'
 require_relative 'middleware'
 require_relative 'middleware/formatter'
+require_relative 'middleware/rate_limit'
 require_relative 'middleware/sqlite_store'
 require_relative 'middleware/trace'
 
@@ -85,6 +86,10 @@ def Fbe.octo(options: $options, global: $global, loog: $loog)
               methods: [:get],
               backoff_factor: 2
             )
+            builder.use(Octokit::Response::RaiseError)
+            builder.use(Faraday::Response::Logger, loog, formatter: Fbe::Middleware::Formatter)
+            builder.use(Fbe::Middleware::RateLimit)
+            builder.use(Fbe::Middleware::Trace, trace, ignores: [:fresh])
             if options.sqlite_cache
               maxsize = Filesize.from(options.sqlite_cache_maxsize || '10M').to_i
               maxvsize = Filesize.from(options.sqlite_cache_maxvsize || '10K').to_i
@@ -105,9 +110,6 @@ def Fbe.octo(options: $options, global: $global, loog: $loog)
                 serializer: Marshal, shared_cache: false, logger: Loog::NULL
               )
             end
-            builder.use(Octokit::Response::RaiseError)
-            builder.use(Faraday::Response::Logger, loog, formatter: Fbe::Middleware::Formatter)
-            builder.use(Fbe::Middleware::Trace, trace)
             builder.adapter(Faraday.default_adapter)
           end
         o.middleware = stack

data/lib/fbe.rb

@@ -10,5 +10,5 @@
 # License:: MIT
 module Fbe
   # Current version of the gem (changed by +.rultor.yml+ on every release)
-  VERSION = '0.23.5' unless const_defined?(:VERSION)
+  VERSION = '0.23.7' unless const_defined?(:VERSION)
 end

data/test/fbe/middleware/test_rate_limit.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Zerocracy
+# SPDX-License-Identifier: MIT
+
+require 'faraday'
+require 'webmock'
+require_relative '../../test__helper'
+require_relative '../../../lib/fbe'
+require_relative '../../../lib/fbe/middleware'
+require_relative '../../../lib/fbe/middleware/rate_limit'
+
+# Test.
+# Author:: Yegor Bugayenko (yegor256@gmail.com)
+# Copyright:: Copyright (c) 2024-2025 Zerocracy
+# License:: MIT
+class RateLimitTest < Fbe::Test
+  def test_caches_rate_limit_response_on_first_call
+    rate_limit_response = {
+      'rate' => {
+        'limit' => 5000,
+        'remaining' => 4999,
+        'reset' => 1_672_531_200
+      }
+    }
+    stub_request(:get, 'https://api.github.com/rate_limit')
+      .to_return(status: 200, body: rate_limit_response.to_json, headers: { 'Content-Type' => 'application/json' })
+    conn = create_connection
+    response = conn.get('/rate_limit')
+    assert_equal 200, response.status
+    assert_equal 4999, response.body['rate']['remaining']
+  end
+
+  def test_returns_cached_response_on_subsequent_calls
+    rate_limit_response = {
+      'rate' => {
+        'limit' => 5000,
+        'remaining' => 4999,
+        'reset' => 1_672_531_200
+      }
+    }
+    stub_request(:get, 'https://api.github.com/rate_limit')
+      .to_return(status: 200, body: rate_limit_response.to_json, headers: { 'Content-Type' => 'application/json' })
+      .times(1)
+    conn = create_connection
+    conn.get('/rate_limit')
+    response = conn.get('/rate_limit')
+    assert_equal 200, response.status
+    assert_equal 4999, response.body['rate']['remaining']
+    assert_requested :get, 'https://api.github.com/rate_limit', times: 1
+  end
+
+  def test_decrements_remaining_count_for_non_rate_limit_requests
+    rate_limit_response = {
+      'rate' => {
+        'limit' => 5000,
+        'remaining' => 4999,
+        'reset' => 1_672_531_200
+      }
+    }
+    stub_request(:get, 'https://api.github.com/rate_limit')
+      .to_return(status: 200, body: rate_limit_response.to_json, headers: { 'Content-Type' => 'application/json',
+                                                                            'X-RateLimit-Remaining' => '4999' })
+    stub_request(:get, 'https://api.github.com/user')
+      .to_return(status: 200, body: '{"login": "test"}', headers: { 'Content-Type' => 'application/json' })
+    conn = create_connection
+    conn.get('/rate_limit')
+    conn.get('/user')
+    response = conn.get('/rate_limit')
+    assert_equal 4998, response.body['rate']['remaining']
+    assert_equal '4998', response.headers['x-ratelimit-remaining']
+  end
+
+  def test_refreshes_cache_after_hundred_requests
+    rate_limit_response = {
+      'rate' => {
+        'limit' => 5000,
+        'remaining' => 4999,
+        'reset' => 1_672_531_200
+      }
+    }
+    refreshed_response = {
+      'rate' => {
+        'limit' => 5000,
+        'remaining' => 4950,
+        'reset' => 1_672_531_200
+      }
+    }
+    stub_request(:get, 'https://api.github.com/rate_limit')
+      .to_return(status: 200, body: rate_limit_response.to_json, headers: { 'Content-Type' => 'application/json' })
+      .then
+      .to_return(status: 200, body: refreshed_response.to_json, headers: { 'Content-Type' => 'application/json' })
+    stub_request(:get, 'https://api.github.com/user')
+      .to_return(status: 200, body: '{"login": "test"}', headers: { 'Content-Type' => 'application/json' })
+      .times(100)
+    conn = create_connection
+    conn.get('/rate_limit')
+    100.times { conn.get('/user') }
+    response = conn.get('/rate_limit')
+    assert_equal 4950, response.body['rate']['remaining']
+    assert_requested :get, 'https://api.github.com/rate_limit', times: 2
+  end
+
+  def test_handles_response_without_rate_data
+    stub_request(:get, 'https://api.github.com/rate_limit')
+      .to_return(status: 200, body: '{}', headers: { 'Content-Type' => 'application/json' })
+    conn = create_connection
+    response = conn.get('/rate_limit')
+    assert_equal 200, response.status
+    assert_empty(response.body)
+  end
+
+  def test_ignores_non_hash_response_body
+    stub_request(:get, 'https://api.github.com/rate_limit')
+      .to_return(status: 200, body: 'invalid json', headers: { 'Content-Type' => 'text/plain' })
+    conn = create_connection
+    response = conn.get('/rate_limit')
+    assert_equal 200, response.status
+    assert_equal 'invalid json', response.body
+  end
+
+  def test_handles_zero_remaining_count
+    rate_limit_response = {
+      'rate' => {
+        'limit' => 5000,
+        'remaining' => 1,
+        'reset' => 1_672_531_200
+      }
+    }
+    stub_request(:get, 'https://api.github.com/rate_limit')
+      .to_return(status: 200, body: rate_limit_response.to_json, headers: { 'Content-Type' => 'application/json' })
+    stub_request(:get, 'https://api.github.com/user')
+      .to_return(status: 200, body: '{"login": "test"}', headers: { 'Content-Type' => 'application/json' })
+      .times(2)
+    conn = create_connection
+    conn.get('/rate_limit')
+    conn.get('/user')
+    conn.get('/user')
+    response = conn.get('/rate_limit')
+    assert_equal 0, response.body['rate']['remaining']
+  end
+
+  private
+
+  def create_connection
+    Faraday.new(url: 'https://api.github.com') do |f|
+      f.use Fbe::Middleware::RateLimit
+      f.response :json
+      f.adapter :net_http
+    end
+  end
+end

data/test/fbe/middleware/test_trace.rb

@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: MIT
 
 require 'faraday'
+require 'faraday/http_cache'
 require 'webmock'
 require_relative '../../test__helper'
 require_relative '../../../lib/fbe'
@@ -103,4 +104,65 @@ class TraceTest < Fbe::Test
     assert_includes url, 'q=test'
     assert_includes url, 'page=2'
   end
+
+  def test_trace_and_cache_middlewares_together
+    WebMock.disable_net_connect!
+    now = Time.now
+    stub_request(:get, 'https://api.example.com/page')
+      .to_return(
+        status: 200,
+        headers: {
+          'date' => now.httpdate,
+          'cache-control' => 'public, max-age=60, s-maxage=60',
+          'last-modified' => (now - (6 * 60 * 60)).httpdate
+        },
+        body: 'some body 1'
+      )
+      .times(1)
+      .then
+      .to_return(
+        status: 200,
+        headers: {
+          'date' => (now + 70).httpdate,
+          'cache-control' => 'public, max-age=60, s-maxage=60',
+          'last-modified' => (now - (6 * 60 * 60)).httpdate,
+          'content-type' => 'application/json; charset=utf-8'
+        },
+        body: 'some body 2'
+      )
+      .times(1)
+      .then.to_raise('no more request to /page')
+    trace_real = []
+    trace_full = []
+    builder =
+      Faraday::RackBuilder.new do |f|
+        f.use Fbe::Middleware::Trace, trace_full
+        f.use(Faraday::HttpCache, serializer: Marshal, shared_cache: false, logger: Loog::NULL)
+        f.use Fbe::Middleware::Trace, trace_real
+        f.adapter :net_http
+      end
+    conn = Faraday::Connection.new(builder: builder)
+    5.times do
+      r = conn.get('https://api.example.com/page')
+      assert_equal('some body 1', r.body)
+    end
+    assert_equal(1, trace_real.size)
+    assert_equal(5, trace_full.size)
+    trace_real.clear
+    trace_full.clear
+    5.times do
+      r = conn.get('https://api.example.com/page')
+      assert_equal('some body 1', r.body)
+    end
+    assert_equal(0, trace_real.size)
+    assert_equal(5, trace_full.size)
+    Time.stub(:now, now + 70) do
+      5.times do
+        r = conn.get('https://api.example.com/page')
+        assert_equal('some body 2', r.body)
+      end
+    end
+    assert_equal(1, trace_real.size)
+    assert_equal(10, trace_full.size)
+  end
 end

data/test/fbe/test_conclude.rb

@@ -79,11 +79,7 @@ class TestConclude < Fbe::Test
       }
     )
     stub_request(:get, 'https://api.github.com/rate_limit').to_return(
-      { body: 'hm...', headers: { 'X-RateLimit-Remaining' => '777' } },
-      { body: 'hm...', headers: { 'X-RateLimit-Remaining' => '777' } },
-      { body: 'hm...', headers: { 'X-RateLimit-Remaining' => '777' } },
-      { body: 'hm...', headers: { 'X-RateLimit-Remaining' => '999' } },
-      { body: 'hm...', headers: { 'X-RateLimit-Remaining' => '9' } }
+      { body: '{"rate":{"remaining":51}}', headers: { 'X-RateLimit-Remaining' => '51' } }
     )
     global = {}
     o = Fbe.octo(loog: Loog::NULL, options:, global:)

data/test/fbe/test_octo.rb

@@ -99,7 +99,7 @@ class TestOcto < Fbe::Test
   def test_caching
     WebMock.disable_net_connect!
     stub_request(:get, 'https://api.github.com/rate_limit').to_return(
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '222' } }
+      { body: '{"rate":{"remaining":222}}', headers: { 'X-RateLimit-Remaining' => '222' } }
     )
     global = {}
     o = Fbe.octo(loog: Loog::NULL, global:, options: Judges::Options.new)
@@ -133,12 +133,10 @@ class TestOcto < Fbe::Test
   def test_off_quota?
     WebMock.disable_net_connect!
     stub_request(:get, 'https://api.github.com/rate_limit').to_return(
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '333' } },
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '333' } },
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '3' } }
+      { body: '{"rate":{"remaining":50}}', headers: { 'X-RateLimit-Remaining' => '50' } }
     )
     stub_request(:get, 'https://api.github.com/user/42').to_return(
-      body: '', headers: { 'X-RateLimit-Remaining' => '3' }
+      body: '', headers: { 'X-RateLimit-Remaining' => '49' }
     )
     o = Fbe.octo(loog: Loog::NULL, global: {}, options: Judges::Options.new)
     refute_predicate(o, :off_quota?)
@@ -149,11 +147,7 @@ class TestOcto < Fbe::Test
   def test_off_quota_twice
     WebMock.disable_net_connect!
     stub_request(:get, 'https://api.github.com/rate_limit').to_return(
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '333' } },
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '333' } },
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '333' } },
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '5555' } },
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '5' } }
+      { body: '{"rate":{"remaining":51}}', headers: { 'X-RateLimit-Remaining' => '51' } }
     )
     stub_request(:get, 'https://api.github.com/user/42').to_return(
       { body: '', headers: { 'X-RateLimit-Remaining' => '5555' } },
@@ -372,9 +366,9 @@ class TestOcto < Fbe::Test
     loog = Loog::Buffer.new
     WebMock.disable_net_connect!
     stub_request(:get, 'https://api.github.com/rate_limit').to_return(
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '222' } },
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '222' } },
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '222' } }
+      { body: '{"rate":{"remaining":222}}', headers: { 'X-RateLimit-Remaining' => '222' } },
+      { body: '{"rate":{"remaining":222}}', headers: { 'X-RateLimit-Remaining' => '222' } },
+      { body: '{"rate":{"remaining":222}}', headers: { 'X-RateLimit-Remaining' => '222' } }
     )
     stub_request(:get, 'https://api.github.com/user/123').to_return do
       {
@@ -396,9 +390,9 @@ class TestOcto < Fbe::Test
     octo.repository('foo/bar')
     octo.print_trace!(all: true, max: 9_999)
     output = loog.to_s
-    assert_includes output, '3 URLs vs 6 requests'
-    assert_includes output, '222 quota left'
-    assert_includes output, '/rate_limit: 3'
+    assert_includes output, '3 URLs vs 4 requests'
+    assert_includes output, '219 quota left'
+    assert_includes output, '/rate_limit: 1'
     assert_includes output, '/user/123: 1'
     assert_includes output, '/repos/foo/bar: 2'
     repo_index = output.index('/repos/foo/bar: 2')
@@ -427,12 +421,67 @@ class TestOcto < Fbe::Test
       octo = Fbe.octo(loog: Loog::NULL, global: {}, options: Judges::Options.new({ 'sqlite_cache' => fcache }))
       octo.user(123)
       loog = Loog::Buffer.new
-      octo = Fbe.octo(loog: fake_loog, global: {}, options: Judges::Options.new({ 'sqlite_cache' => fcache }))
+      octo = Fbe.octo(loog:, global: {}, options: Judges::Options.new({ 'sqlite_cache' => fcache }))
       WebMock.remove_request_stub(stub)
       octo.user(123)
-      octo.print_trace!
-      assert_empty(loog.to_s)
+      octo.print_trace!(all: true)
+      refute_match('/user/123: 1', loog.to_s)
+    end
+  end
+
+  def test_octo_not_trace_cached_requests
+    WebMock.disable_net_connect!
+    now = Time.now
+    stub_request(:get, 'https://api.github.com/rate_limit')
+      .to_return(
+        status: 200, headers: { 'Content-Type' => 'application/json', 'X-RateLimit-Remaining' => '5000' },
+        body: { 'rate' => { 'limit' => 5000, 'remaining' => 5000, 'reset' => 1_672_531_200 } }.to_json
+      )
+    stub_request(:get, 'https://api.github.com/repos/zerocracy/baza.rb')
+      .to_return(
+        status: 200,
+        headers: {
+          'date' => now.httpdate,
+          'cache-control' => 'public, max-age=60, s-maxage=60',
+          'last-modified' => (now - (6 * 60 * 60)).httpdate,
+          'content-type' => 'application/json; charset=utf-8'
+        },
+        body: { id: 840_215_648, name: 'baza.rb' }.to_json
+      )
+      .times(1)
+      .then
+      .to_return(
+        status: 200,
+        headers: {
+          'date' => (now + 70).httpdate,
+          'cache-control' => 'public, max-age=60, s-maxage=60',
+          'last-modified' => (now - (6 * 60 * 60)).httpdate,
+          'content-type' => 'application/json; charset=utf-8'
+        },
+        body: { id: 840_215_648, name: 'baza.rb' }.to_json
+      )
+      .times(1)
+      .then.to_raise('no more request to /repos/zerocracy/baza.rb')
+    loog = Loog::Buffer.new
+    o = Fbe.octo(loog:, global: {}, options: Judges::Options.new({}))
+    o.print_trace!(all: true)
+    Time.stub(:now, now) do
+      5.times do
+        o.repo('zerocracy/baza.rb')
+      end
     end
+    o.print_trace!(all: true)
+    Time.stub(:now, now + 70) do
+      25.times do
+        o.repo('zerocracy/baza.rb')
+      end
+    end
+    o.print_trace!(all: true)
+    assert_requested :get, 'https://api.github.com/repos/zerocracy/baza.rb', times: 2
+    output = loog.to_s
+    assert_match('/repos/zerocracy/baza.rb: 1', output)
+    refute_match('/repos/zerocracy/baza.rb: 5', output)
+    refute_match('/repos/zerocracy/baza.rb: 25', output)
   end
 
   def test_trace_gets_cleared_after_print
@@ -539,19 +588,78 @@ class TestOcto < Fbe::Test
   def test_fetch_rate_limit_by_making_new_request
     WebMock.disable_net_connect!
     stub_request(:get, 'https://api.github.com/rate_limit').to_return(
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '321' } }
-    ).to_return(
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '123' } }
-    ).to_return(
-      { body: '{}', headers: { 'X-RateLimit-Remaining' => '1' } }
-    ).to_raise(StandardError.new('no more requests to https://api.github.com/rate_limit'))
+      { body: '{"rate":{"remaining":321}}', headers: { 'X-RateLimit-Remaining' => '321' } }
+    )
     loog = Loog::Buffer.new
     o = Fbe.octo(loog:, global: {}, options: Judges::Options.new)
     refute_predicate(o, :off_quota?)
     assert_match(/321 GitHub API quota left/, loog.to_s)
     o.print_trace!(all: true)
-    assert_match(/123 quota left/, loog.to_s)
-    assert_predicate(o, :off_quota?)
-    assert_match(/1 GitHub API quota left/, loog.to_s)
+    assert_match(/321 quota left/, loog.to_s)
+  end
+
+  def test_throttling_request_to_rate_limit
+    WebMock.disable_net_connect!
+    stub_request(:get, 'https://api.github.com/rate_limit')
+      .to_return(
+        status: 200, headers: { 'Content-Type' => 'application/json', 'X-RateLimit-Remaining' => '5000' },
+        body: { 'rate' => { 'limit' => 5000, 'remaining' => 5000, 'reset' => 1_672_531_200 } }.to_json
+      )
+      .then.to_return(
+        status: 200, headers: { 'Content-Type' => 'application/json', 'X-RateLimit-Remaining' => '4900' },
+        body: { 'rate' => { 'limit' => 5000, 'remaining' => 4900, 'reset' => 1_672_531_200 } }.to_json
+      )
+      .then.to_return(
+        status: 200, headers: { 'Content-Type' => 'application/json', 'X-RateLimit-Remaining' => '4800' },
+        body: { 'rate' => { 'limit' => 5000, 'remaining' => 4800, 'reset' => 1_672_531_200 } }.to_json
+      )
+      .then.to_raise('no more request to /rate_limit')
+    stub_request(:get, 'https://api.github.com/user/1')
+      .to_return(
+        status: 200, headers: { 'Content-Type' => 'application/json' },
+        body: { 'id' => 1, 'login' => 'user1' }.to_json
+      ).times(1)
+    stub_request(:get, 'https://api.github.com/user/111')
+      .to_return(
+        status: 200, headers: { 'Content-Type' => 'application/json' },
+        body: { 'id' => 111, 'login' => 'user111' }.to_json
+      )
+      .times(201)
+      .then.to_raise('no more request to /user/111')
+    loog = Loog::Buffer.new
+    o = Fbe.octo(loog:, global: {}, options: Judges::Options.new({}))
+    o.user(1)
+    o.print_trace!(all: true)
+    201.times do
+      o.user(111)
+      o.rate_limit!.remaining
+    end
+    o.print_trace!(all: true)
+    output = loog.to_s
+    assert_requested :get, 'https://api.github.com/user/1', times: 1
+    assert_requested :get, 'https://api.github.com/user/111', times: 201
+    assert_requested :get, 'https://api.github.com/rate_limit', times: 3
+    assert_match('2 URLs vs 2 requests', output)
+    assert_match('/user/1: 1', output)
+    assert_match('/rate_limit: 1', output)
+    assert_match('2 URLs vs 203 requests', output)
+    assert_match('/user/111: 201', output)
+    assert_match('/rate_limit: 2', output)
+  end
+
+  def test_octo_http_cache_middleware_located_in_end_of_chain
+    WebMock.disable_net_connect!
+    stub_request(:get, 'https://api.github.com/rate_limit')
+      .to_return(
+        status: 200, headers: { 'Content-Type' => 'application/json', 'X-RateLimit-Remaining' => '5000' },
+        body: { 'rate' => { 'limit' => 5000, 'remaining' => 5000, 'reset' => 1_672_531_200 } }.to_json
+      )
+    o = Fbe.octo(loog: fake_loog, global: {}, options: Judges::Options.new({}))
+    assert_equal('Faraday::HttpCache', o.middleware.handlers.last.name, <<~MSG.strip.gsub!(/\s+/, ' '))
+      Faraday::HttpCache middleware must be located in the end of chain middlewares,
+      because the Oktokit client change Faraday::HttpCache position to the last,
+      for more info, see: https://github.com/zerocracy/fbe/issues/230#issuecomment-3020551743 and
+      https://github.com/octokit/octokit.rb/blob/ea3413c3174571e87c83d358fc893cc7613091fa/lib/octokit/connection.rb#L109-L119
+    MSG
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fbe
 version: !ruby/object:Gem::Version
-  version: 0.23.5
+  version: 0.23.7
 platform: ruby
 authors:
 - Yegor Bugayenko
@@ -363,6 +363,7 @@ files:
 - lib/fbe/just_one.rb
 - lib/fbe/middleware.rb
 - lib/fbe/middleware/formatter.rb
+- lib/fbe/middleware/rate_limit.rb
 - lib/fbe/middleware/sqlite_store.rb
 - lib/fbe/middleware/trace.rb
 - lib/fbe/octo.rb
@@ -376,6 +377,7 @@ files:
 - renovate.json
 - rules/basic.fe
 - test/fbe/middleware/test_formatter.rb
+- test/fbe/middleware/test_rate_limit.rb
 - test/fbe/middleware/test_sqlite_store.rb
 - test/fbe/middleware/test_trace.rb
 - test/fbe/test_award.rb