bug_bunny 3.1.0 → 3.1.1

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.1
 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

data/bin_suite.rb

@@ -1,106 +0,0 @@
-# bin_suite.rb
-require_relative 'test_helper'
-require_relative 'test_resource' # Cargamos la clase TestUser
-
-# Cliente "Raw" para pruebas manuales
-raw_client = BugBunny.new(pool: TEST_POOL)
-
-def assert(condition, msg)
-  if condition
-    puts "  ✅ PASS: #{msg}"
-  else
-    puts "  ❌ FAIL: #{msg}"
-  end
-end
-
-puts "\n🔎 --- INICIANDO SUITE DE PRUEBAS BUG BUNNY ---"
-
-# ---------------------------------------------------------
-# TEST 1: RPC Manual (Raw Client)
-# ---------------------------------------------------------
-puts "\n[1] Probando RPC Manual (Client#request)..."
-begin
-  # Notar la routing key: test_user.ping
-  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.class} - #{e.message}")
-end
-
-# ---------------------------------------------------------
-# TEST 2: Resource Finder (ORM)
-# ---------------------------------------------------------
-puts "\n[2] Probando BugBunny::Resource (Estilo Rails)..."
-
-# YA NO NECESITAS with_scope
-puts "    -> Buscando usuario ID 123..."
-user = TestUser.find(123)
-
-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")
-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
-# ---------------------------------------------------------
-puts "\n[4] Probando Validaciones Locales..."
-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")
-
-# ---------------------------------------------------------
-# TEST 5: Probando Configuración Dinámica (.with)...
-# ---------------------------------------------------------
-puts "\n[5] Probando Configuración Dinámica (.with)..."
-
-# Probamos cambiar el routing key prefix temporalmente
-begin
-  # Forzamos una routing key que no existe
-  puts "    -> Intentando ruta incorrecta (esperando timeout)..."
-  TestUser.with(routing_key: 'ruta.incorrecta').find(123)
-  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/bin_worker.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-# bin_worker.rb
-require 'bundler/setup'
-require 'bug_bunny'
-require_relative 'test_controller' # Cargamos los controladores
-
-puts '🐰 WORKER INICIADO (Exchange: Topic)...'
-
-# Configuración básica
-BugBunny.configure do |config|
-  config.logger = Logger.new($stdout)
-  config.logger.level = Logger::DEBUG
-end
-
-# Iniciar el Consumidor
-# Escucha en la cola 'bug_bunny_queue', atada al exchange 'test_exchange' con routing key '#' (todo)
-connection = BugBunny.create_connection
-
-BugBunny::Consumer.subscribe(
-  connection: connection,
-  exchange_name: 'test_exchange',
-  exchange_type: 'topic',
-  queue_name: 'bug_bunny_test_queue',
-  routing_key: '#' # Wildcard para recibir todo en este test
-)

data/test/integration/fire_and_forget_test.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../test_helper'
-require 'connection_pool'
-
-class FireAndForgetTest < Minitest::Test
-  def setup
-    skip "RabbitMQ no disponible" unless TestHelper.rabbitmq_available?
-
-    # 1. Configuración
-    BugBunny.configure do |c|
-      c.host = 'localhost'
-      c.username = 'wisproMQ'
-      c.password = 'wisproMQ'
-      c.port = 5672
-      c.logger = Logger.new(nil)
-    end
-
-    @pool = ConnectionPool.new(size: 1, timeout: 5) { BugBunny.create_connection }
-
-    # 2. Infraestructura de Test
-    @queue_name = 'test_fire_queue'
-    @exchange_name = 'test_fire_exchange'
-    @routing_key = 'logs.error'
-
-    # Usamos una Queue de Ruby para pasar el mensaje del Consumer al Test
-    @message_bucket = Queue.new
-
-    # 3. Consumidor "Espía"
-    @conn_consumer = BugBunny.create_connection
-    @consumer_thread = Thread.new do
-      ch = @conn_consumer.create_channel
-      # IMPORTANTE: Aquí declaramos el exchange como TOPIC
-      x = ch.topic(@exchange_name)
-      q = ch.queue(@queue_name).bind(x, routing_key: @routing_key)
-
-      q.subscribe(block: true) do |delivery_info, properties, body|
-        @message_bucket << {
-          body: body,
-          routing_key: delivery_info.routing_key
-        }
-      end
-    end
-    sleep 0.5 # Wait boot
-  end
-
-  def teardown
-    return unless @conn_consumer
-    @conn_consumer.close
-    @consumer_thread.kill
-  end
-
-  def test_publish_directly
-    client = BugBunny::Client.new(pool: @pool)
-    payload = { system: 'payment', error: 'timeout' }
-
-    # 1. Disparamos (Fire)
-    client.publish(
-      'logs/error',
-      body: payload,
-      exchange: @exchange_name,
-      exchange_type: 'topic',
-      routing_key: @routing_key
-    )
-
-    # 2. Verificamos asíncronamente
-    received = nil
-    Timeout.timeout(2) do
-      received = @message_bucket.pop
-    end
-
-    # 3. Aserciones
-    assert_equal payload.to_json, received[:body]
-    assert_equal @routing_key, received[:routing_key]
-  end
-end