bug_bunny 4.6.0 → 4.7.0

data/spec/unit/consumer_middleware_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BugBunny::ConsumerMiddleware::Stack do
+  subject(:stack) { described_class.new }
+
+  let(:delivery_info) { double('delivery_info') }
+  let(:properties)    { double('properties') }
+  let(:body)          { 'payload' }
+
+  # Construye un middleware de seguimiento que escribe en `log` (Array capturado por closure).
+  def tracking_middleware(log, label)
+    Class.new(BugBunny::ConsumerMiddleware::Base) do
+      define_method(:call) do |delivery, props, msg|
+        log << :"#{label}_before"
+        @app.call(delivery, props, msg)
+        log << :"#{label}_after"
+      end
+    end
+  end
+
+  describe '#use' do
+    it 'registra un middleware y retorna self para encadenamiento' do
+      klass  = Class.new(BugBunny::ConsumerMiddleware::Base)
+      result = stack.use(klass)
+
+      expect(result).to be(stack)
+      expect(stack.instance_variable_get(:@middlewares)).to eq([klass])
+    end
+
+    it 'permite encadenar múltiples calls' do
+      klass_a = Class.new(BugBunny::ConsumerMiddleware::Base)
+      klass_b = Class.new(BugBunny::ConsumerMiddleware::Base)
+
+      stack.use(klass_a).use(klass_b)
+
+      expect(stack.instance_variable_get(:@middlewares)).to eq([klass_a, klass_b])
+    end
+
+    it 'es thread-safe bajo registros concurrentes' do
+      classes = 20.times.map { Class.new(BugBunny::ConsumerMiddleware::Base) }
+      threads = classes.map { |klass| Thread.new { stack.use(klass) } }
+      threads.each(&:join)
+
+      expect(stack.instance_variable_get(:@middlewares).size).to eq(20)
+    end
+  end
+
+  describe '#empty?' do
+    it 'retorna true cuando no hay middlewares' do
+      expect(stack.empty?).to be(true)
+    end
+
+    it 'retorna false después de registrar un middleware' do
+      stack.use(Class.new(BugBunny::ConsumerMiddleware::Base))
+      expect(stack.empty?).to be(false)
+    end
+  end
+
+  describe '#call' do
+    it 'ejecuta el core directamente si no hay middlewares' do
+      core_called = false
+      stack.call(delivery_info, properties, body) { core_called = true }
+      expect(core_called).to be(true)
+    end
+
+    it 'ejecuta los middlewares en orden FIFO — el primero registrado envuelve al segundo' do
+      log = []
+      stack.use(tracking_middleware(log, :a)).use(tracking_middleware(log, :b))
+
+      stack.call(delivery_info, properties, body) { log << :core }
+
+      expect(log).to eq(%i[a_before b_before core b_after a_after])
+    end
+
+    it 'pasa delivery_info, properties y body sin modificar al primer middleware' do
+      received = {}
+      spy = Class.new(BugBunny::ConsumerMiddleware::Base) do
+        define_method(:call) do |delivery, props, msg|
+          received[:delivery] = delivery
+          received[:props]    = props
+          received[:body]     = msg
+          @app.call(delivery, props, msg)
+        end
+      end
+
+      stack.use(spy)
+      stack.call(delivery_info, properties, body) {}
+
+      expect(received[:delivery]).to be(delivery_info)
+      expect(received[:props]).to be(properties)
+      expect(received[:body]).to eq(body)
+    end
+
+    it 'usa snapshot del array — un use() concurrente no altera la cadena en ejecución' do
+      barrier      = Concurrent::CyclicBarrier.new(2)
+      intruder_ran = Concurrent::AtomicBoolean.new(false)
+
+      # Middleware lento que se sincroniza con el thread que registra
+      slow = Class.new(BugBunny::ConsumerMiddleware::Base) do
+        define_method(:call) do |delivery, props, msg|
+          barrier.wait
+          @app.call(delivery, props, msg)
+        end
+      end
+
+      intruder = Class.new(BugBunny::ConsumerMiddleware::Base) do
+        define_method(:call) do |delivery, props, msg|
+          intruder_ran.make_true
+          @app.call(delivery, props, msg)
+        end
+      end
+
+      stack.use(slow)
+
+      call_thread = Thread.new { stack.call(delivery_info, properties, body) {} }
+
+      # Registrar el intruder mientras call está bloqueado en barrier.wait
+      barrier.wait
+      stack.use(intruder)
+
+      call_thread.join
+
+      # El intruder se registró DESPUÉS del snapshot — no debe haber ejecutado
+      expect(intruder_ran.value).to be(false)
+    end
+  end
+end

data/spec/unit/consumer_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/bunny_mocks'
+
+RSpec.describe BugBunny::Consumer do
+  include BunnyMocks
+
+  let(:channel)    { BunnyMocks::FakeChannel.new(true) }
+  let(:connection) { BunnyMocks::FakeConnection.new(true, channel) }
+  let(:consumer)   { described_class.new(connection) }
+
+  let(:fake_session) do
+    session = instance_double(BugBunny::Session)
+    allow(session).to receive(:exchange).and_return(double('exchange'))
+    allow(session).to receive(:queue).and_return(fake_queue)
+    allow(session).to receive(:close)
+    session
+  end
+
+  let(:fake_queue) do
+    q = double('queue')
+    allow(q).to receive(:bind)
+    allow(q).to receive(:subscribe)
+    q
+  end
+
+  before do
+    consumer.instance_variable_set(:@session, fake_session)
+  end
+
+  describe '#shutdown' do
+    it 'detiene el health timer' do
+      timer = instance_double(Concurrent::TimerTask)
+      expect(timer).to receive(:shutdown)
+
+      consumer.instance_variable_set(:@health_timer, timer)
+      consumer.shutdown
+
+      expect(consumer.instance_variable_get(:@health_timer)).to be_nil
+    end
+
+    it 'es idempotente si no hay timer activo' do
+      consumer.instance_variable_set(:@health_timer, nil)
+      expect { consumer.shutdown }.not_to raise_error
+    end
+
+    it 'cierra la sesión' do
+      expect(fake_session).to receive(:close)
+      consumer.shutdown
+    end
+  end
+
+  describe '#subscribe' do
+    it 'llama a shutdown en el ensure al salir normalmente' do
+      shutdown_called = false
+      consumer.define_singleton_method(:shutdown) { shutdown_called = true }
+
+      consumer.subscribe(
+        queue_name:    'q',
+        exchange_name: 'x',
+        routing_key:   '#',
+        block:         false
+      )
+
+      expect(shutdown_called).to be(true)
+    end
+
+    it 'llama a shutdown aunque subscribe falle con max_reconnect_attempts=1' do
+      shutdown_called = false
+      consumer.define_singleton_method(:shutdown) { shutdown_called = true }
+
+      allow(fake_session).to receive(:exchange).and_raise(RuntimeError, 'boom')
+      BugBunny.configuration.max_reconnect_attempts = 1
+
+      expect do
+        consumer.subscribe(
+          queue_name:    'q',
+          exchange_name: 'x',
+          routing_key:   '#',
+          block:         false
+        )
+      end.to raise_error(RuntimeError)
+
+      expect(shutdown_called).to be(true)
+    ensure
+      BugBunny.configuration.max_reconnect_attempts = nil
+    end
+  end
+end

data/spec/unit/controller_after_action_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe BugBunny::Controller, 'after_action' do
+  # Construye un controlador mínimo funcional y lo ejecuta directamente.
+  def call_controller(klass, action: :index, body: {})
+    klass.call(headers: { action: action.to_s }, body: body)
+  end
+
+  describe '.after_action' do
+    it 'registra el callback y retorna void' do
+      klass = Class.new(BugBunny::Controller)
+      klass.after_action :log_after
+      expect(klass.after_actions[:_all_actions]).to include(:log_after)
+    end
+
+    it 'soporta la opción only: para restringir la acción' do
+      klass = Class.new(BugBunny::Controller)
+      klass.after_action :log_after, only: [:show]
+      expect(klass.after_actions[:show]).to include(:log_after)
+      expect(klass.after_actions[:_all_actions]).to be_nil
+    end
+
+    it 'no muta la clase padre al registrar en la subclase' do
+      parent = Class.new(BugBunny::Controller)
+      child  = Class.new(parent)
+      child.after_action :child_callback
+
+      expect(parent.after_actions[:_all_actions]).to be_nil
+      expect(child.after_actions[:_all_actions]).to include(:child_callback)
+    end
+  end
+
+  describe 'ejecución' do
+    it 'ejecuta el callback después de la acción' do
+      log = []
+      klass = Class.new(BugBunny::Controller) do
+        after_action :record_after
+        define_method(:index) { log << :action; render status: 200, json: {} }
+        define_method(:record_after) { log << :after }
+      end
+
+      call_controller(klass)
+      expect(log).to eq(%i[action after])
+    end
+
+    it 'ejecuta múltiples after_actions en orden FIFO' do
+      log = []
+      klass = Class.new(BugBunny::Controller) do
+        after_action :first_after
+        after_action :second_after
+        define_method(:index) { log << :action; render status: 200, json: {} }
+        define_method(:first_after)  { log << :first }
+        define_method(:second_after) { log << :second }
+      end
+
+      call_controller(klass)
+      expect(log).to eq(%i[action first second])
+    end
+
+    it 'ejecuta after_action después de before_action y de la acción' do
+      log = []
+      klass = Class.new(BugBunny::Controller) do
+        before_action :record_before
+        after_action  :record_after
+        define_method(:index) { log << :action; render status: 200, json: {} }
+        define_method(:record_before) { log << :before }
+        define_method(:record_after)  { log << :after }
+      end
+
+      call_controller(klass)
+      expect(log).to eq(%i[before action after])
+    end
+
+    it 'ejecuta after_action dentro del yield de around_action' do
+      log = []
+      klass = Class.new(BugBunny::Controller) do
+        around_action :wrap
+        after_action  :record_after
+        define_method(:index) { log << :action; render status: 200, json: {} }
+        define_method(:record_after) { log << :after }
+        define_method(:wrap) { |&blk| log << :around_pre; blk.call; log << :around_post }
+      end
+
+      call_controller(klass)
+      # after_action corre dentro del yield del around, antes de :around_post
+      expect(log).to eq(%i[around_pre action after around_post])
+    end
+
+    it 'NO ejecuta after_action si before_action interrumpió con render' do
+      log = []
+      klass = Class.new(BugBunny::Controller) do
+        before_action :halt_early
+        after_action  :record_after
+        define_method(:index) { log << :action; render status: 200, json: {} }
+        define_method(:halt_early)   { render status: 403, json: { error: 'forbidden' } }
+        define_method(:record_after) { log << :after }
+      end
+
+      call_controller(klass)
+      expect(log).to be_empty
+    end
+
+    it 'NO ejecuta after_action si la acción lanzó una excepción' do
+      log = []
+      klass = Class.new(BugBunny::Controller) do
+        after_action :record_after
+        define_method(:index) { raise 'boom' }
+        define_method(:record_after) { log << :after }
+      end
+
+      call_controller(klass) # rescue_from genérico devuelve 500
+      expect(log).to be_empty
+    end
+
+    it 'respeta only: y no ejecuta el callback en otras acciones' do
+      log = []
+      klass = Class.new(BugBunny::Controller) do
+        after_action :record_after, only: [:show]
+        define_method(:index) { log << :index_ran; render status: 200, json: {} }
+        define_method(:show)  { log << :show_ran;  render status: 200, json: {} }
+        define_method(:record_after) { log << :after }
+      end
+
+      call_controller(klass, action: :index)
+      expect(log).to eq(%i[index_ran])
+
+      log.clear
+      call_controller(klass, action: :show)
+      expect(log).to eq(%i[show_ran after])
+    end
+
+    it 'hereda after_actions del padre y agrega los propios sin mutarlo' do
+      log = []
+      parent = Class.new(BugBunny::Controller) do
+        after_action :parent_after
+        define_method(:index) { log << :action; render status: 200, json: {} }
+        define_method(:parent_after) { log << :parent }
+      end
+
+      child = Class.new(parent) do
+        after_action :child_after
+        define_method(:child_after) { log << :child }
+      end
+
+      call_controller(child)
+      expect(log).to eq(%i[action parent child])
+
+      log.clear
+      call_controller(parent)
+      expect(log).to eq(%i[action parent])
+    end
+  end
+end

data/spec/unit/observability_spec.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'logger'
+
+RSpec.describe BugBunny::Observability do
+  # Host class mínimo para ejercitar el mixin.
+  let(:host_class) do
+    Class.new do
+      include BugBunny::Observability
+
+      attr_writer :logger
+
+      def initialize(logger)
+        @logger = logger
+      end
+
+      # Expone safe_log públicamente solo para tests.
+      public :safe_log
+    end
+  end
+
+  let(:log_output) { StringIO.new }
+  let(:logger)     { Logger.new(log_output) }
+  let(:host)       { host_class.new(logger) }
+
+  # Extrae el mensaje del log (después del prefijo "D, [timestamp] DEBUG -- :")
+  def last_log_line
+    log_output.string.split("\n").last.to_s.sub(/\A.*?:\s*/, '')
+  end
+
+  describe '.sensitive_key? (módulo público)' do
+    subject(:sensitive?) { BugBunny::Observability.method(:sensitive_key?) }
+
+    context 'keys símbolo' do
+      it 'filtra :password' do
+        expect(BugBunny::Observability.sensitive_key?(:password)).to be(true)
+      end
+
+      it 'filtra :token' do
+        expect(BugBunny::Observability.sensitive_key?(:token)).to be(true)
+      end
+
+      it 'filtra :secret' do
+        expect(BugBunny::Observability.sensitive_key?(:secret)).to be(true)
+      end
+
+      it 'filtra :api_key' do
+        expect(BugBunny::Observability.sensitive_key?(:api_key)).to be(true)
+      end
+
+      it 'filtra :auth' do
+        expect(BugBunny::Observability.sensitive_key?(:auth)).to be(true)
+      end
+    end
+
+    context 'keys string' do
+      it 'filtra "password"' do
+        expect(BugBunny::Observability.sensitive_key?('password')).to be(true)
+      end
+
+      it 'filtra "Authorization" (case-insensitive)' do
+        expect(BugBunny::Observability.sensitive_key?('Authorization')).to be(true)
+      end
+
+      it 'filtra "X-Api-Key" (case-insensitive)' do
+        expect(BugBunny::Observability.sensitive_key?('X-Api-Key')).to be(true)
+      end
+    end
+
+    context 'partial matches' do
+      it 'filtra "user_password"' do
+        expect(BugBunny::Observability.sensitive_key?('user_password')).to be(true)
+      end
+
+      it 'filtra "access_token"' do
+        expect(BugBunny::Observability.sensitive_key?('access_token')).to be(true)
+      end
+
+      it 'filtra "refresh_token"' do
+        expect(BugBunny::Observability.sensitive_key?('refresh_token')).to be(true)
+      end
+
+      it 'filtra "accessToken" (camelCase)' do
+        expect(BugBunny::Observability.sensitive_key?('accessToken')).to be(true)
+      end
+
+      it 'filtra "password2"' do
+        expect(BugBunny::Observability.sensitive_key?('password2')).to be(true)
+      end
+
+      it 'filtra "csrf_token"' do
+        expect(BugBunny::Observability.sensitive_key?('csrf_token')).to be(true)
+      end
+
+      it 'filtra "csrftoken"' do
+        expect(BugBunny::Observability.sensitive_key?('csrftoken')).to be(true)
+      end
+
+      it 'filtra "db_credentials"' do
+        expect(BugBunny::Observability.sensitive_key?('db_credentials')).to be(true)
+      end
+
+      it 'filtra "private_key"' do
+        expect(BugBunny::Observability.sensitive_key?('private_key')).to be(true)
+      end
+
+      it 'filtra "session_id"' do
+        expect(BugBunny::Observability.sensitive_key?('session_id')).to be(true)
+      end
+    end
+
+    context 'sin falsos positivos' do
+      it 'no filtra "username"' do
+        expect(BugBunny::Observability.sensitive_key?('username')).to be(false)
+      end
+
+      it 'no filtra "user_email"' do
+        expect(BugBunny::Observability.sensitive_key?('user_email')).to be(false)
+      end
+
+      it 'no filtra "passport_number"' do
+        expect(BugBunny::Observability.sensitive_key?('passport_number')).to be(false)
+      end
+
+      it 'no filtra "status"' do
+        expect(BugBunny::Observability.sensitive_key?('status')).to be(false)
+      end
+
+      it 'no filtra "duration_s"' do
+        expect(BugBunny::Observability.sensitive_key?('duration_s')).to be(false)
+      end
+    end
+  end
+
+  describe '#safe_log — filtrado en el output' do
+    it 'reemplaza el valor de una key sensible con [FILTERED]' do
+      host.safe_log(:info, 'test.event', password: 'secret123')
+      expect(last_log_line).to include('password=[FILTERED]')
+      expect(last_log_line).not_to include('secret123')
+    end
+
+    it 'filtra keys string sensibles' do
+      host.safe_log(:info, 'test.event', 'Authorization' => 'Bearer xyz')
+      expect(last_log_line).to include('Authorization=[FILTERED]')
+      expect(last_log_line).not_to include('Bearer xyz')
+    end
+
+    it 'filtra partial match en key' do
+      host.safe_log(:info, 'test.event', user_password: 'hunter2')
+      expect(last_log_line).to include('user_password=[FILTERED]')
+    end
+
+    it 'no filtra keys no sensibles' do
+      host.safe_log(:info, 'test.event', username: 'gabriel')
+      expect(last_log_line).to include('username=gabriel')
+    end
+
+    it 'filtra múltiples keys sensibles en el mismo log' do
+      host.safe_log(:info, 'test.event', token: 'abc', status: 'ok', secret: 'xyz')
+      line = last_log_line
+      expect(line).to include('token=[FILTERED]')
+      expect(line).to include('secret=[FILTERED]')
+      expect(line).to include('status=ok')
+    end
+  end
+end

data/spec/unit/resource_attributes_spec.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+module ResourceAttributesSpec
+  class Product < BugBunny::Resource
+    attribute :name, :string
+    attribute :price, :decimal
+    attribute :active, :boolean
+    attribute :created_at, :datetime
+  end
+end
+
+RSpec.describe BugBunny::Resource do
+  let(:product_class) { ResourceAttributesSpec::Product }
+
+  describe 'ActiveModel::Attributes integration' do
+    it 'realiza la coerción de tipos para atributos definidos' do
+      product = product_class.new(
+        name: 'Teclado',
+        price: '25.50',
+        active: '1',
+        created_at: '2026-04-01 12:00:00'
+      )
+
+      expect(product.name).to eq('Teclado')
+      expect(product.price).to be_a(BigDecimal)
+      expect(product.price).to eq(BigDecimal('25.50'))
+      expect(product.active).to be(true)
+      expect(product.created_at).to be_a(Time)
+    end
+
+    it 'permite atributos dinámicos que no están definidos' do
+      product = product_class.new(name: 'Teclado', category: 'Hardware')
+
+      expect(product.name).to eq('Teclado')
+      expect(product.category).to eq('Hardware')
+    end
+
+    it 'detecta cambios tanto en atributos definidos como dinámicos usando ActiveModel::Dirty' do
+      product = product_class.new(name: 'Teclado', price: 10.0)
+      product.persisted = true
+      product.clear_changes_information
+
+      # Cambio en atributo definido (tipado)
+      product.price = 15.0
+      # Cambio en atributo dinámico
+      product.sku = 'TK-123'
+
+      expect(product.changed?).to be(true)
+      expect(product.changed).to include('price', 'sku')
+      
+      expect(product.changes_to_send).to eq({
+        'price' => 15.0,
+        'sku' => 'TK-123'
+      })
+    end
+
+    it 'devuelve el ID correctamente sin importar dónde esté almacenado (ID aliases)' do
+      p1 = product_class.new(id: '123')
+      p2 = product_class.new(ID: '456')
+      p3 = product_class.new(_id: '789')
+      
+      expect(p1.id).to eq('123')
+      expect(p2.id).to eq('456')
+      expect(p3.id).to eq('789')
+    end
+  end
+end