bug_bunny 4.6.0 → 4.7.0

data/spec/integration/infrastructure_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/integration_helper'
+
+# Controladores de prueba aislados en namespace propio
+module InfraSpec
+  class PingController < BugBunny::Controller
+    def index
+      render status: 200, json: { message: 'pong', namespace: 'InfraSpec' }
+    end
+
+    def show
+      render status: 200, json: { id: params[:id], message: 'pong', namespace: 'InfraSpec' }
+    end
+  end
+end
+
+class InfraSpecResource < BugBunny::Resource
+  self.resource_name  = 'ping'
+  self.exchange       = 'infra_spec_exchange'
+  self.exchange_type  = 'topic'
+end
+
+RSpec.describe 'Infrastructure', :integration do
+  let(:queue)    { unique('infra_q') }
+  let(:exchange) { 'infra_spec_exchange' }
+
+  before do
+    BugBunny.configure { |c| c.controller_namespace = 'InfraSpec' }
+  end
+
+  after do
+    BugBunny.configure { |c| c.controller_namespace = 'BugBunny::Controllers' }
+  end
+
+  it 'levanta el worker y cede el control al bloque' do
+    with_running_worker(queue: queue, exchange: exchange) do
+      expect(true).to be(true)
+    end
+  end
+
+  it 'resuelve el namespace del controlador dinámicamente' do
+    with_running_worker(queue: queue, exchange: exchange) do
+      resource = InfraSpecResource.find('42')
+
+      expect(resource.id).to eq('42')
+      expect(resource.namespace).to eq('InfraSpec')
+      expect(resource.message).to eq('pong')
+    end
+  end
+end

data/spec/integration/resource_spec.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/integration_helper'
+
+module ResourceSpec
+  class NodeController < BugBunny::Controller
+    def index
+      nodes = params[:q] ? [{ id: '1', status: params.dig(:q, :status) }] : [{ id: '1' }, { id: '2' }]
+      render status: 200, json: nodes
+    end
+
+    def show
+      render status: 200, json: { id: params[:id], name: 'node-01' }
+    end
+
+    def create
+      render status: 201, json: { id: '99', name: params.dig(:node, :name) }
+    end
+
+    def update
+      render status: 200, json: { id: params[:id], updated: true, name: params.dig(:node, 'name') }
+    end
+
+    def destroy
+      render status: 200, json: { id: params[:id], deleted: true }
+    end
+  end
+end
+
+class SpecNode < BugBunny::Resource
+  self.resource_name = 'node'
+  self.param_key     = 'node'
+  self.exchange      = 'resource_spec_exchange'
+  self.exchange_type = 'topic'
+end
+
+RSpec.describe BugBunny::Resource, :integration do
+  let(:queue)    { unique('resource_q') }
+  let(:exchange) { 'resource_spec_exchange' }
+
+  before { BugBunny.configure { |c| c.controller_namespace = 'ResourceSpec' } }
+  after  { BugBunny.configure { |c| c.controller_namespace = 'BugBunny::Controllers' } }
+
+  describe '.find' do
+    it 'retorna el recurso por id' do
+      with_running_worker(queue: queue, exchange: exchange) do
+        node = SpecNode.find('1')
+
+        expect(node.id).to eq('1')
+        expect(node.name).to eq('node-01')
+      end
+    end
+  end
+
+  describe '.where' do
+    it 'retorna todos los recursos sin filtros' do
+      with_running_worker(queue: queue, exchange: exchange) do
+        nodes = SpecNode.where
+
+        expect(nodes).to be_an(Array)
+        expect(nodes.length).to eq(2)
+      end
+    end
+
+    it 'pasa los filtros como query params al controlador' do
+      with_running_worker(queue: queue, exchange: exchange) do
+        nodes = SpecNode.where(q: { status: 'active' })
+
+        expect(nodes).to be_an(Array)
+        expect(nodes.first.status).to eq('active')
+      end
+    end
+  end
+
+  describe '.create' do
+    it 'crea el recurso y retorna el objeto creado' do
+      with_running_worker(queue: queue, exchange: exchange) do
+        node = SpecNode.create(name: 'node-nuevo')
+
+        expect(node.id).to eq('99')
+        expect(node.name).to eq('node-nuevo')
+      end
+    end
+  end
+
+  describe '#update' do
+    it 'actualiza el recurso por id' do
+      with_running_worker(queue: queue, exchange: exchange) do
+        node = SpecNode.new(id: '1')
+        node.persisted = true
+        result = node.update(name: 'node-actualizado')
+
+        expect(result).to be(true)
+        expect(node.id).to eq('1')
+        expect(node.updated).to be(true)
+      end
+    end
+  end
+
+  describe '#destroy' do
+    it 'elimina el recurso por id' do
+      with_running_worker(queue: queue, exchange: exchange) do
+        node = SpecNode.new(id: '1')
+        node.persisted = true
+        result = node.destroy
+
+        expect(result).to be(true)
+        expect(node.persisted?).to be(false)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'bug_bunny'
+require 'connection_pool'
+require 'socket'
+
+# Carga variables de entorno desde .env si existe
+env_file = File.join(__dir__, '..', '.env')
+if File.exist?(env_file)
+  File.readlines(env_file).each do |line|
+    line = line.strip
+    next if line.empty? || line.start_with?('#')
+
+    key, value = line.split('=', 2)
+    ENV[key.strip] = value.strip.delete("'\"") if key && value
+  end
+end
+
+BugBunny.configure do |config|
+  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).tap { |l| l.level = Logger::WARN }
+  config.exchange_options = { durable: false, auto_delete: true }
+  config.queue_options    = { exclusive: false, durable: false, auto_delete: true }
+end
+
+TEST_POOL ||= ConnectionPool.new(size: 5, timeout: 5) { BugBunny.create_connection }
+BugBunny::Resource.connection_pool = TEST_POOL
+
+# Routes globales para todos los specs
+BugBunny.routes.draw do
+  resources :ping
+  resources :node
+  resources :user
+  get  'around',  to: 'around#index'
+  get  'rescue',  to: 'rescue#index'
+  get  'boom',    to: 'boom#index'
+  get  'echo',    to: 'echo#index'
+  post 'events',  to: 'event#create'
+end
+
+require 'support/integration_helper'
+require 'support/bunny_mocks'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.disable_monkey_patching!
+  config.warnings = false
+  config.order    = :random
+  Kernel.srand config.seed
+
+  # Skippea tests de integración si RabbitMQ no está disponible
+  config.before(:each, :integration) do
+    skip 'RabbitMQ no disponible' unless rabbitmq_available?
+  end
+
+  config.include_context 'integration helpers', :integration
+end

data/spec/support/bunny_mocks.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Stubs livianos de Bunny para specs unitarios que no necesitan RabbitMQ real.
+
+module BunnyMocks
+  FakeChannel = Struct.new(:open) do
+    def open?       = open
+    def close       = (self.open = false)
+    def confirm_select; end
+    def prefetch(_n); end
+  end
+
+  FakeConnection = Struct.new(:open, :channel_to_return) do
+    def open?           = open
+    def start           = (self.open = true)
+    def create_channel  = channel_to_return
+  end
+end

data/spec/support/integration_helper.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+# Helpers compartidos para specs de integración con RabbitMQ real.
+# Incluido automáticamente en todos los specs marcados con :integration.
+RSpec.shared_context 'integration helpers' do
+  def rabbitmq_available?
+    conn = BugBunny.create_connection
+    conn.start
+    conn.close
+    true
+  rescue StandardError
+    false
+  end
+
+  # Levanta un Consumer real en un thread separado y cede el control al bloque.
+  # El consumer se detiene al salir del bloque.
+  #
+  # @param queue [String] nombre de la cola
+  # @param exchange [String] nombre del exchange
+  # @param exchange_type [String] tipo de exchange
+  # @param routing_key [String] routing key de binding
+  def with_running_worker(queue:, exchange:, exchange_type: 'topic', routing_key: '#')
+    conn = BugBunny.create_connection
+    consumer = BugBunny::Consumer.new(conn)
+
+    worker_thread = Thread.new do
+      consumer.subscribe(
+        queue_name:    queue,
+        exchange_name: exchange,
+        exchange_type: exchange_type,
+        routing_key:   routing_key,
+        block:         true
+      )
+    rescue StandardError => e
+      warn "WORKER ERROR: #{e.message}"
+    end
+
+    sleep 0.5
+    yield
+  ensure
+    consumer.shutdown rescue nil
+    conn&.close rescue nil
+    worker_thread&.kill
+    sleep 0.1
+  end
+
+  # Levanta un worker espía que captura mensajes raw sin procesarlos.
+  # Útil para verificar que el mensaje llegó con el routing key y headers correctos.
+  #
+  # @yieldparam messages [Thread::Queue] cola thread-safe donde llegan los mensajes
+  def with_spy_worker(queue:, exchange:, exchange_type: 'topic', routing_key: '#')
+    messages = Thread::Queue.new
+    conn = BugBunny.create_connection
+
+    worker_thread = Thread.new do
+      ch = conn.create_channel
+      x  = ch.public_send(exchange_type, exchange, BugBunny.configuration.exchange_options)
+      q  = ch.queue(queue, BugBunny.configuration.queue_options)
+      q.bind(x, routing_key: routing_key)
+      q.subscribe(block: true) do |delivery, props, body|
+        messages << { body: body, routing_key: delivery.routing_key, headers: props.headers }
+      end
+    rescue StandardError => e
+      warn "SPY ERROR: #{e.message}"
+    end
+
+    sleep 0.5
+    yield(messages)
+  ensure
+    conn&.close rescue nil
+    worker_thread&.kill
+  end
+
+  # Espera un mensaje de la Queue con timeout.
+  def wait_for_message(queue, timeout_sec = 3)
+    Timeout.timeout(timeout_sec) { queue.pop }
+  rescue Timeout::Error
+    raise "Timeout: no llegó ningún mensaje en #{timeout_sec}s"
+  end
+
+  # Genera nombres únicos para evitar colisiones entre tests.
+  def unique(name)
+    "#{name}_#{SecureRandom.hex(4)}"
+  end
+end

data/spec/unit/client_session_pool_spec.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/bunny_mocks'
+
+RSpec.describe BugBunny::Client, 'session pooling' do
+  include BunnyMocks
+
+  # Pool falso que siempre entrega la misma conexión.
+  def fake_pool(*conns)
+    index = 0
+    pool  = Object.new
+    pool.define_singleton_method(:with) do |&block|
+      block.call(conns[index % conns.size])
+    ensure
+      index += 1
+    end
+    pool
+  end
+
+  def fake_conn
+    channel = BunnyMocks::FakeChannel.new(true)
+    BunnyMocks::FakeConnection.new(true, channel)
+  end
+
+  # Crea un cliente con un Producer stub que responde inmediatamente.
+  def client_with_pool(pool)
+    client = described_class.new(pool: pool)
+    # Stub Producer#rpc para que no toque RabbitMQ real
+    allow_any_instance_of(BugBunny::Producer).to receive(:rpc) do |_prod, req|
+      { 'status' => 200, 'body' => '{"ok":true}' }
+    end
+    allow_any_instance_of(BugBunny::Producer).to receive(:fire) do |_prod, _req|
+      { 'status' => 202, 'body' => nil }
+    end
+    client
+  end
+
+  describe 'Session reuse' do
+    it 'crea una sola Session aunque se hagan múltiples requests a la misma conexión' do
+      conn   = fake_conn
+      client = client_with_pool(fake_pool(conn))
+
+      session_new_count = 0
+      allow(BugBunny::Session).to receive(:new).and_wrap_original do |orig, *args, **kwargs|
+        session_new_count += 1
+        orig.call(*args, **kwargs)
+      end
+
+      3.times { client.request('ping', method: :get, exchange: 'x', exchange_type: 'direct') }
+
+      expect(session_new_count).to eq(1)
+    end
+
+    it 'retorna la misma instancia de Session en cada request' do
+      conn   = fake_conn
+      client = client_with_pool(fake_pool(conn))
+
+      client.request('ping', method: :get, exchange: 'x', exchange_type: 'direct')
+      session_after_first = conn.instance_variable_get(:@_bug_bunny_session)
+
+      client.request('ping', method: :get, exchange: 'x', exchange_type: 'direct')
+      session_after_second = conn.instance_variable_get(:@_bug_bunny_session)
+
+      expect(session_after_first).to be(session_after_second)
+    end
+
+    it 'crea Sessions distintas para conexiones distintas' do
+      conn_a = fake_conn
+      conn_b = fake_conn
+      pool   = fake_pool(conn_a, conn_b)
+      client = client_with_pool(pool)
+
+      client.request('ping', method: :get, exchange: 'x', exchange_type: 'direct')
+      client.request('ping', method: :get, exchange: 'x', exchange_type: 'direct')
+
+      session_a = conn_a.instance_variable_get(:@_bug_bunny_session)
+      session_b = conn_b.instance_variable_get(:@_bug_bunny_session)
+
+      expect(session_a).not_to be_nil
+      expect(session_b).not_to be_nil
+      expect(session_a).not_to be(session_b)
+    end
+  end
+
+  describe 'Producer reuse' do
+    it 'crea un solo Producer aunque se hagan múltiples requests a la misma conexión' do
+      conn   = fake_conn
+      client = client_with_pool(fake_pool(conn))
+
+      producer_new_count = 0
+      allow(BugBunny::Producer).to receive(:new).and_wrap_original do |orig, *args|
+        producer_new_count += 1
+        orig.call(*args)
+      end
+
+      3.times { client.request('ping', method: :get, exchange: 'x', exchange_type: 'direct') }
+
+      expect(producer_new_count).to eq(1)
+    end
+
+    it 'retorna la misma instancia de Producer en cada request' do
+      conn   = fake_conn
+      client = client_with_pool(fake_pool(conn))
+
+      client.request('ping', method: :get, exchange: 'x', exchange_type: 'direct')
+      producer_after_first = conn.instance_variable_get(:@_bug_bunny_producer)
+
+      client.request('ping', method: :get, exchange: 'x', exchange_type: 'direct')
+      producer_after_second = conn.instance_variable_get(:@_bug_bunny_producer)
+
+      expect(producer_after_first).to be(producer_after_second)
+    end
+  end
+
+  describe 'thread-safety' do
+    it 'múltiples threads con la misma conexión no generan Sessions duplicadas' do
+      conn   = fake_conn
+      # Pool siempre devuelve la misma conexión — simula concurrencia en el mismo slot
+      pool = Object.new
+      mutex = Mutex.new
+      pool.define_singleton_method(:with) { |&blk| mutex.synchronize { blk.call(conn) } }
+
+      client = client_with_pool(pool)
+
+      session_new_count = Concurrent::AtomicFixnum.new(0)
+      allow(BugBunny::Session).to receive(:new).and_wrap_original do |orig, *args, **kwargs|
+        session_new_count.increment
+        orig.call(*args, **kwargs)
+      end
+
+      threads = 10.times.map do
+        Thread.new { client.request('ping', method: :get, exchange: 'x', exchange_type: 'direct') }
+      end
+      threads.each(&:join)
+
+      expect(session_new_count.value).to eq(1)
+    end
+  end
+
+  describe 'Session no se cierra entre requests' do
+    it 'no invoca close en la Session al terminar el request' do
+      conn   = fake_conn
+      client = client_with_pool(fake_pool(conn))
+
+      # Primera request para crear y cachear la session
+      client.request('ping', method: :get, exchange: 'x', exchange_type: 'direct')
+
+      session = conn.instance_variable_get(:@_bug_bunny_session)
+      expect(session).not_to be_nil
+
+      # Espiamos la session cacheada y ejecutamos una segunda request
+      allow(session).to receive(:close).and_call_original
+      client.request('ping', method: :get, exchange: 'x', exchange_type: 'direct')
+
+      expect(session).not_to have_received(:close)
+    end
+  end
+end

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BugBunny::Configuration do
+  # Construye una configuración con los defaults + overrides dados, llama validate!.
+  def configure_with(**overrides)
+    BugBunny.configuration = BugBunny::Configuration.new
+    BugBunny.configure do |c|
+      overrides.each { |attr, val| c.send(:"#{attr}=", val) }
+    end
+  end
+
+  after { BugBunny.configuration = BugBunny::Configuration.new }
+
+  describe 'defaults' do
+    it 'pasan validate! sin ninguna configuración adicional' do
+      expect { configure_with }.not_to raise_error
+    end
+  end
+
+  describe 'host' do
+    it 'levanta ConfigurationError si es nil' do
+      expect { configure_with(host: nil) }
+        .to raise_error(BugBunny::ConfigurationError, /host is required/)
+    end
+
+    it 'levanta ConfigurationError si es string vacío' do
+      expect { configure_with(host: '') }
+        .to raise_error(BugBunny::ConfigurationError, /host is required/)
+    end
+
+    it 'levanta ConfigurationError si no es String' do
+      expect { configure_with(host: 12_345) }
+        .to raise_error(BugBunny::ConfigurationError, /host must be a String/)
+    end
+  end
+
+  describe 'port' do
+    it 'levanta ConfigurationError si es un String' do
+      expect { configure_with(port: 'invalid') }
+        .to raise_error(BugBunny::ConfigurationError, /port must be a Integer/)
+    end
+
+    it 'levanta ConfigurationError si es 0 (fuera de rango)' do
+      expect { configure_with(port: 0) }
+        .to raise_error(BugBunny::ConfigurationError, /port must be in/)
+    end
+
+    it 'levanta ConfigurationError si es 99999 (fuera de rango)' do
+      expect { configure_with(port: 99_999) }
+        .to raise_error(BugBunny::ConfigurationError, /port must be in/)
+    end
+
+    it 'acepta valores en los límites del rango (1 y 65535)' do
+      expect { configure_with(port: 1) }.not_to raise_error
+      expect { configure_with(port: 65_535) }.not_to raise_error
+    end
+
+    it 'acepta 5672 (default de RabbitMQ)' do
+      expect { configure_with(port: 5672) }.not_to raise_error
+    end
+  end
+
+  describe 'username / password' do
+    it 'levanta ConfigurationError si username es nil' do
+      expect { configure_with(username: nil) }
+        .to raise_error(BugBunny::ConfigurationError, /username is required/)
+    end
+
+    it 'levanta ConfigurationError si password es nil' do
+      expect { configure_with(password: nil) }
+        .to raise_error(BugBunny::ConfigurationError, /password is required/)
+    end
+
+    it 'levanta ConfigurationError si username no es String' do
+      expect { configure_with(username: 123) }
+        .to raise_error(BugBunny::ConfigurationError, /username must be a String/)
+    end
+  end
+
+  describe 'heartbeat' do
+    it 'acepta 0 (heartbeat deshabilitado)' do
+      expect { configure_with(heartbeat: 0) }.not_to raise_error
+    end
+
+    it 'levanta ConfigurationError si es negativo' do
+      expect { configure_with(heartbeat: -1) }
+        .to raise_error(BugBunny::ConfigurationError, /heartbeat must be in/)
+    end
+
+    it 'levanta ConfigurationError si supera 3600' do
+      expect { configure_with(heartbeat: 3_601) }
+        .to raise_error(BugBunny::ConfigurationError, /heartbeat must be in/)
+    end
+
+    it 'levanta ConfigurationError si no es Integer' do
+      expect { configure_with(heartbeat: '30') }
+        .to raise_error(BugBunny::ConfigurationError, /heartbeat must be a Integer/)
+    end
+  end
+
+  describe 'rpc_timeout' do
+    it 'levanta ConfigurationError si es negativo' do
+      expect { configure_with(rpc_timeout: -1) }
+        .to raise_error(BugBunny::ConfigurationError, /rpc_timeout must be in/)
+    end
+
+    it 'levanta ConfigurationError si es 0' do
+      expect { configure_with(rpc_timeout: 0) }
+        .to raise_error(BugBunny::ConfigurationError, /rpc_timeout must be in/)
+    end
+  end
+
+  describe 'channel_prefetch' do
+    it 'levanta ConfigurationError si es 0' do
+      expect { configure_with(channel_prefetch: 0) }
+        .to raise_error(BugBunny::ConfigurationError, /channel_prefetch must be in/)
+    end
+
+    it 'levanta ConfigurationError si supera 10000' do
+      expect { configure_with(channel_prefetch: 10_001) }
+        .to raise_error(BugBunny::ConfigurationError, /channel_prefetch must be in/)
+    end
+  end
+
+  describe 'configuración válida completa' do
+    it 'acepta todos los atributos con valores correctos' do
+      expect do
+        configure_with(
+          host: '10.0.0.1',
+          port: 5673,
+          username: 'myuser',
+          password: 'mypass',
+          vhost: '/production',
+          heartbeat: 30,
+          rpc_timeout: 5,
+          channel_prefetch: 10
+        )
+      end.not_to raise_error
+    end
+  end
+
+  describe 'atributos opcionales nil' do
+    it 'acepta nil en atributos no requeridos (max_reconnect_attempts, health_check_file)' do
+      expect do
+        configure_with(max_reconnect_attempts: nil, health_check_file: nil)
+      end.not_to raise_error
+    end
+  end
+
+  describe '.validate! directamente' do
+    it 'es invocable directamente sobre la instancia' do
+      config = BugBunny::Configuration.new
+      expect { config.validate! }.not_to raise_error
+    end
+
+    it 'levanta ConfigurationError si el estado es inválido' do
+      config = BugBunny::Configuration.new
+      config.port = 'bad'
+      expect { config.validate! }.to raise_error(BugBunny::ConfigurationError)
+    end
+  end
+end