bug_bunny 3.0.2 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42bf10dd1d3e749561b43b298e6dda00f9b6a76a40dce49103d1d094faa39948
-  data.tar.gz: 3088ecec60567a95972ed7abc7dff8f6dd9f5019ad6e0a19bb15dcae61e68bb3
+  metadata.gz: 6d012f3384230432e8f94c365d2a19ea05179f362f0433482c8d9967c3838102
+  data.tar.gz: ae306fdebe3c63b08a4980337294e46830a0277c9deea509a485d9978b2a9760
 SHA512:
-  metadata.gz: ccf976738d355512f3effec2d84a94087c62b41b329516df4cb15ca99034385da216592a7b52acec6aa224708b7c5c272f17dde349a8d5fe88f3903e33ff1122
-  data.tar.gz: 60252a5667d1178b4ac9de5118dd21cfd5538c12c9f69360988f493ffea50c81e4efec2cc08f50570fc9e76c9a57d9bb08c1ef6d75aef4a6b25f995fc765b512
+  metadata.gz: fdee3c4b42d2e852649985f962fe81ca0cf3b152357d484e3e37310bbacd07889c82408c92b3b99936c0f81d2cf60e22ca57bae24f54e30efb0a36040649382b
+  data.tar.gz: 4c47cde21b912b1cad5cda132af21cb7ea5fcb0a7cefd8827f572695fbe50d6945b6083738e81fa8cc3f40b03344314f28655586e7c298925b2bf9482034acaa

data/CHANGELOG.md

@@ -1,4 +1,10 @@
 # Changelog
+## [3.0.3] - 2026-02-13
+
+### 🐛 Bug Fixes
+* **Nested Query Serialization:** Fixed an issue where passing nested hashes to `Resource.where` (e.g., `where(q: { service: 'rabbit' })`) produced invalid URL strings (Ruby's `to_s` format) instead of standard HTTP query parameters.
+    * **Resource:** Now uses `Rack::Utils.build_nested_query` to generate correct URLs (e.g., `?q[service]=rabbit`).
+    * **Consumer:** Now uses `Rack::Utils.parse_nested_query` to correctly reconstruct nested hashes from the query string.
 
 ## [3.0.2] - 2026-02-12
 

data/bin_suite.rb

@@ -24,7 +24,7 @@ begin
   response = raw_client.request('test_user/ping', exchange: 'test_exchange', exchange_type: 'topic', routing_key: 'test_user.ping')
   assert(response['body']['message'] == 'Pong!', "Respuesta RPC recibida correctamente")
 rescue => e
-  assert(false, "Error RPC: #{e.message}")
+  assert(false, "Error RPC: #{e.class} - #{e.message}")
 end
 
 # ---------------------------------------------------------
@@ -36,17 +36,26 @@ puts "\n[2] Probando BugBunny::Resource (Estilo Rails)..."
 puts "    -> Buscando usuario ID 123..."
 user = TestUser.find(123)
 
-assert(user.is_a?(TestUser), "El objeto retornado es un TestUser")
-assert(user.name == "Gabriel", "El nombre cargó correctamente")
-assert(user.persisted?, "El objeto figura como persistido")
+if user
+  assert(user.is_a?(TestUser), "El objeto retornado es un TestUser")
+  assert(user.name == "Gabriel", "El nombre cargó correctamente")
+  assert(user.persisted?, "El objeto figura como persistido")
+else
+  assert(false, "No se encontró el usuario (Check worker logs)")
+end
+
 # ---------------------------------------------------------
 # TEST 3: Resource Create (ORM)
 # ---------------------------------------------------------
 puts "\n[3] Probando Resource Creation..."
 puts "    -> Creando usuario nuevo..."
 new_user = TestUser.create(name: "Nuevo User", email: "new@test.com")
-assert(new_user.persisted?, "El usuario se guardó y recibió ID")
-assert(new_user.id.present?, "Tiene ID asignado por el worker (#{new_user.id})")
+if new_user.persisted?
+  assert(new_user.persisted?, "El usuario se guardó y recibió ID")
+  assert(new_user.id.present?, "Tiene ID asignado por el worker (#{new_user.id})")
+else
+  assert(false, "Fallo al crear usuario: #{new_user.errors.full_messages}")
+end
 
 # ---------------------------------------------------------
 # TEST 4: Validaciones Locales
@@ -56,22 +65,42 @@ invalid_user = TestUser.new(email: "sin_nombre@test.com")
 assert(invalid_user.valid? == false, "Usuario sin nombre es inválido")
 assert(invalid_user.errors[:name].any?, "Tiene error en el campo :name")
 
-puts "\n🏁 SUITE FINALIZADA"
-
 # ---------------------------------------------------------
 # TEST 5: Probando Configuración Dinámica (.with)...
 # ---------------------------------------------------------
 puts "\n[5] Probando Configuración Dinámica (.with)..."
 
 # Probamos cambiar el routing key prefix temporalmente
-# El worker escucha 'test_user.*', así que si cambiamos a 'bad_prefix', debería fallar o no encontrar nada
 begin
-  # Forzamos una routing key que no existe para ver si respeta el cambio
+  # Forzamos una routing key que no existe
+  puts "    -> Intentando ruta incorrecta (esperando timeout)..."
   TestUser.with(routing_key: 'ruta.incorrecta').find(123)
-rescue BugBunny::RequestTimeout
-  puts "  ✅ PASS: El override funcionó (timeout esperado en ruta incorrecta)"
+  assert(false, "Debería haber fallado por timeout")
+rescue BugBunny::RequestTimeout, BugBunny::ClientError
+  # Nota: Dependiendo de tu config, puede dar Timeout o 501 si llega a un worker default
+  puts "  ✅ PASS: El override funcionó (timeout o error esperado en ruta incorrecta)"
 end
 
 # Probamos que vuelve a la normalidad
 user = TestUser.find(123)
 assert(user.present?, "  ✅ PASS: La configuración volvió a la normalidad")
+
+# ---------------------------------------------------------
+# TEST 6: Filtrado Complejo (Query String Nested - FIX Rack)
+# ---------------------------------------------------------
+puts "\n[6] Probando Resource.where con filtros anidados (Fix Rack)..."
+
+begin
+  # Esto fallaba antes (generaba string feo en la URL: {:active=>true})
+  # Al usar Rack, esto genera: ?q[active]=true&q[roles][]=admin
+  # No necesitamos que el worker responda algo real, solo que el request SALGA sin explotar URI.
+  TestUser.where(q: { active: true, roles: ['admin'] })
+  puts "  ✅ PASS: .where generó la query anidada correctamente sin errores de URI."
+rescue URI::InvalidURIError => e
+  assert(false, "❌ FAIL: URI Inválida (El fix de Rack no funcionó): #{e.message}")
+rescue => e
+  # Si falla por conexión o 404 está bien, lo importante es que no falle al serializar
+  puts "  ✅ PASS: El request se envió correctamente (aunque el worker responda: #{e.class}). Serialización OK."
+end
+
+puts "\n🏁 SUITE FINALIZADA"

data/lib/bug_bunny/consumer.rb

@@ -4,41 +4,58 @@ require 'concurrent'
 require 'json'
 require 'uri'
 require 'cgi'
+require 'rack/utils' # Necesario para parse_nested_query
 
 module BugBunny
-  # Consumidor de mensajes y Router RPC estilo REST.
+  # Consumidor de mensajes AMQP que actúa como un Router RESTful.
   #
-  # Esta clase se encarga de escuchar una cola específica, deserializar los mensajes,
-  # interpretar los headers REST (`x-http-method`, `type`) y despacharlos al
-  # controlador correspondiente.
+  # Esta clase es el corazón del procesamiento de mensajes en el lado del servidor/worker.
+  # Sus responsabilidades son:
+  # 1. Escuchar una cola específica.
+  # 2. Deserializar el mensaje y sus headers.
+  # 3. Enrutar el mensaje a un Controlador (`BugBunny::Controller`) basándose en el "path" y el verbo HTTP.
+  # 4. Gestionar el ciclo de respuesta RPC (Request-Response) para evitar timeouts en el cliente.
   #
-  # También gestiona el ciclo de vida de la respuesta RPC, asegurando que siempre
-  # se envíe una contestación (éxito o error) para evitar timeouts en el cliente.
+  # @example Suscripción manual
+  #   connection = BugBunny.create_connection
+  #   BugBunny::Consumer.subscribe(
+  #     connection: connection,
+  #     queue_name: 'my_app_queue',
+  #     exchange_name: 'my_exchange',
+  #     routing_key: 'users.#'
+  #   )
   class Consumer
-    # @return [BugBunny::Session] La sesión de RabbitMQ wrapper.
+    # @return [BugBunny::Session] La sesión wrapper de RabbitMQ que gestiona el canal.
     attr_reader :session
 
     # Método de conveniencia para instanciar y suscribir en un solo paso.
-    # @param connection [Bunny::Session] Conexión activa.
-    # @param args [Hash] Argumentos para {#subscribe}.
+    #
+    # @param connection [Bunny::Session] Una conexión TCP activa a RabbitMQ.
+    # @param args [Hash] Argumentos que se pasarán al método {#subscribe}.
+    # @return [BugBunny::Consumer] La instancia del consumidor creada.
     def self.subscribe(connection:, **args)
       new(connection).subscribe(**args)
     end
 
-    # Inicializa el consumidor.
+    # Inicializa un nuevo consumidor.
+    #
     # @param connection [Bunny::Session] Conexión nativa de Bunny.
     def initialize(connection)
       @session = BugBunny::Session.new(connection)
     end
 
-    # Inicia la suscripción a la cola y el procesamiento de mensajes.
+    # Inicia la suscripción a la cola y comienza el bucle de procesamiento.
+    #
+    # Declara el exchange y la cola (si no existen), realiza el "binding" y
+    # se queda escuchando mensajes entrantes.
     #
     # @param queue_name [String] Nombre de la cola a escuchar.
-    # @param exchange_name [String] Exchange al que se bindeará la cola.
-    # @param routing_key [String] Routing key para el binding.
-    # @param exchange_type [String] Tipo de exchange ('direct', 'topic', etc).
-    # @param queue_opts [Hash] Opciones de declaración de la cola (durable, auto_delete).
-    # @param block [Boolean] Si es true, bloquea el hilo principal (loop).
+    # @param exchange_name [String] Nombre del exchange al cual enlazar la cola.
+    # @param routing_key [String] Patrón de enrutamiento (ej: 'users.*').
+    # @param exchange_type [String] Tipo de exchange ('direct', 'topic', 'fanout').
+    # @param queue_opts [Hash] Opciones adicionales para la cola (durable, auto_delete).
+    # @param block [Boolean] Si es `true`, bloquea el hilo actual (loop infinito).
+    # @return [void]
     def subscribe(queue_name:, exchange_name:, routing_key:, exchange_type: 'direct', queue_opts: {}, block: true)
       x = session.exchange(name: exchange_name, type: exchange_type)
       q = session.queue(queue_name, queue_opts)
@@ -58,26 +75,25 @@ module BugBunny
 
     private
 
-    # Procesa un mensaje individual.
+    # Procesa un mensaje individual recibido de la cola.
     #
-    # 1. Parsea headers y body.
-    # 2. Enruta al controlador/acción.
-    # 3. Envía la respuesta RPC si es necesario.
-    # 4. Maneja excepciones y envía errores formateados al cliente.
+    # Realiza la orquestación completa: Parsing -> Routing -> Ejecución -> Respuesta.
     #
-    # @param delivery_info [Bunny::DeliveryInfo] Metadatos de entrega.
-    # @param properties [Bunny::MessageProperties] Headers y propiedades AMQP.
-    # @param body [String] Payload del mensaje.
+    # @param delivery_info [Bunny::DeliveryInfo] Metadatos de entrega (tag, redelivered, etc).
+    # @param properties [Bunny::MessageProperties] Headers y propiedades AMQP (reply_to, correlation_id).
+    # @param body [String] El payload crudo del mensaje.
+    # @return [void]
     def process_message(delivery_info, properties, body)
       if properties.type.nil? || properties.type.empty?
-        BugBunny.configuration.logger.error("[Consumer] Missing 'type'. Rejected.")
+        BugBunny.configuration.logger.error("[Consumer] Missing 'type' header. Message rejected.")
         session.channel.reject(delivery_info.delivery_tag, false)
         return
       end
 
+      # 1. Determinar Verbo HTTP (Default: GET)
       http_method = properties.headers ? (properties.headers['x-http-method'] || 'GET') : 'GET'
 
-      # Inferencia de rutas (Router)
+      # 2. Router: Inferencia de Controlador y Acción
       route_info = router_dispatch(http_method, properties.type)
 
       headers = {
@@ -92,55 +108,57 @@ module BugBunny
         reply_to: properties.reply_to
       }
 
-      # Instanciación dinámica del controlador
+      # 3. Instanciación Dinámica del Controlador
       # Ej: "users" -> Rabbit::Controllers::UsersController
       controller_class_name = "rabbit/controllers/#{route_info[:controller]}".camelize
       controller_class = controller_class_name.constantize
 
-      # Ejecución del pipeline del controlador
+      # 4. Ejecución del Pipeline (Filtros -> Acción)
       response_payload = controller_class.call(headers: headers, body: body)
 
-      # Respuesta RPC (Éxito)
+      # 5. Respuesta RPC (Si se solicita respuesta)
       if properties.reply_to
         reply(response_payload, properties.reply_to, properties.correlation_id)
       end
 
+      # 6. Acknowledge (Confirmación de procesado)
       session.channel.ack(delivery_info.delivery_tag)
 
     rescue NameError => e
-      # Caso: Controlador o Acción no existen (404/501)
+      # Error 501/404: El controlador o la acción no existen.
       BugBunny.configuration.logger.error("[Consumer] Routing Error: #{e.message}")
-
-      # FIX CRÍTICO: Responder con error para evitar Timeout en el cliente
-      if properties.reply_to
-        error_payload = { status: 501, body: { error: "Routing Error", detail: e.message } }
-        reply(error_payload, properties.reply_to, properties.correlation_id)
-      end
-
+      handle_fatal_error(properties, 501, "Routing Error", e.message)
       session.channel.reject(delivery_info.delivery_tag, false)
 
     rescue StandardError => e
-      # Caso: Crash interno de la aplicación (500)
+      # Error 500: Crash interno de la aplicación.
       BugBunny.configuration.logger.error("[Consumer] Execution Error: #{e.message}")
-
-      # FIX CRÍTICO: Responder con 500 para evitar Timeout
-      if properties.reply_to
-        error_payload = { status: 500, body: { error: "Internal Server Error", detail: e.message } }
-        reply(error_payload, properties.reply_to, properties.correlation_id)
-      end
-
+      handle_fatal_error(properties, 500, "Internal Server Error", e.message)
       session.channel.reject(delivery_info.delivery_tag, false)
     end
 
-    # Simula el Router de Rails.
-    # Convierte Verbo + Path en Controlador + Acción + ID.
+    # Interpreta la URL y el verbo para decidir qué controlador ejecutar.
     #
-    # @return [Hash] { controller, action, id, params }
+    # Utiliza `Rack::Utils.parse_nested_query` para soportar parámetros anidados
+    # como `q[service]=rabbit`.
+    #
+    # @param method [String] Verbo HTTP (GET, POST, etc).
+    # @param path [String] URL virtual del recurso (ej: 'users/1?active=true').
+    # @return [Hash] Estructura con keys {:controller, :action, :id, :params}.
     def router_dispatch(method, path)
+      # Usamos URI para separar path de query string
       uri = URI.parse("http://dummy/#{path}")
       segments = uri.path.split('/').reject(&:empty?)
-      query_params = uri.query ? CGI.parse(uri.query).transform_values(&:first) : {}
 
+      # --- FIX: Uso de Rack para soportar params anidados ---
+      query_params = uri.query ? Rack::Utils.parse_nested_query(uri.query) : {}
+
+      # Si estamos en Rails, convertimos a HashWithIndifferentAccess para comodidad
+      if defined?(ActiveSupport::HashWithIndifferentAccess)
+        query_params = query_params.with_indifferent_access
+      end
+
+      # Lógica de Ruteo Convencional
       controller_name = segments[0]
       id = segments[1]
 
@@ -152,18 +170,24 @@ module BugBunny
                else id || 'index'
                end
 
-      # Soporte para Custom Member Actions (POST users/1/promote)
+      # Soporte para rutas miembro custom (POST users/1/promote)
       if segments.size >= 3
          id = segments[1]
          action = segments[2]
       end
 
+      # Inyectamos el ID en los params si existe en la ruta
       query_params['id'] = id if id
 
       { controller: controller_name, action: action, id: id, params: query_params }
     end
 
-    # Envía la respuesta a la cola temporal del cliente (Direct Reply-to).
+    # Envía una respuesta al cliente RPC utilizando Direct Reply-to.
+    #
+    # @param payload [Hash] Cuerpo de la respuesta ({ status: ..., body: ... }).
+    # @param reply_to [String] Cola de respuesta (generalmente pseudo-cola amq.rabbitmq.reply-to).
+    # @param correlation_id [String] ID para correlacionar la respuesta con la petición original.
+    # @return [void]
     def reply(payload, reply_to, correlation_id)
       session.channel.default_exchange.publish(
         payload.to_json,
@@ -173,11 +197,29 @@ module BugBunny
       )
     end
 
-    # Tarea de fondo para asegurar que la cola sigue existiendo.
+    # Maneja errores fatales asegurando que el cliente reciba una respuesta.
+    # Evita que el cliente RPC se quede esperando hasta el timeout.
+    #
+    # @api private
+    def handle_fatal_error(properties, status, error_title, detail)
+      return unless properties.reply_to
+
+      error_payload = {
+        status: status,
+        body: { error: error_title, detail: detail }
+      }
+      reply(error_payload, properties.reply_to, properties.correlation_id)
+    end
+
+    # Tarea de fondo (Heartbeat lógico) para verificar la salud del canal.
+    # Si la cola desaparece o la conexión se cierra, fuerza una reconexión.
+    #
+    # @param q_name [String] Nombre de la cola a monitorear.
     def start_health_check(q_name)
-      Concurrent::TimerTask.new(execution_interval: 60) do
+      Concurrent::TimerTask.new(execution_interval: BugBunny.configuration.health_check_interval) do
         session.channel.queue_declare(q_name, passive: true)
       rescue StandardError
+        BugBunny.configuration.logger.warn("[Consumer] Queue check failed. Reconnecting session...")
         session.close
       end.execute
     end

data/lib/bug_bunny/resource.rb

@@ -2,6 +2,7 @@
 require 'active_model'
 require 'active_support/core_ext/string/inflections'
 require 'uri'
+require 'rack/utils'
 
 module BugBunny
   # Clase base para modelos remotos que implementan **Active Record over AMQP (RESTful)**.
@@ -17,7 +18,7 @@ module BugBunny
   #     self.exchange = 'app.topic'
   #     self.resource_name = 'users'
   #     # Opcional: Personalizar la clave raíz del JSON
-  #     self.param_key = 'user_data' 
+  #     self.param_key = 'user_data'
   #   end
   #
   # @example Uso con contexto temporal
@@ -34,16 +35,16 @@ module BugBunny
 
     # @return [HashWithIndifferentAccess] Contenedor de los atributos remotos (JSON crudo).
     attr_reader :remote_attributes
-    
+
     # @return [Boolean] Indica si el objeto ha sido guardado en el servicio remoto.
     attr_accessor :persisted
 
     # @return [String, nil] Routing Key capturada en el momento de la instanciación.
     attr_accessor :routing_key
-    
+
     # @return [String, nil] Exchange capturado en el momento de la instanciación.
     attr_accessor :exchange
-    
+
     # @return [String, nil] Tipo de Exchange capturado en el momento de la instanciación.
     attr_accessor :exchange_type
 
@@ -76,21 +77,21 @@ module BugBunny
 
       # @return [ConnectionPool] El pool de conexiones asignado.
       def connection_pool; resolve_config(:pool, :@connection_pool); end
-      
+
       # @return [String] El exchange configurado.
       # @raise [ArgumentError] Si no se ha definido un exchange.
       def current_exchange; resolve_config(:exchange, :@exchange) || raise(ArgumentError, "Exchange not defined"); end
-      
+
       # @return [String] El tipo de exchange (default: direct).
       def current_exchange_type; resolve_config(:exchange_type, :@exchange_type) || 'direct'; end
-      
+
       # @return [String] El nombre del recurso (ej: 'users'). Se infiere del nombre de la clase si no existe.
       def resource_name
         resolve_config(:resource_name, :@resource_name) || name.demodulize.underscore.pluralize
       end
 
       # Define la clave raíz para envolver el payload JSON (Wrapping).
-      # 
+      #
       # Por defecto utiliza `model_name.element`, lo que elimina los namespaces.
       # Ej: `Manager::Service` -> `'service'`.
       #
@@ -122,7 +123,7 @@ module BugBunny
       def bug_bunny_client
         pool = connection_pool
         raise BugBunny::Error, "Connection pool missing for #{name}" unless pool
-        
+
         BugBunny::Client.new(pool: pool) do |conn|
           resolve_middleware_stack.each { |block| block.call(conn) }
         end
@@ -137,7 +138,7 @@ module BugBunny
         keys = { exchange: "bb_#{object_id}_exchange", exchange_type: "bb_#{object_id}_exchange_type", pool: "bb_#{object_id}_pool", routing_key: "bb_#{object_id}_routing_key" }
         old_values = {}
         keys.each { |k, v| old_values[k] = Thread.current[v] }
-        
+
         # Seteamos valores temporales
         Thread.current[keys[:exchange]] = exchange if exchange
         Thread.current[keys[:exchange_type]] = exchange_type if exchange_type
@@ -150,7 +151,7 @@ module BugBunny
           ScopeProxy.new(self, keys, old_values)
         end
       end
-      
+
       # Proxy para permitir encadenamiento: User.with(...).find(1)
       class ScopeProxy < BasicObject
         def initialize(target, keys, old_values); @target = target; @keys = keys; @old_values = old_values; end
@@ -179,13 +180,14 @@ module BugBunny
       def where(filters = {})
         rk = calculate_routing_key
         path = resource_name
-        path += "?#{URI.encode_www_form(filters)}" if filters.present?
+
+        # Usamos Rack para serializar anidamiento (q[service]=val)
+        path += "?#{Rack::Utils.build_nested_query(filters)}" if filters.present?
 
         response = bug_bunny_client.request(path, method: :get, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk)
 
         return [] unless response['body'].is_a?(Array)
         response['body'].map do |attrs|
-          # Al instanciar aquí, se captura el contexto si estamos dentro de un .with
           inst = new(attrs)
           inst.persisted = true
           inst.send(:clear_changes_information)
@@ -204,7 +206,7 @@ module BugBunny
         response = bug_bunny_client.request(path, method: :get, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk)
 
         return nil if response.nil? || response['status'] == 404
-        
+
         attributes = response['body']
         return nil unless attributes.is_a?(Hash)
 
@@ -235,12 +237,12 @@ module BugBunny
     def initialize(attributes = {})
       @remote_attributes = {}.with_indifferent_access
       @persisted = false
-      
+
       # === CAPTURA DE CONTEXTO ===
       @routing_key = self.class.thread_config(:routing_key)
       @exchange = self.class.thread_config(:exchange)
       @exchange_type = self.class.thread_config(:exchange_type)
-      
+
       assign_attributes(attributes)
       super()
     end
@@ -269,7 +271,7 @@ module BugBunny
       return if new_attributes.nil?
       new_attributes.each { |k, v| public_send("#{k}=", v) }
     end
-    
+
     def update(attributes)
       assign_attributes(attributes)
       save
@@ -325,10 +327,10 @@ module BugBunny
       run_callbacks(:save) do
         is_new = !persisted?
         rk = calculate_routing_key(id)
-        
+
         # 1. Obtenemos el payload plano (atributos modificados)
         flat_payload = changes_to_send
-        
+
         # 2. Wrappeamos automáticamente en la clave del modelo
         key = self.class.param_key
         wrapped_payload = { key => flat_payload }

data/lib/bug_bunny/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BugBunny
-  VERSION = "3.0.2"
+  VERSION = "3.0.3"
 end

data/test_resource.rb

@@ -1,22 +1,19 @@
 require_relative 'test_helper'
 
 class TestUser < BugBunny::Resource
-  # Se decide qué pool usar en cada petición
-  self.connection_pool = -> {
-    nil || TEST_POOL
-  }
-
-  # El exchange cambia según el entorno
-  self.exchange = -> {
-    ENV['IS_STAGING'] ? 'test_exchange' : 'test_exchange'
-  }
+  # Configuración del Pool
+  self.connection_pool = -> { nil || TEST_POOL }
 
+  # Configuración del Exchange
+  self.exchange = -> { ENV['IS_STAGING'] ? 'test_exchange' : 'test_exchange' }
   self.exchange_type = 'topic'
-  self.routing_key_prefix = 'test_user'
 
-  attribute :id, :integer
-  attribute :name, :string
-  attribute :email, :string
+  # ACTUALIZADO v3.0: Usamos resource_name
+  self.resource_name = 'test_users'
+
+  # ELIMINADO: attribute :id, :integer (Causa crash en v3)
+  # ELIMINADO: attribute :name, :string (Causa crash en v3)
 
+  # Las validaciones siguen funcionando igual
   validates :name, presence: true
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.0.3
 platform: ruby
 authors:
 - gabix
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-12 00:00:00.000000000 Z
+date: 2026-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny