bug_bunny 4.13.0 → 4.16.0

data/spec/unit/producer_spec.rb

@@ -95,6 +95,31 @@ RSpec.describe BugBunny::Producer do
           messaging_destination_name: 'events_x'
         )
       end
+
+      it 'producer.published incluye duration_s y campos de routing' do
+        request = BugBunny::Request.new('users')
+        request.exchange = 'users_x'
+        request.method = :post
+        request.correlation_id = 'corr-1'
+
+        fake_exchange = double('exchange')
+        allow(session).to receive(:exchange).and_return(fake_exchange)
+        allow(fake_exchange).to receive(:publish)
+
+        producer.fire(request)
+
+        published_event = logged_events.find { |e| e[:event] == 'producer.published' }
+        expect(published_event).not_to be_nil
+        expect(published_event[:level]).to eq(:info)
+        expect(published_event[:kwargs]).to include(
+          method: 'POST',
+          path: 'users',
+          routing_key: 'users',
+          messaging_message_id: 'corr-1'
+        )
+        expect(published_event[:kwargs][:duration_s]).to be_a(Numeric)
+        expect(published_event[:kwargs][:duration_s]).to be >= 0
+      end
     end
 
     describe '#rpc — log events incluyen campos OTel' do
@@ -182,6 +207,28 @@ RSpec.describe BugBunny::Producer do
           messaging_message_id: 'corr-reply-test'
         )
       end
+
+      it 'producer.rpc_response_received incluye duration_s total' do
+        request = BugBunny::Request.new('users')
+        request.exchange = 'users_x'
+        request.method = :get
+
+        allow(rpc_producer).to receive(:ensure_reply_listener!)
+
+        ivar = Concurrent::IVar.new
+        allow(Concurrent::IVar).to receive(:new).and_return(ivar)
+
+        request.correlation_id = 'corr-dur'
+        rpc_producer.instance_variable_get(:@pending_requests)['corr-dur'] = ivar
+
+        Thread.new { ivar.set({ body: '{"ok":true}', headers: {} }) }.join(0.1)
+
+        rpc_producer.rpc(request)
+
+        response_event = logged_events.find { |e| e[:event] == 'producer.rpc_response_received' }
+        expect(response_event[:kwargs][:duration_s]).to be_a(Numeric)
+        expect(response_event[:kwargs][:duration_s]).to be >= 0
+      end
     end
   end
 
@@ -201,6 +248,12 @@ RSpec.describe BugBunny::Producer do
       s = instance_double(BugBunny::Session)
       allow(s).to receive(:exchange).and_return(fake_exchange)
       allow(s).to receive(:channel).and_return(mock_channel)
+      # Return registry stubs: tests que activan `mandatory: true` con `return_raise`
+      # default invocan estos hooks. Devolvemos un event/slot vacío (no return).
+      allow(s).to receive(:register_return_listener) do |_cid|
+        [Concurrent::Event.new, { event: Concurrent::Event.new, info: nil }]
+      end
+      allow(s).to receive(:unregister_return_listener)
       s
     end
 
@@ -252,6 +305,18 @@ RSpec.describe BugBunny::Producer do
       expect(nack_event).to be_nil
     end
 
+    it 'logea producer.confirmed con publish_duration_s, confirm_duration_s y duration_s total' do
+      confirmed_producer.confirmed(build_request)
+
+      ev = logged_events.find { |e| e[:event] == 'producer.confirmed' }
+      expect(ev).not_to be_nil
+      expect(ev[:level]).to eq(:info)
+      expect(ev[:kwargs]).to include(method: 'POST', path: 'acct.start', routing_key: 'acct.start')
+      expect(ev[:kwargs][:publish_duration_s]).to be_a(Numeric)
+      expect(ev[:kwargs][:confirm_duration_s]).to be_a(Numeric)
+      expect(ev[:kwargs][:duration_s]).to be_a(Numeric)
+    end
+
     context 'cuando el broker NACKea (wait_for_confirms devuelve false)' do
       before do
         allow(mock_channel).to receive(:wait_for_confirms).and_return(false)
@@ -325,5 +390,206 @@ RSpec.describe BugBunny::Producer do
       expect { confirmed_producer.confirmed(build_request) }
         .to raise_error(BugBunny::CommunicationError, 'chan dead')
     end
+
+    describe 'return_raise (basic.return + mandatory)' do
+      # Dispara el `basic.return` desde el reader-thread simulado. El stub de
+      # wait_for_confirms invoca este lambda *antes* de retornar true, simulando
+      # el orden AMQP wire: return precede al ack.
+      def stub_return_during_wait(producer, return_info)
+        allow(mock_channel).to receive(:wait_for_confirms) do
+          props = double('properties', correlation_id: producer_pending_cid(producer))
+          producer.instance_variable_get(:@session)
+                  .send(:handle_broker_return, return_info, props, 'payload')
+          true
+        end
+      end
+
+      def producer_pending_cid(producer)
+        session = producer.instance_variable_get(:@session)
+        registry = session.instance_variable_get(:@pending_returns)
+        cids = []
+        registry.each_pair { |cid, _slot| cids << cid }
+        cids.first
+      end
+
+      let(:return_info) do
+        Struct.new(:reply_code, :reply_text, :exchange, :routing_key)
+              .new(312, 'NO_ROUTE', 'acct_x', 'acct.unbound')
+      end
+
+      let(:real_session) do
+        s = BugBunny::Session.new(BunnyMocks::FakeConnection.new(true, mock_channel))
+        allow(s).to receive(:channel).and_return(mock_channel)
+        allow(s).to receive(:exchange).and_return(fake_exchange)
+        s
+      end
+
+      let(:return_producer) do
+        p = described_class.new(real_session)
+        allow(p).to receive(:safe_log) do |level, event, **kwargs|
+          logged_events << { level: level, event: event, kwargs: kwargs }
+        end
+        p
+      end
+
+      before do
+        BugBunny.configuration.on_return = nil
+      end
+
+      after do
+        BugBunny.configuration.on_return = nil
+      end
+
+      def build_mandatory_request
+        req = BugBunny::Request.new('acct.start')
+        req.exchange = 'acct_x'
+        req.method = :post
+        req.body = { tenant: 42 }
+        req.mandatory = true
+        req
+      end
+
+      it 'levanta PublishUnroutable cuando llega basic.return + ack y mandatory:true (default)' do
+        stub_return_during_wait(return_producer, return_info)
+
+        req = build_mandatory_request
+
+        expect { return_producer.confirmed(req) }.to raise_error(BugBunny::PublishUnroutable) do |err|
+          expect(err.path).to eq('acct.start')
+          expect(err.exchange).to eq('acct_x')
+          expect(err.routing_key).to eq('acct.unbound')
+          expect(err.reply_code).to eq(312)
+          expect(err.reply_text).to eq('NO_ROUTE')
+          expect(err.correlation_id).to eq(req.correlation_id)
+        end
+      end
+
+      it 'logea producer.publish_unroutable antes de levantar' do
+        stub_return_during_wait(return_producer, return_info)
+
+        expect { return_producer.confirmed(build_mandatory_request) }
+          .to raise_error(BugBunny::PublishUnroutable)
+
+        ev = logged_events.find { |e| e[:event] == 'producer.publish_unroutable' }
+        expect(ev).not_to be_nil
+        expect(ev[:level]).to eq(:warn)
+        expect(ev[:kwargs]).to include(
+          path: 'acct.start',
+          exchange: 'acct_x',
+          routing_key: 'acct.unbound',
+          reply_code: 312
+        )
+      end
+
+      it 'auto-asigna correlation_id cuando falta y return_raise está activo' do
+        stub_return_during_wait(return_producer, return_info)
+        req = build_mandatory_request
+        expect(req.correlation_id).to be_nil
+
+        expect { return_producer.confirmed(req) }.to raise_error(BugBunny::PublishUnroutable)
+        expect(req.correlation_id).to be_a(String)
+        expect(req.correlation_id).not_to be_empty
+      end
+
+      it 'limpia el listener del registry tras un return (no leak)' do
+        stub_return_during_wait(return_producer, return_info)
+        req = build_mandatory_request
+
+        expect { return_producer.confirmed(req) }.to raise_error(BugBunny::PublishUnroutable)
+
+        registry = real_session.instance_variable_get(:@pending_returns)
+        expect(registry.size).to eq(0)
+      end
+
+      it 'limpia el listener del registry tras un ack normal sin return' do
+        # mock_channel.wait_for_confirms default ya devuelve true sin disparar return
+        req = build_mandatory_request
+        result = return_producer.confirmed(req)
+
+        expect(result).to eq('status' => 202, 'body' => nil)
+        registry = real_session.instance_variable_get(:@pending_returns)
+        expect(registry.size).to eq(0)
+      end
+
+      it 'limpia el listener del registry tras timeout en wait_for_confirms' do
+        allow(mock_channel).to receive(:wait_for_confirms) {
+          sleep 1
+          true
+        }
+
+        req = build_mandatory_request
+        req.confirm_timeout = 0.05
+
+        expect { return_producer.confirmed(req) }.to raise_error(BugBunny::RequestTimeout)
+        registry = real_session.instance_variable_get(:@pending_returns)
+        expect(registry.size).to eq(0)
+      end
+
+      it 'no levanta cuando el request override `return_raise: false`' do
+        # No stub de return — el listener no se registra siquiera.
+        req = build_mandatory_request
+        req.return_raise = false
+
+        result = return_producer.confirmed(req)
+        expect(result).to eq('status' => 202, 'body' => nil)
+        # Sin listener registrado (flag off) → no hubo set up
+        registry = real_session.instance_variable_get(:@pending_returns)
+        expect(registry.size).to eq(0)
+      end
+
+      it 'no levanta cuando la config global tiene return_raise=false (aunque mandatory esté on)' do
+        allow(BugBunny.configuration).to receive(:return_raise).and_return(false)
+
+        req = build_mandatory_request
+        result = return_producer.confirmed(req)
+
+        expect(result).to eq('status' => 202, 'body' => nil)
+      end
+
+      it 'override per-request gana sobre la config global' do
+        allow(BugBunny.configuration).to receive(:return_raise).and_return(false)
+        stub_return_during_wait(return_producer, return_info)
+
+        req = build_mandatory_request
+        req.return_raise = true
+
+        expect { return_producer.confirmed(req) }.to raise_error(BugBunny::PublishUnroutable)
+      end
+
+      it 'flag inerte cuando mandatory:false aunque return_raise=true' do
+        req = BugBunny::Request.new('acct.start')
+        req.exchange = 'acct_x'
+        req.method = :post
+        req.body = { tenant: 42 }
+        req.mandatory = false
+        req.return_raise = true
+
+        result = return_producer.confirmed(req)
+        expect(result).to eq('status' => 202, 'body' => nil)
+        registry = real_session.instance_variable_get(:@pending_returns)
+        expect(registry.size).to eq(0)
+      end
+
+      it 'invoca el callback global on_return antes de levantar PublishUnroutable' do
+        captured = nil
+        BugBunny.configuration.on_return = lambda { |ri, _props, _body|
+          captured = { rk: ri.routing_key }
+        }
+
+        stub_return_during_wait(return_producer, return_info)
+
+        expect { return_producer.confirmed(build_mandatory_request) }
+          .to raise_error(BugBunny::PublishUnroutable)
+        expect(captured).to eq(rk: 'acct.unbound')
+      end
+
+      it 'levanta PublishUnroutable aunque el user_cb on_return explote' do
+        BugBunny.configuration.on_return = ->(_, _, _) { raise 'boom in user cb' }
+        stub_return_during_wait(return_producer, return_info)
+
+        expect { return_producer.confirmed(build_mandatory_request) }
+          .to raise_error(BugBunny::PublishUnroutable)
+      end
+    end
   end
 end

data/spec/unit/request_spec.rb

@@ -76,5 +76,21 @@ RSpec.describe BugBunny::Request do
       expect(req.mandatory).to be(true)
       expect(req.confirm_timeout).to eq(0.5)
     end
+
+    it 'tiene return_raise=nil por defecto (delega a config global)' do
+      req = described_class.new('foo')
+
+      expect(req.return_raise).to be_nil
+    end
+
+    it 'permite asignar return_raise' do
+      req = described_class.new('foo')
+
+      req.return_raise = false
+      expect(req.return_raise).to be(false)
+
+      req.return_raise = true
+      expect(req.return_raise).to be(true)
+    end
   end
 end

data/spec/unit/session_spec.rb

@@ -151,6 +151,78 @@ RSpec.describe BugBunny::Session do
     end
   end
 
+  describe '#register_return_listener / #unregister_return_listener' do
+    let(:properties_for) do
+      ->(cid) { double('properties', correlation_id: cid) }
+    end
+
+    let(:return_info) do
+      Struct.new(:reply_code, :reply_text, :exchange, :routing_key)
+            .new(312, 'NO_ROUTE', 'evt_x', 'rk')
+    end
+
+    before do
+      BugBunny.configuration.on_return = nil
+    end
+
+    after do
+      BugBunny.configuration.on_return = nil
+    end
+
+    it 'devuelve un Concurrent::Event y un slot que se setean al disparar el return' do
+      event, slot = session.register_return_listener('corr-1')
+
+      expect(event).to be_a(Concurrent::Event)
+      expect(slot[:info]).to be_nil
+
+      session.send(:handle_broker_return, return_info, properties_for.call('corr-1'), 'payload')
+
+      expect(event.set?).to be(true)
+      expect(slot[:info]).to eq(return_info)
+    end
+
+    it 'no toca otros listeners cuando llega un return de otro correlation_id' do
+      event_a, slot_a = session.register_return_listener('corr-A')
+      event_b, slot_b = session.register_return_listener('corr-B')
+
+      session.send(:handle_broker_return, return_info, properties_for.call('corr-A'), 'p')
+
+      expect(event_a.set?).to be(true)
+      expect(slot_a[:info]).to eq(return_info)
+      expect(event_b.set?).to be(false)
+      expect(slot_b[:info]).to be_nil
+    end
+
+    it 'ignora returns sin correlation_id en properties' do
+      event, slot = session.register_return_listener('corr-1')
+      props = double('properties', correlation_id: nil)
+
+      expect { session.send(:handle_broker_return, return_info, props, 'p') }.not_to raise_error
+      expect(event.set?).to be(false)
+      expect(slot[:info]).to be_nil
+    end
+
+    it '#unregister_return_listener limpia el slot del registry' do
+      session.register_return_listener('corr-1')
+      session.unregister_return_listener('corr-1')
+
+      registry = session.instance_variable_get(:@pending_returns)
+      expect(registry['corr-1']).to be_nil
+    end
+
+    it 'setea el event ANTES de invocar el callback global on_return (resiliencia a user_cb que explota)' do
+      BugBunny.configuration.on_return = ->(_, _, _) { raise 'boom in user callback' }
+
+      event, slot = session.register_return_listener('corr-1')
+
+      expect { session.send(:handle_broker_return, return_info, properties_for.call('corr-1'), 'p') }
+        .not_to raise_error
+
+      expect(event.set?).to be(true)
+      expect(slot[:info]).to eq(return_info)
+    end
+  end
+
   describe '#close' do
     it 'cierra el canal y lo nilifica' do
       session.channel

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 4.13.0
+  version: 4.16.0
 platform: ruby
 authors:
 - gabix
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-11 00:00:00.000000000 Z
+date: 2026-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -275,6 +275,7 @@ files:
 - spec/integration/controller_spec.rb
 - spec/integration/error_handling_spec.rb
 - spec/integration/infrastructure_spec.rb
+- spec/integration/publisher_confirms_spec.rb
 - spec/integration/resource_spec.rb
 - spec/spec_helper.rb
 - spec/support/bunny_mocks.rb
@@ -303,7 +304,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.13.0/skill
+  documentation_uri: https://github.com/gedera/bug_bunny/blob/v4.16.0/skill
 post_install_message:
 rdoc_options: []
 require_paths: