bug_bunny 3.1.0 → 3.1.2

data/lib/bug_bunny/session.rb

@@ -1,18 +1,23 @@
-# lib/bug_bunny/session.rb
+# frozen_string_literal: true
 
 module BugBunny
   # Clase interna que encapsula una unidad de trabajo sobre una conexión RabbitMQ.
   #
-  # Gestiona el ciclo de vida de un `Bunny::Channel` implementando:
-  # 1. Carga Perezosa (Lazy Loading): El canal solo se abre al usarse.
-  # 2. Resiliencia: Intenta recuperar la conexión TCP si está cerrada.
+  # Implementa la lógica de "Configuración en Cascada" para Exchanges y Colas,
+  # gestionando el ciclo de vida de un `Bunny::Channel` con resiliencia y carga perezosa.
   #
   # @api private
   class Session
-    # Opciones por defecto (Mantenemos las que tenías en tu repo)
+    # @!group Opciones por Defecto (Nivel 1: Gema)
+
+    # Opciones predeterminadas de la gema para Exchanges.
     DEFAULT_EXCHANGE_OPTIONS = { durable: false, auto_delete: false }.freeze
+
+    # Opciones predeterminadas de la gema para Colas.
     DEFAULT_QUEUE_OPTIONS = { exclusive: false, durable: false, auto_delete: true }.freeze
 
+    # @!endgroup
+
     # @return [Bunny::Session] La conexión TCP subyacente.
     attr_reader :connection
 
@@ -42,30 +47,50 @@ module BugBunny
       @channel
     end
 
-    # Factory method para declarar o recuperar un Exchange.
-    # Usa el método robusto `channel` internamente.
+    # Factory method para declarar o recuperar un Exchange aplicando la cascada de configuración.
+    #
+    # Jerarquía de fusión:
+    # 1. Defaults de la gema (`DEFAULT_EXCHANGE_OPTIONS`)
+    # 2. Configuración global (`BugBunny.configuration.exchange_options`)
+    # 3. Opciones específicas pasadas como argumento (`opts`)
     #
     # @param name [String, nil] Nombre del exchange.
-    # @param type [String, Symbol] Tipo de exchange.
-    # @param opts [Hash] Opciones adicionales.
+    # @param type [String, Symbol] Tipo de exchange ('direct', 'topic', 'fanout').
+    # @param opts [Hash] Opciones específicas de infraestructura para este intercambio.
+    # @return [Bunny::Exchange] El objeto exchange de Bunny configurado.
     def exchange(name: nil, type: 'direct', opts: {})
       return channel.default_exchange if name.nil? || name.empty?
 
-      merged_opts = DEFAULT_EXCHANGE_OPTIONS.merge(opts)
-      # public_send permite llamar a :topic, :direct, etc. dinámicamente
+      # Aplicación de la lógica de fusión en cascada
+      merged_opts = DEFAULT_EXCHANGE_OPTIONS
+                    .merge(BugBunny.configuration.exchange_options || {})
+                    .merge(opts)
+
+      # public_send permite llamar a :topic, :direct, etc. dinámicamente según el tipo
       channel.public_send(type, name, merged_opts)
     end
 
-    # Factory method para declarar o recuperar una Cola.
-    # Usa el método robusto `channel` internamente.
+    # Factory method para declarar o recuperar una Cola aplicando la cascada de configuración.
+    #
+    # Jerarquía de fusión:
+    # 1. Defaults de la gema (`DEFAULT_QUEUE_OPTIONS`)
+    # 2. Configuración global (`BugBunny.configuration.queue_options`)
+    # 3. Opciones específicas pasadas como argumento (`opts`)
     #
     # @param name [String] Nombre de la cola.
-    # @param opts [Hash] Opciones adicionales.
+    # @param opts [Hash] Opciones específicas de infraestructura para esta cola.
+    # @return [Bunny::Queue] El objeto cola de Bunny configurado.
     def queue(name, opts = {})
-      channel.queue(name.to_s, DEFAULT_QUEUE_OPTIONS.merge(opts))
+      # Aplicación de la lógica de fusión en cascada
+      merged_opts = DEFAULT_QUEUE_OPTIONS
+                    .merge(BugBunny.configuration.queue_options || {})
+                    .merge(opts)
+
+      channel.queue(name.to_s, merged_opts)
     end
 
     # Cierra el canal asociado a esta sesión de forma segura.
+    # @return [void]
     def close
       @channel&.close if @channel&.open?
       @channel = nil
@@ -73,8 +98,10 @@ module BugBunny
 
     private
 
-    # Crea y configura un nuevo canal.
+    # Crea y configura un nuevo canal con las preferencias globales.
     # Asume que la conexión ya ha sido verificada por `ensure_connection!`.
+    #
+    # @raise [BugBunny::CommunicationError] Si falla la creación del canal.
     def create_channel!
       @channel = @connection.create_channel
 
@@ -90,13 +117,15 @@ module BugBunny
 
     # Garantiza que la conexión TCP esté abierta.
     # Si está cerrada, intenta reconectarla (Reconexión Transparente).
+    #
+    # @raise [BugBunny::CommunicationError] Si falla la reconexión.
     def ensure_connection!
       return if @connection.open?
 
-      BugBunny.configuration.logger.warn("[BugBunny] Connection lost. Attempting to reconnect...")
+      BugBunny.configuration.logger.warn("[BugBunny::Session] ⚠️  Connection lost. Attempting to reconnect...")
       @connection.start
     rescue StandardError => e
-      BugBunny.configuration.logger.error("[BugBunny] Critical connection failure: #{e.message}")
+      BugBunny.configuration.logger.error("[BugBunny::Session] ❌ Critical connection failure: #{e.message}")
       raise BugBunny::CommunicationError, "Could not reconnect to RabbitMQ: #{e.message}"
     end
   end

data/lib/bug_bunny/version.rb

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

data/lib/bug_bunny.rb

@@ -75,7 +75,7 @@ module BugBunny
 
     @global_connection.close if @global_connection.open?
     @global_connection = nil
-    configuration.logger.info('[BugBunny] Global connection closed.')
+    configuration.logger.info('[BugBunny] 🔌 Global connection closed.')
   end
 
   # @api private

data/test/integration/infrastructure_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+
+# --- CLASES DE PRUEBA (Namespace Aislado) ---
+module InfraTest
+  class PingController < BugBunny::Controller
+    # Agregamos SHOW para soportar el .find del test
+    def show
+      render status: 200, json: { id: params[:id], message: 'pong', namespace: 'InfraTest' }
+    end
+
+    def index
+      render status: 200, json: { message: 'pong_index', namespace: 'InfraTest' }
+    end
+  end
+end
+
+class InfraResource < BugBunny::Resource
+  self.resource_name = 'ping'
+  self.exchange = 'test_infra_exchange'
+  self.exchange_type = 'topic'
+end
+
+# --- SUITE DE INFRAESTRUCTURA ---
+class InfrastructureTest < Minitest::Test
+  include IntegrationHelper
+
+  def setup
+    skip "RabbitMQ no disponible" unless IntegrationHelper.rabbitmq_available?
+    @queue = "test_infra_queue_#{SecureRandom.hex(4)}"
+    @exchange = "test_infra_exchange"
+  end
+
+  def test_00_worker_lifecycle
+    with_running_worker(queue: @queue, exchange: @exchange) do
+      assert true, "El worker levantó y cedió el control al bloque"
+    end
+  end
+
+  def test_01_dynamic_namespace_resolution
+    BugBunny.configure do |c|
+      c.controller_namespace = 'InfraTest'
+    end
+
+    with_running_worker(queue: @queue, exchange: @exchange) do
+      # Enviamos GET ping/123 -> InfraTest::PingController#show
+      resource = InfraResource.find('123')
+
+      # Verificamos que volvió el objeto construido
+      assert_equal '123', resource.id
+      assert_equal 'InfraTest', resource.namespace
+      assert_equal 'pong', resource.message
+    end
+
+  ensure
+    BugBunny.configure do |c|
+      c.controller_namespace = 'Rabbit::Controllers'
+    end
+  end
+end

data/test/integration/manual_client_test.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'timeout'
+
+module ManualTest
+  class EchoController < BugBunny::Controller
+    def index
+      render status: 200, json: { 
+        received: params[:message],
+        type: headers[:type],
+        via: 'ManualTest::EchoController'
+      }
+    end
+  end
+end
+
+class ManualClientTest < Minitest::Test
+  include IntegrationHelper
+
+  def setup
+    skip "RabbitMQ no disponible" unless IntegrationHelper.rabbitmq_available?
+    
+    # 1. NOMBRES ÚNICOS: Evitamos colisiones entre tests de diferentes tipos (Direct/Fanout)
+    @queue = "test_manual_q_#{SecureRandom.hex(4)}"
+    @exchange = "test_manual_x_#{SecureRandom.hex(4)}"
+    
+    @client = BugBunny::Client.new(pool: TEST_POOL)
+    BugBunny.configure { |c| c.controller_namespace = 'ManualTest' }
+  end
+
+  def teardown
+    BugBunny.configure { |c| c.controller_namespace = 'Rabbit::Controllers' }
+  end
+
+  # ==========================================
+  # GRUPO 1: PUBLICACIÓN ASÍNCRONA (PUBLISH)
+  # ==========================================
+
+  def test_publish_topic
+    puts "\n  -> [Manual] Publish (Topic)..."
+    with_spy_worker(queue: @queue, exchange: @exchange, exchange_type: 'topic', routing_key: 'logs.#') do |messages|
+      
+      @client.publish('logs.error', exchange: @exchange, exchange_type: 'topic', body: { a: 1 })
+      
+      msg = wait_for_message(messages)
+      assert_equal 'logs.error', msg[:routing_key]
+    end
+  end
+
+  def test_publish_direct
+    puts "  -> [Manual] Publish (Direct)..."
+    with_spy_worker(queue: @queue, exchange: @exchange, exchange_type: 'direct', routing_key: 'alert') do |messages|
+      
+      @client.publish('alert', exchange: @exchange, exchange_type: 'direct', body: { a: 1 })
+      
+      msg = wait_for_message(messages)
+      assert_equal 'alert', msg[:routing_key]
+    end
+  end
+
+  def test_publish_fanout
+    puts "  -> [Manual] Publish (Fanout)..."
+    with_spy_worker(queue: @queue, exchange: @exchange, exchange_type: 'fanout', routing_key: '') do |messages|
+      
+      @client.publish('ignored.key', exchange: @exchange, exchange_type: 'fanout', body: { a: 1 })
+      
+      msg = wait_for_message(messages)
+      assert_equal 'ignored.key', msg[:routing_key]
+    end
+  end
+
+  # ==========================================
+  # GRUPO 2: RPC SÍNCRONO (REQUEST)
+  # ==========================================
+
+  def test_request_topic
+    puts "  -> [Manual] RPC (Topic)..."
+    with_running_worker(queue: @queue, exchange: @exchange, exchange_type: 'topic', routing_key: 'echo') do
+      
+      response = @client.request('echo', 
+        method: :get, exchange: @exchange, exchange_type: 'topic', 
+        body: { message: 'topic_rpc' }
+      )
+      assert_equal 'topic_rpc', response['body']['received']
+    end
+  end
+
+  def test_request_direct
+    puts "  -> [Manual] RPC (Direct)..."
+    direct_key = 'rpc.direct'
+    
+    with_running_worker(queue: @queue, exchange: @exchange, exchange_type: 'direct', routing_key: direct_key) do
+      
+      response = @client.request('echo',
+        method: :get,
+        routing_key: direct_key, 
+        exchange: @exchange, 
+        exchange_type: 'direct', 
+        body: { message: 'direct_rpc' }
+      )
+
+      assert_equal 200, response['status']
+      assert_equal 'direct_rpc', response['body']['received']
+    end
+  end
+
+  def test_request_fanout
+    puts "  -> [Manual] RPC (Fanout)..."
+    with_running_worker(queue: @queue, exchange: @exchange, exchange_type: 'fanout', routing_key: '') do
+      
+      response = @client.request('echo', 
+        method: :get,
+        routing_key: 'random.ignored', 
+        exchange: @exchange, 
+        exchange_type: 'fanout', 
+        body: { message: 'fanout_rpc' }
+      )
+
+      assert_equal 200, response['status']
+      assert_equal 'fanout_rpc', response['body']['received']
+    end
+  end
+
+  # ==========================================
+  # GRUPO 3: OPCIONES DE INFRAESTRUCTURA (CASCADA NIVEL 3)
+  # ==========================================
+
+  def test_publish_with_custom_exchange_options
+    puts "  -> [Manual] Publish (Custom Options Nivel 3)..."
+    custom_exchange = "custom_opts_x_#{SecureRandom.hex(4)}"
+    
+    # 1. Pre-creamos el exchange exigiendo que sea DURABLE (contrario a la config global)
+    conn = BugBunny.create_connection
+    ch = conn.create_channel
+    ch.topic(custom_exchange, durable: true, auto_delete: true)
+
+    begin
+      # 2. El cliente publica inyectando opciones dinámicas.
+      # Si esto no funcionara, RabbitMQ nos tiraría PRECONDITION_FAILED 
+      # porque la configuración global (Nivel 2) dice durable: false.
+      @client.publish('logs', 
+        exchange: custom_exchange, 
+        exchange_type: 'topic', 
+        exchange_options: { durable: true, auto_delete: true }, # Nivel 3 sobrescribe Nivel 2
+        body: { test: 'options' }
+      )
+      
+      # Si la ejecución llega aquí, significa que la Cascada funcionó perfecto.
+      assert true 
+    ensure
+      ch&.exchange_delete(custom_exchange) rescue nil
+      conn&.close
+    end
+  end
+
+  def test_request_with_custom_exchange_options
+    puts "  -> [Manual] RPC (Custom Options Nivel 3)..."
+    custom_exchange = "custom_opts_rpc_x_#{SecureRandom.hex(4)}"
+    
+    # 1. Exigimos DURABLE
+    conn = BugBunny.create_connection
+    ch = conn.create_channel
+    ch.direct(custom_exchange, durable: true, auto_delete: true)
+
+    # 2. Levantamos un worker usando esas configuraciones nativas
+    worker_thread = Thread.new do
+      q = ch.queue('', exclusive: true)
+      q.bind(custom_exchange, routing_key: 'custom.rpc')
+      q.subscribe(block: true) do |delivery, props, _body|
+        # Respuesta manual
+        ch.default_exchange.publish('{"status":200, "body":"ok"}', routing_key: props.reply_to, correlation_id: props.correlation_id)
+      end
+    end
+    sleep 0.5
+
+    begin
+      # 3. El cliente hace el request inyectando las opciones
+      response = @client.request('test',
+        exchange: custom_exchange,
+        exchange_type: 'direct',
+        routing_key: 'custom.rpc',
+        exchange_options: { durable: true, auto_delete: true }, # Nivel 3
+        body: { req: 'data' }
+      )
+
+      assert_equal 200, response['status']
+      assert_equal 'ok', response['body']
+    ensure
+      worker_thread&.kill
+      ch&.exchange_delete(custom_exchange) rescue nil
+      conn&.close
+    end
+  end
+
+  private
+
+  def wait_for_message(queue, timeout_sec = 2)
+    Timeout.timeout(timeout_sec) { queue.pop }
+  rescue Timeout::Error
+    flunk "Timeout: No llegó el mensaje al Worker en #{timeout_sec}s"
+  end
+end

data/test/test_helper.rb

@@ -1,24 +1,109 @@
 # frozen_string_literal: true
-require 'bundler/setup'
-
-$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
-require 'bug_bunny'
 
+require 'bundler/setup'
 require 'minitest/autorun'
-require 'mocha/minitest'
-require 'logger'
+# require 'minitest/reporters'
+require 'bug_bunny'
+require 'connection_pool'
+require 'securerandom'
+require 'socket'
 
 BugBunny.configure do |config|
-  config.logger = Logger.new(nil)
-  config.bunny_logger = Logger.new(nil)
+  config.host = ENV.fetch('RABBITMQ_HOST', 'localhost')
+  config.username = ENV.fetch('RABBITMQ_USER', 'guest')
+  config.password = ENV.fetch('RABBITMQ_PASS', 'guest')
+  config.vhost = '/'
+  config.logger = Logger.new($stdout)
+  config.logger.level = Logger::WARN
+
+  # ========================================================
+  # LA MAGIA DE LA CASCADA (Nivel 2: Configuración Global)
+  # ========================================================
+  # Para los tests, queremos que los exchanges y queues sean efímeros
+  config.exchange_options = { durable: false, auto_delete: true }
+  config.queue_options    = { exclusive: false, durable: false, auto_delete: true }
 end
 
-module TestHelper
+TEST_POOL = ConnectionPool.new(size: 5, timeout: 5) { BugBunny.create_connection }
+BugBunny::Resource.connection_pool = TEST_POOL
+
+module IntegrationHelper
   def self.rabbitmq_available?
-    socket = TCPSocket.new('localhost', 5672)
+    socket = TCPSocket.new(BugBunny.configuration.host, 5672)
     socket.close
     true
-  rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT
+  rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError
     false
   end
+
+  def with_running_worker(queue:, exchange:, exchange_type: 'topic', routing_key: '#')
+    conn = BugBunny.create_connection
+
+    worker_thread = Thread.new do
+      ch = conn.create_channel
+
+      x_opts = BugBunny.configuration.exchange_options || {}
+      q_opts = BugBunny.configuration.queue_options || {}
+
+      # FIX: Usamos la API de alto nivel (public_send) idéntica a BugBunny::Session
+      ch.public_send(exchange_type, exchange, x_opts)
+      ch.close
+
+      BugBunny::Consumer.subscribe(
+        connection: conn,
+        queue_name: queue,
+        exchange_name: exchange,
+        exchange_type: exchange_type,
+        routing_key: routing_key,
+        queue_opts: q_opts,
+        block: true
+      )
+    rescue => e
+      puts "❌ WORKER CRASHED: #{e.message}"
+      puts e.backtrace.join("\n")
+    end
+
+    sleep 0.5
+    yield
+  ensure
+    conn&.close
+    worker_thread&.kill
+    sleep 0.1
+  end
+
+  def with_spy_worker(queue:, exchange:, exchange_type: 'topic', routing_key: '#')
+    captured_messages = Thread::Queue.new
+    conn = BugBunny.create_connection
+
+    worker_thread = Thread.new do
+      ch = conn.create_channel
+
+      x_opts = BugBunny.configuration.exchange_options || {}
+      q_opts = BugBunny.configuration.queue_options || {}
+
+      # FIX DEFINITIVO: Ahora 'x' es un hermoso objeto Bunny::Exchange
+      # que la función .bind() entiende perfectamente.
+      x = ch.public_send(exchange_type, exchange, x_opts)
+      q = ch.queue(queue, q_opts)
+
+      # Bindeamos el objeto al queue
+      q.bind(x, routing_key: routing_key)
+
+      q.subscribe(block: true) do |delivery, props, body|
+        captured_messages << {
+          body: body,
+          routing_key: delivery.routing_key,
+          headers: props.headers
+        }
+      end
+    rescue => e
+      puts "SPY WORKER ERROR: #{e.message}"
+    end
+
+    sleep 0.5
+    yield(captured_messages)
+  ensure
+    conn&.close
+    worker_thread&.kill
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.2
 platform: ruby
 authors:
 - gabix
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-18 00:00:00.000000000 Z
+date: 2026-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -206,6 +206,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
 description: BugBunny is a lightweight RPC framework for Ruby on Rails over RabbitMQ.
   It simulates a RESTful architecture with an intelligent router, Active Record-like
   resources, and middleware support.
@@ -218,9 +232,6 @@ files:
 - CHANGELOG.md
 - README.md
 - Rakefile
-- bin_client.rb
-- bin_suite.rb
-- bin_worker.rb
 - initializer_example.rb
 - lib/bug_bunny.rb
 - lib/bug_bunny/client.rb
@@ -241,18 +252,9 @@ files:
 - lib/generators/bug_bunny/install/install_generator.rb
 - lib/generators/bug_bunny/install/templates/initializer.rb
 - sig/bug_bunny.rbs
-- test/integration/fire_and_forget_test.rb
-- test/integration/rpc_flow_test.rb
+- test/integration/infrastructure_test.rb
+- test/integration/manual_client_test.rb
 - test/test_helper.rb
-- test/unit/configuration_test.rb
-- test/unit/consumer_test.rb
-- test/unit/controller_headers_test.rb
-- test/unit/hybrid_resource_test.rb
-- test/unit/middleware_test.rb
-- test/unit/resource_test.rb
-- test_controller.rb
-- test_helper.rb
-- test_resource.rb
 homepage: https://github.com/gedera/bug_bunny
 licenses:
 - MIT

data/bin_client.rb

@@ -1,51 +0,0 @@
-# bin_client.rb
-require_relative 'lib/bug_bunny'
-$stdout.sync = true # <--- Agrega esto
-
-# 1. Configuración
-BugBunny.configure do |config|
-  config.host = 'localhost'
-  config.username = 'wisproMQ'
-  config.password = 'wisproMQ'
-  config.vhost = 'sync.devel'
-  config.logger = Logger.new(STDOUT)
-  config.rpc_timeout = 5
-end
-
-# 2. Pool
-POOL = ConnectionPool.new(size: 2, timeout: 5) do
-  BugBunny.create_connection
-end
-
-# 3. Cliente
-client = BugBunny.new(pool: POOL)
-
-# --- PRUEBA 1: Publish ---
-puts "\n[1] Enviando mensaje asíncrono (Publish)..."
-
-# AGREGADO: exchange_type: 'topic'
-client.publish('test/ping', exchange: 'test_exchange', exchange_type: 'topic', routing_key: 'test.ping') do |req|
-  req.body = { msg: 'Hola, soy invisible' }
-end
-
-puts "    -> Enviado."
-sleep 1
-
-# --- PRUEBA 2: RPC ---
-puts "\n[2] Enviando petición síncrona (Request)..."
-
-begin
-  # AGREGADO: exchange_type: 'topic'
-  response = client.request('test/123/ping', exchange: 'test_exchange', exchange_type: 'topic', routing_key: 'test.ping') do |req|
-    req.body = { data: 'Importante' }
-    req.timeout = 3
-    req.headers['X-Source'] = 'Terminal'
-  end
-
-  puts "    -> ✅ RESPUESTA RECIBIDA:"
-  puts "       Status: #{response['status']}"
-  puts "       Body:   #{response['body']}"
-
-rescue BugBunny::RequestTimeout
-  puts "    -> ❌ Error: Timeout esperando respuesta."
-end