rage-rb 0.7.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c3041038ae63ae245e261a7a2096195ab56291d236414e086646ae96a4a6d16
-  data.tar.gz: a64817ded16716fe714310c7318d8e1d318454615da43d37055b333e76778fa2
+  metadata.gz: fd10469efc73f6134f72f79fe21871238b8860e958c085499c47b312adf91764
+  data.tar.gz: 34990a4885df4a4acd55fcbabf8d3a67e57e0609db406ee55d5f71cab0655ffb
 SHA512:
-  metadata.gz: 350f5150012852a3ca2532c031ce8ef28338da6d985ef66dff59095dea6b3dbbc4498826996876722bc5b7991683fed82c2fd3854313f7ed59f9fff20aaf4315
-  data.tar.gz: 84cd798056a43c8eb0e94809f72f6b0ac602076aa904831a3a049a8ed13352cad9321329233063343b73e65c0fbf1521564b0cee6f3696c89877a0af15191c94
+  metadata.gz: bc28afd194f122bf436c215cb6d88dfe3d923874f4e07c3c1db5dd3f33a4676354731fad3f6ffc29326423086b59dbb0d1860ecb5cb71cf4c7f0412a252af16f
+  data.tar.gz: 58cd0cea6daba63d67f9285d3b616980d2e69c778620c54b14c7c5cb1eccf093bfbc0644dec081c325d4cdc5f6c032b7f399ccb8ea5b052c1da401dcde08ed6e

data/.yardopts

@@ -1 +1 @@
---exclude lib/rage/templates --markup markdown --no-private -o doc
+--exclude lib/rage/templates --exclude lib/rage/rspec --exclude lib/rage/rails --markup markdown --no-private -o doc

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## [Unreleased]
 
+## [1.1.0] - 2024-03-25
+
+### Changed
+
+- Change the way controller names are logged (#72).
+- Use formatters in console (#71).
+
+### Fixed
+
+- Fix Fiber.await behavior in RSpec (#70).
+
+## [1.0.0] - 2024-03-13
+
+### Added
+
+- RSpec integration (#60).
+- Add DNS cache (#65).
+- Allow to disable the `FiberScheduler#io_write` hook (#63).
+
+### Fixed
+
+- Preload fiber ID (#62).
+- Release ActiveRecord connections on yield (#66).
+- Logger fixes (#64).
+- Fix publish calls in cluster mode (#67).
+
 ## [0.7.0] - 2024-01-09
 
 - Add conditional GET using `stale?` by [@tonekk](https://github.com/tonekk) (#55).

data/README.md

@@ -53,8 +53,12 @@ Check out in-depth API docs for more information:
 - [Fiber API](https://rage-rb.pages.dev/Fiber)
 - [Logger API](https://rage-rb.pages.dev/Rage/Logger)
 - [Configuration API](https://rage-rb.pages.dev/Rage/Configuration)
+- [CORS middleware](https://rage-rb.pages.dev/Rage/Cors)
 
-Also, see the [changelog](https://github.com/rage-rb/rage/blob/master/CHANGELOG.md) and [upcoming-releases](https://github.com/rage-rb/rage#upcoming-releases) for currently supported and planned features.
+Also, see the following integration guides:
+
+- [Rails integration](https://github.com/rage-rb/rage/wiki/Rails-integration)
+- [RSpec integration](https://github.com/rage-rb/rage/wiki/RSpec-integration)
 
 ### Example
 
@@ -150,8 +154,8 @@ Status | Changes
 :white_check_mark: | ~~Expose the `params` object.<br>Support header authentication with `authenticate_with_http_token`.<br>Router updates:<br>&emsp;• add the `resources` route helper;<br>&emsp;• add the `namespace` route helper;~~
 :white_check_mark:  | ~~Add request logging.~~
 :white_check_mark: | ~~Automatic code reloading in development with Zeitwerk.~~
+:white_check_mark: | ~~Support conditional get with `etag` and `last_modified`.~~
 ⏳ | Expose the `send_data` and `send_file` methods.
-⏳ | Support conditional get with `etag` and `last_modified`.
 ⏳ | Expose the `cookies` and `session` objects.
 ⏳ | Implement Iodine-based equivalent of Action Cable.
 

data/lib/rage/all.rb

@@ -18,6 +18,7 @@ require_relative "router/constrainer"
 require_relative "router/dsl"
 require_relative "router/handler_storage"
 require_relative "router/node"
+require_relative "router/util"
 
 require_relative "controller/api"
 

data/lib/rage/configuration.rb

@@ -19,7 +19,7 @@
 #
 # • _config.middleware.use_
 #
-# > Adds a middleware to the top of the middleware stack. **This is the preferred way of adding a middleware.**
+# > Adds a middleware to the top of the middleware stack. **This is the recommended way of adding a middleware.**
 # > ```
 # config.middleware.use Rack::Cors do
 #   allow do
@@ -166,7 +166,7 @@ class Rage::Configuration
 
   # @private
   class Internal
-    attr_accessor :rails_mode, :rails_console
+    attr_accessor :rails_mode
 
     def inspect
       "#<#{self.class.name}>"

data/lib/rage/fiber.rb

@@ -1,6 +1,46 @@
 # frozen_string_literal: true
 
+##
+# Rage provides a simple and efficient API to wait on several instances of IO at the same time - {Fiber.await}.
+# 
+# Let's say we have the following controller:
+# ```ruby
+# class UsersController < RageController::API
+#   def show
+#     user = Net::HTTP.get(URI("http://users.service/users/#{params[:id]}"))
+#     bookings = Net::HTTP.get(URI("http://bookings.service/bookings?user_id=#{params[:id]}"))
+#     render json: { user: user, bookings: bookings }
+#   end
+# end
+# ```
+# This code will fire two consecutive HTTP requests. If each request takes 1 second to execute, the total execution time will be 2 seconds.<br>
+# With {Fiber.await}, we can significantly decrease the overall execution time by changing the code to fire the requests concurrently.
+#
+# To do this, we will need to:
+#
+# 1. Wrap every request in a separate fiber using {Fiber.schedule};
+# 2. Pass newly created fibers into {Fiber.await};
+#
+# ```ruby
+# class UsersController < RageController::API
+#   def show
+#     user, bookings = Fiber.await([
+#       Fiber.schedule { Net::HTTP.get(URI("http://users.service/users/#{params[:id]}")) },
+#       Fiber.schedule { Net::HTTP.get(URI("http://bookings.service/bookings?user_id=#{params[:id]}")) }
+#     ])
+#
+#     render json: { user: user, bookings: bookings }
+#   end
+# end
+# ```
+# With this change, if each request takes 1 second to execute, the total execution time will still be 1 second.
+# 
+# ## Creating fibers
+# Many developers see fibers as "lightweight threads" that should be used in conjunction with fiber pools, the same way we use thread pools for threads.<br>
+# Instead, it makes sense to think of fibers as regular Ruby objects. We don't use a pool of arrays when we need to create an array - we create a new object and let Ruby and the GC do their job.<br>
+# Same applies to fibers. Feel free to create as many fibers as you need on demand.
 class Fiber
+  # @private
   AWAIT_ERROR_MESSAGE = "err"
 
   # @private
@@ -23,14 +63,14 @@ class Fiber
     @__err
   end
 
-   # @private
-  def __get_id
-    @__rage_id ||= object_id.to_s
+  # @private
+  def __set_id
+    @__rage_id = object_id.to_s
   end
 
-  # @private
-  def __yielded?
-    !@__rage_id.nil?
+   # @private
+  def __get_id
+    @__rage_id
   end
 
   # @private
@@ -49,8 +89,15 @@ class Fiber
     Fiber.yield
   end
 
+  # @private
+  # under normal circumstances, the method is a copy of `yield`, but it can be overriden to perform
+  # additional steps on yielding, e.g. releasing AR connections; see "lib/rage/rails.rb"
+  class << self
+    alias_method :defer, :yield
+  end
+
   # Wait on several fibers at the same time. Calling this method will automatically pause the current fiber, allowing the
-  #   server to process other requests. Once all fibers have completed, the current fiber will be automatically resumed.
+  # server to process other requests. Once all fibers have completed, the current fiber will be automatically resumed.
   #
   # @param fibers [Fiber, Array<Fiber>] one or several fibers to wait on. The fibers must be created using the `Fiber.schedule` call.
   # @example
@@ -101,4 +148,16 @@ class Fiber
       fibers.map!(&:__get_result)
     end
   end
+
+  # @!method self.schedule(&block)
+  #   Create a non-blocking fiber. Should mostly be used in conjunction with `Fiber.await`.
+  #   @example
+  #     Fiber.await([
+  #       Fiber.schedule { request_1 },
+  #       Fiber.schedule { request_2 }
+  #     ])
+  #   @example
+  #     fiber_1 = Fiber.schedule { request_1 }
+  #     fiber_2 = Fiber.schedule { request_2 }
+  #     Fiber.await([fiber_1, fiber_2])
 end

data/lib/rage/fiber_scheduler.rb

@@ -7,13 +7,14 @@ class Rage::FiberScheduler
 
   def initialize
     @root_fiber = Fiber.current
+    @dns_cache = {}
   end
 
   def io_wait(io, events, timeout = nil)
     f = Fiber.current
     ::Iodine::Scheduler.attach(io.fileno, events, timeout&.ceil || 0) { |err| f.resume(err) }
 
-    err = Fiber.yield
+    err = Fiber.defer
     if err == Errno::ETIMEDOUT::Errno
       0
     else
@@ -49,13 +50,15 @@ class Rage::FiberScheduler
     end
   end
 
-  def io_write(io, buffer, length, offset = 0)
-    bytes_to_write = length
-    bytes_to_write = buffer.size if length == 0
+  unless ENV["RAGE_DISABLE_IO_WRITE"]
+    def io_write(io, buffer, length, offset = 0)
+      bytes_to_write = length
+      bytes_to_write = buffer.size if length == 0
 
-    ::Iodine::Scheduler.write(io.fileno, buffer.get_string, bytes_to_write, offset)
+      ::Iodine::Scheduler.write(io.fileno, buffer.get_string, bytes_to_write, offset)
 
-    bytes_to_write - offset
+      bytes_to_write - offset
+    end
   end
 
   def kernel_sleep(duration = nil)
@@ -77,7 +80,13 @@ class Rage::FiberScheduler
   # end
 
   def address_resolve(hostname)
-    Resolv.getaddresses(hostname)
+    @dns_cache[hostname] ||= begin
+      ::Iodine.run_after(60_000) do
+        @dns_cache[hostname] = nil
+      end
+
+      Resolv.getaddresses(hostname)
+    end
   end
 
   def block(_blocker, timeout = nil)
@@ -100,7 +109,7 @@ class Rage::FiberScheduler
   end
 
   def unblock(_blocker, fiber)
-    ::Iodine.publish(fiber.__block_channel, "")
+    ::Iodine.publish(fiber.__block_channel, "", Iodine::PubSub::PROCESS)
   end
 
   def fiber(&block)
@@ -109,6 +118,7 @@ class Rage::FiberScheduler
     fiber = if parent == @root_fiber
       # the fiber to wrap a request in
       Fiber.new(blocking: false) do
+        Fiber.current.__set_id
         Fiber.current.__set_result(block.call)
       end
     else
@@ -119,10 +129,10 @@ class Rage::FiberScheduler
         Thread.current[:rage_logger] = logger
         Fiber.current.__set_result(block.call)
         # send a message for `Fiber.await` to work
-        Iodine.publish("await:#{parent.object_id}", "") if parent.alive?
+        Iodine.publish("await:#{parent.object_id}", "", Iodine::PubSub::PROCESS) if parent.alive?
       rescue Exception => e
         Fiber.current.__set_err(e)
-        Iodine.publish("await:#{parent.object_id}", Fiber::AWAIT_ERROR_MESSAGE) if parent.alive?
+        Iodine.publish("await:#{parent.object_id}", Fiber::AWAIT_ERROR_MESSAGE, Iodine::PubSub::PROCESS) if parent.alive?
       end
     end
 

data/lib/rage/logger/json_formatter.rb

@@ -7,7 +7,7 @@ class Rage::JSONFormatter
   end
 
   def call(severity, timestamp, _, message)
-    logger = Thread.current[:rage_logger]
+    logger = Thread.current[:rage_logger] || { tags: [], context: {} }
     tags, context = logger[:tags], logger[:context]
 
     if !context.empty?
@@ -17,8 +17,8 @@ class Rage::JSONFormatter
 
     if final = logger[:final]
       params, env = final[:params], final[:env]
-      if params
-        return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",\"controller\":\"#{params[:controller]}\",\"action\":\"#{params[:action]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"
+      if params && params[:controller]
+        return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",\"controller\":\"#{Rage::Router::Util.path_to_name(params[:controller])}\",\"action\":\"#{params[:action]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"
       else
         # no controller/action keys are written if there are no params
         return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"
@@ -29,6 +29,8 @@ class Rage::JSONFormatter
       tags_msg = "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
     elsif tags.length == 2
       tags_msg = "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+    elsif tags.length == 0
+      tags_msg = "{\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
     else
       tags_msg = "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\""
       i = 2

data/lib/rage/logger/logger.rb

@@ -33,6 +33,23 @@ require "logger"
 # Rage.logger.info("Initializing")
 # Rage.logger.debug { "This is a " + potentially + " expensive operation" }
 # ```
+#
+# ## Using the logger
+# The recommended approach to logging with Rage is to make sure your code always logs the same message no matter what the input is.
+# You can achieve this by using the {with_context} and {tagged} methods. So, a code like this:
+# ```ruby
+# def process_purchase(user_id:, product_id:)
+#   Rage.logger.info "processing purchase with user_id = #{user_id}; product_id = #{product_id}"
+# end
+# ```
+# turns into this:
+# ```ruby
+# def process_purchase(user_id:, product_id:)
+#   Rage.logger.with_context(user_id: user_id, product_id: product_id) do
+#     Rage.logger.info "processing purchase"
+#   end
+# end
+# ```
 class Rage::Logger
   METHODS_MAP = {
     "debug" => Logger::DEBUG,
@@ -83,7 +100,7 @@ class Rage::Logger
   #     Rage.logger.info "cache miss"
   #   end
   def with_context(context)
-    old_context = Thread.current[:rage_logger][:context]
+    old_context = (Thread.current[:rage_logger] ||= { tags: [], context: {} })[:context]
 
     if old_context.empty? # there's nothing in the context yet
       Thread.current[:rage_logger][:context] = context
@@ -92,8 +109,6 @@ class Rage::Logger
     end
 
     yield(self)
-    true
-
   ensure
     Thread.current[:rage_logger][:context] = old_context
   end
@@ -106,17 +121,20 @@ class Rage::Logger
   #     Rage.logger.info "success"
   #   end
   def tagged(tag)
-    Thread.current[:rage_logger][:tags] << tag
-
+    (Thread.current[:rage_logger] ||= { tags: [], context: {} })[:tags] << tag
     yield(self)
-    true
-
   ensure
     Thread.current[:rage_logger][:tags].pop
   end
 
   alias_method :with_tag, :tagged
 
+  def debug? = @level <= Logger::DEBUG
+  def error? = @level <= Logger::ERROR
+  def fatal? = @level <= Logger::FATAL
+  def info? = @level <= Logger::INFO
+  def warn? = @level <= Logger::WARN
+
   private
 
   def define_log_methods
@@ -128,13 +146,6 @@ class Rage::Logger
             false
           end
         RUBY
-      elsif (Rage.config.internal.rails_mode ? Rage.config.internal.rails_console : defined?(IRB))
-        # the call was made from the console - don't use the formatter
-        <<-RUBY
-          def #{level_name}(msg = nil)
-            @logdev.write((msg || yield) + "\n")
-          end
-        RUBY
       elsif @formatter.class.name.start_with?("Rage::")
         # the call was made from within the application and a built-in formatter is used;
         # in such case we use the `gen_timestamp` method which is much faster than `Time.now.strftime`;

data/lib/rage/logger/text_formatter.rb

@@ -7,7 +7,7 @@ class Rage::TextFormatter
   end
 
   def call(severity, timestamp, _, message)
-    logger = Thread.current[:rage_logger]
+    logger = Thread.current[:rage_logger] || { tags: [], context: {} }
     tags, context = logger[:tags], logger[:context]
 
     if !context.empty?
@@ -17,8 +17,8 @@ class Rage::TextFormatter
 
     if final = logger[:final]
       params, env = final[:params], final[:env]
-      if params
-        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{params[:controller]} action=#{params[:action]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
+      if params && params[:controller]
+        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{Rage::Router::Util.path_to_name(params[:controller])} action=#{params[:action]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
       else
         # no controller/action keys are written if there are no params
         return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
@@ -29,6 +29,8 @@ class Rage::TextFormatter
       tags_msg = "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
     elsif tags.length == 2
       tags_msg = "[#{tags[0]}][#{tags[1]}] timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
+    elsif tags.length == 0
+      tags_msg = "timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
     else
       tags_msg = "[#{tags[0]}][#{tags[1]}]"
       i = 2

data/lib/rage/middleware/fiber_wrapper.rb

@@ -17,7 +17,7 @@ class Rage::FiberWrapper
       @app.call(env)
     ensure
       # notify Iodine the request can now be resumed
-      Iodine.publish(Fiber.current.__get_id, "", Iodine::PubSub::PROCESS) if Fiber.current.__yielded?
+      Iodine.publish(Fiber.current.__get_id, "", Iodine::PubSub::PROCESS)
     end
 
     # the fiber encountered blocking IO and yielded; instruct Iodine to pause the request

data/lib/rage/rails.rb

@@ -11,12 +11,6 @@ Iodine.patch_rack
 # configure the framework
 Rage.config.internal.rails_mode = true
 
-# make sure log formatter is not used in console
-Rails.application.console do
-  Rage.config.internal.rails_console = true
-  Rage.logger.level = Rage.logger.level if Rage.logger # trigger redefining log methods
-end
-
 # patch ActiveRecord's connection pool
 if defined?(ActiveRecord)
   Rails.configuration.after_initialize do
@@ -30,6 +24,21 @@ if defined?(ActiveRecord)
   end
 end
 
+# release ActiveRecord connections on yield
+if defined?(ActiveRecord)
+  class Fiber
+    def self.defer
+      res = Fiber.yield
+
+      if ActiveRecord::Base.connection_pool.active_connection?
+        ActiveRecord::Base.connection_handler.clear_active_connections!
+      end
+
+      res
+    end
+  end
+end
+
 # plug into Rails' Zeitwerk instance to reload the code
 Rails.autoloaders.main.on_setup do
   if Iodine.running?

data/lib/rage/router/backend.rb

@@ -67,7 +67,7 @@ class Rage::Router::Backend
     if handler.is_a?(String)
       raise "Invalid route handler format, expected to match the 'controller#action' pattern" unless handler =~ STRING_HANDLER_REGEXP
 
-      controller, action = to_controller_class($1), $2
+      controller, action = Rage::Router::Util.path_to_class($1), $2
       run_action_method_name = controller.__register_action(action.to_sym)
 
       meta[:controller] = $1
@@ -273,22 +273,4 @@ class Rage::Router::Backend
       end
     end
   end
-
-  def to_controller_class(str)
-    str.capitalize!
-    str.gsub!(/([\/_])([a-zA-Z0-9]+)/) do
-      if $1 == "/"
-        "::#{$2.capitalize}"
-      else
-        $2.capitalize
-      end
-    end
-
-    klass = "#{str}Controller"
-    if Object.const_defined?(klass)
-      Object.const_get(klass)
-    else
-      raise Rage::Errors::RouterError, "Routing error: could not find the #{klass} class"
-    end
-  end
 end

data/lib/rage/router/handler_storage.rb

@@ -48,10 +48,11 @@ class Rage::Router::HandlerStorage
   private
 
   def compile_create_params_object(param_keys, defaults, meta)
-    lines = [
-      ":controller => '#{meta[:controller]}'.freeze",
-      ":action => '#{meta[:action]}'.freeze"
-    ]
+    lines = if meta[:controller]
+      [":controller => '#{meta[:controller]}'.freeze", ":action => '#{meta[:action]}'.freeze"]
+    else
+      []
+    end
 
     param_keys.each_with_index do |key, i|
       lines << ":#{key} => param_values[#{i}]"

data/lib/rage/router/util.rb

@@ -0,0 +1,33 @@
+class Rage::Router::Util
+  class << self
+    # converts controller name in a path form into a class
+    # `api/v1/users` => `Api::V1::UsersController`
+    def path_to_class(str)
+      str = str.capitalize
+      str.gsub!(/([\/_])([a-zA-Z0-9]+)/) do
+        if $1 == "/"
+          "::#{$2.capitalize}"
+        else
+          $2.capitalize
+        end
+      end
+
+      klass = "#{str}Controller"
+      if Object.const_defined?(klass)
+        Object.const_get(klass)
+      else
+        raise Rage::Errors::RouterError, "Routing error: could not find the #{klass} class"
+      end
+    end
+
+    @@names_map = {}
+
+    # converts controller name in a path form into a string representation of a class
+    # `api/v1/users` => `"Api::V1::UsersController"`
+    def path_to_name(str)
+      @@names_map[str] || begin
+        @@names_map[str] = path_to_class(str).name
+      end
+    end
+  end
+end

data/lib/rage/rspec.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "rack/test"
+require "json"
+
+# set up environment
+ENV["RAGE_ENV"] ||= ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "test"
+
+# load the app
+require "bundler/setup"
+require "rage"
+require_relative "#{Rage.root}/config/application"
+
+# verify the environment
+abort("The test suite is running in #{Rage.env} mode instead of 'test'!") unless Rage.env.test?
+
+# mock fiber methods as RSpec tests don't run concurrently
+class Fiber
+  def self.schedule(&block)
+    fiber = Fiber.new(blocking: true) do
+      Fiber.current.__set_id
+      Fiber.current.__set_result(block.call)
+    end
+    fiber.resume
+
+    fiber
+  end
+
+  def self.await(fibers)
+    Array(fibers).map(&:__get_result)
+  end
+end
+
+# define request helpers
+module RageRequestHelpers
+  include Rack::Test::Methods
+
+  alias_method :response, :last_response
+
+  APP = Rack::Builder.parse_file("#{Rage.root}/config.ru").yield_self do |app|
+    app.is_a?(Array) ? app[0] : app
+  end
+
+  def app
+    APP
+  end
+
+  %w(get options head).each do |method_name|
+    class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def #{method_name}(path, params: {}, headers: {})
+        request("#{method_name.upcase}", path, params: params, headers: headers)
+      end
+    RUBY
+  end
+
+  %w(post put patch delete).each do |method_name|
+    class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def #{method_name}(path, params: {}, headers: {}, as: nil)
+        if as == :json
+          params = params.to_json
+          headers["content-type"] = "application/json"
+        end
+
+        request("#{method_name.upcase}", path, params: params, headers: headers.merge("IODINE_HAS_BODY" => !params.empty?))
+      end
+    RUBY
+  end
+
+  def request(method, path, params: {}, headers: {})
+    if headers.any?
+      headers = headers.transform_keys do |k|
+        if k.downcase == "content-type"
+          "CONTENT_TYPE"
+        elsif k.downcase == "content-length"
+          "CONTENT_LENGTH"
+        elsif k.upcase == k
+          k
+        else
+          "HTTP_#{k.tr("-", "_").upcase! || k}"
+        end
+      end
+    end
+
+    custom_request(method, path, params, headers)
+  end
+
+  def host!(host)
+    @__host = host
+  end
+
+  def default_host
+    @__host || "example.org"
+  end
+end
+
+# include request helpers
+RSpec.configure do |config|
+  config.include(RageRequestHelpers, type: :request)
+end
+
+# patch MockResponse class
+class Rack::MockResponse
+  def parsed_body
+    if headers["content-type"].start_with?("application/json")
+      JSON.parse(body)
+    else
+      body
+    end
+  end
+
+  def code
+    status.to_s
+  end
+
+  alias_method :response_code, :status
+end
+
+# define http status matcher
+RSpec::Matchers.matcher :have_http_status do |expected|
+  codes = Rack::Utils::SYMBOL_TO_STATUS_CODE
+
+  failure_message do |response|
+    actual = response.status
+
+    if expected.is_a?(Integer)
+      "expected the response to have status code #{expected} but it was #{actual}"
+    elsif expected == :success
+      "expected the response to have a success status code (2xx) but it was #{actual}"
+    elsif expected == :error
+      "expected the response to have an error status code (5xx) but it was #{actual}"
+    elsif expected == :missing
+      "expected the response to have a missing status code (404) but it was #{actual}"
+    else
+      "expected the response to have status code :#{expected} (#{codes[expected]}) but it was :#{codes.key(actual)} (#{actual})"
+    end
+  end
+
+  failure_message_when_negated do |response|
+    actual = response.status
+
+    if expected.is_a?(Integer)
+      "expected the response not to have status code #{expected} but it was #{actual}"
+    elsif expected == :success
+      "expected the response not to have a success status code (2xx) but it was #{actual}"
+    elsif expected == :error
+      "expected the response not to have an error status code (5xx) but it was #{actual}"
+    elsif expected == :missing
+      "expected the response not to have a missing status code (404) but it was #{actual}"
+    else
+      "expected the response not to have status code :#{expected} (#{codes[expected]}) but it was :#{codes.key(actual)} (#{actual})"
+    end
+  end
+
+  match do |response|
+    actual = response.status
+
+    case expected
+    when :success
+      actual >= 200 && actual < 300
+    when :error
+      actual >= 500
+    when :missing
+      actual == 404
+    when Symbol
+      actual == codes.fetch(expected)
+    else
+      actual == expected
+    end
+  end
+end
+
+if defined? RSpec::Rails::Matchers
+  module RSpec::Rails::Matchers
+    def have_http_status(_)
+      super
+    end
+  end
+end

data/lib/rage/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rage
-  VERSION = "0.7.0"
+  VERSION = "1.1.0"
 end

data/rage.gemspec

@@ -31,4 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "rack", "~> 2.0"
   spec.add_dependency "rage-iodine", "~> 3.0"
   spec.add_dependency "zeitwerk", "~> 2.6"
+  spec.add_dependency "rack-test", "~> 2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Roman Samoilov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-01-09 00:00:00.000000000 Z
+date: 2024-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
 description:
 email:
 - rsamoi@icloud.com
@@ -112,6 +126,8 @@ files:
 - lib/rage/router/handler_storage.rb
 - lib/rage/router/node.rb
 - lib/rage/router/strategies/host.rb
+- lib/rage/router/util.rb
+- lib/rage/rspec.rb
 - lib/rage/setup.rb
 - lib/rage/sidekiq_session.rb
 - lib/rage/templates/Gemfile