bug_bunny 4.6.1 → 4.8.0

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

data/spec/unit/session_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/bunny_mocks'
+
+RSpec.describe BugBunny::Session do
+  include BunnyMocks
+
+  let(:channel)    { BunnyMocks::FakeChannel.new(false).tap { |c| c.open = true } }
+  let(:connection) { BunnyMocks::FakeConnection.new(true, channel) }
+  let(:session)    { described_class.new(connection) }
+
+  describe '#channel' do
+    context 'cuando el canal está abierto' do
+      it 'retorna el canal existente sin crear uno nuevo (fast path)' do
+        first  = session.channel
+        second = session.channel
+        expect(second).to be(first)
+      end
+    end
+
+    context 'cuando el canal está cerrado' do
+      it 'crea un canal nuevo' do
+        session.channel # inicializa
+
+        new_channel = BunnyMocks::FakeChannel.new(true)
+        session.instance_variable_get(:@channel).open = false
+        connection.channel_to_return = new_channel
+
+        expect(session.channel).to be(new_channel)
+      end
+    end
+
+    context 'con múltiples threads simultáneos' do
+      it 'llama a create_channel! exactamente una vez aunque varios threads compitan' do
+        fresh_session = described_class.new(connection)
+        create_count  = Concurrent::AtomicFixnum.new(0)
+
+        fresh_session.define_singleton_method(:create_channel!) do
+          create_count.increment
+          super()
+        end
+
+        threads = 10.times.map { Thread.new { fresh_session.channel } }
+        threads.each(&:join)
+
+        expect(create_count.value).to eq(1)
+      end
+    end
+
+    context 'cuando la conexión está cerrada' do
+      it 'reconecta transparentemente' do
+        closed_conn = BunnyMocks::FakeConnection.new(false, channel)
+        s = described_class.new(closed_conn)
+
+        s.channel
+
+        expect(closed_conn.open?).to be(true)
+      end
+
+      it 'lanza CommunicationError si la reconexión falla' do
+        bad_conn = BunnyMocks::FakeConnection.new(false, channel)
+        bad_conn.define_singleton_method(:start) { raise RuntimeError, 'refused' }
+
+        s = described_class.new(bad_conn)
+
+        expect { s.channel }.to raise_error(BugBunny::CommunicationError)
+      end
+    end
+  end
+
+  describe '#close' do
+    it 'cierra el canal y lo nilifica' do
+      session.channel
+      session.close
+
+      expect(session.instance_variable_get(:@channel)).to be_nil
+    end
+
+    it 'es idempotente — no explota si se llama dos veces' do
+      session.channel
+      session.close
+      expect { session.close }.not_to raise_error
+    end
+
+    it 'es thread-safe junto con #channel' do
+      errors = []
+
+      threads = [
+        Thread.new { 10.times { session.channel rescue nil } },
+        Thread.new { 10.times { session.close   rescue nil } }
+      ]
+      threads.each(&:join)
+
+      expect(errors).to be_empty
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 4.6.1
+  version: 4.8.0
 platform: ruby
 authors:
 - gabix
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-03-31 00:00:00.000000000 Z
+date: 2026-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -229,9 +229,36 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".agents/skills/rabbitmq-expert/SKILL.md"
+- ".claude/commands/gem-ai-setup.md"
+- ".claude/commands/pr.md"
+- ".claude/commands/release.md"
+- ".claude/commands/rubocop.md"
+- ".claude/commands/service-ai-setup.md"
+- ".claude/commands/test.md"
+- ".claude/commands/yard.md"
 - CHANGELOG.md
+- CLAUDE.md
 - README.md
 - Rakefile
+- docs/_index.md
+- docs/ai/_index.md
+- docs/ai/antipatterns.md
+- docs/ai/api.md
+- docs/ai/architecture.md
+- docs/ai/errors.md
+- docs/ai/faq_external.md
+- docs/ai/faq_internal.md
+- docs/ai/glossary.md
+- docs/concepts.md
+- docs/howto/controller.md
+- docs/howto/middleware_client.md
+- docs/howto/middleware_consumer.md
+- docs/howto/rails.md
+- docs/howto/resource.md
+- docs/howto/routing.md
+- docs/howto/testing.md
+- docs/howto/tracing.md
 - initializer_example.rb
 - lib/bug_bunny.rb
 - lib/bug_bunny/client.rb
@@ -255,7 +282,26 @@ files:
 - lib/bug_bunny/version.rb
 - lib/generators/bug_bunny/install/install_generator.rb
 - lib/generators/bug_bunny/install/templates/initializer.rb
-- sig/bug_bunny.rbs
+- lib/tasks/bug_bunny.rake
+- plan_test.txt
+- skills-lock.json
+- spec/integration/client_spec.rb
+- spec/integration/consumer_middleware_spec.rb
+- spec/integration/controller_spec.rb
+- spec/integration/error_handling_spec.rb
+- spec/integration/infrastructure_spec.rb
+- spec/integration/resource_spec.rb
+- spec/spec_helper.rb
+- spec/support/bunny_mocks.rb
+- spec/support/integration_helper.rb
+- spec/unit/client_session_pool_spec.rb
+- spec/unit/configuration_spec.rb
+- spec/unit/consumer_middleware_spec.rb
+- spec/unit/consumer_spec.rb
+- spec/unit/controller_after_action_spec.rb
+- spec/unit/observability_spec.rb
+- spec/unit/resource_attributes_spec.rb
+- spec/unit/session_spec.rb
 - test/integration/infrastructure_test.rb
 - test/integration/manual_client_test.rb
 - test/test_helper.rb
@@ -266,6 +312,7 @@ metadata:
   homepage_uri: https://github.com/gedera/bug_bunny
   source_code_uri: https://github.com/gedera/bug_bunny
   changelog_uri: https://github.com/gedera/bug_bunny/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/gedera/bug_bunny/blob/v4.8.0/docs
 post_install_message:
 rdoc_options: []
 require_paths:

data/sig/bug_bunny.rbs

@@ -1,4 +0,0 @@
-module BugBunny
-  VERSION: String
-  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-end