bug_bunny 4.6.1 → 4.8.0

data/lib/tasks/bug_bunny.rake

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'date'
+
+namespace :bug_bunny do
+  desc 'Sync BugBunny AI docs reference in CLAUDE.md with the installed version'
+  task :sync do
+    spec = Gem::Specification.find_by_name('bug_bunny')
+    version = spec.version.to_s
+    docs_path = File.join(spec.gem_dir, 'docs', 'ai')
+    claude_md_path = File.join(Dir.pwd, 'CLAUDE.md')
+
+    content = if File.exist?(claude_md_path)
+                File.read(claude_md_path)
+              else
+                app_name = File.basename(Dir.pwd).split(/[-_]/).map(&:capitalize).join
+                puts 'bug_bunny:sync — CLAUDE.md not found, creating it.'
+                "# #{app_name}\n"
+              end
+
+    # Idempotent: same version already present, nothing to do
+    if content.include?('### bug_bunny') && content.include?("**Version:** #{version}")
+      puts "bug_bunny:sync — already at #{version}, nothing to do."
+      next
+    end
+
+    block = <<~BLOCK
+      ### bug_bunny
+      - **Version:** #{version}
+      - **Docs:** #{docs_path}
+      - **Updated:** #{Date.today}
+    BLOCK
+
+    # Replace existing block if present
+    if content.match?(/^### bug_bunny\n/)
+      updated = content.gsub(/^### bug_bunny\n(?:- \*\*.*\n)*/, block)
+      File.write(claude_md_path, updated)
+      puts "bug_bunny:sync — updated to #{version} in CLAUDE.md"
+    elsif content.include?('## Gemas internas')
+      # Append under existing section
+      updated = content.sub(/^## Gemas internas\n/, "## Gemas internas\n\n#{block}")
+      File.write(claude_md_path, updated)
+      puts "bug_bunny:sync — added #{version} under '## Gemas internas' in CLAUDE.md"
+    else
+      # Create section at end of file
+      File.write(claude_md_path, content.rstrip + "\n\n## Gemas internas\n\n#{block}")
+      puts "bug_bunny:sync — added '## Gemas internas' section with #{version} to CLAUDE.md"
+    end
+  end
+end

data/plan_test.txt

@@ -0,0 +1,63 @@
+📋 Plan de Testing: BugBunny v3.1 (Extendido)
+🟢 Nivel 0: Infraestructura (Los Cimientos)
+Test 0.0: test_helper capaz de levantar consumers con Exchanges Direct, Topic y Fanout.
+
+Test 0.1: Control de "Namespace" dinámico en los tests para evitar colisión de nombres de clase.
+
+🔵 Nivel 1: El Recurso (Resource ORM)
+Test 1.1: CRUD Completo (Create, Find, Update) con Exchange Topic (Default).
+
+Test 1.2: Manejo de Errores (404, 500, Timeout).
+
+Test 1.3: Resource.where con filtros anidados (Query String).
+
+🟠 Nivel 2: Cliente Manual (Publisher Mode)
+Este nivel prueba el uso de la gema como un cliente RabbitMQ puro, sin la magia de Active Record.
+
+Test 2.1 (Fire-and-Forget):
+
+Usar client.publish('logs.error', body: { msg: 'Crash' }).
+
+Verificar que el mensaje llega a la cola sin esperar respuesta.
+
+Test 2.2 (RPC Manual):
+
+Usar client.request('users/123', method: :get).
+
+Verificar que devuelve un hash parseado y maneja el timeout.
+
+Test 2.3 (Raw Bytes):
+
+Enviar un string crudo (no JSON) y verificar que llega intacto.
+
+🟣 Nivel 3: Topologías de Exchange (Routing Complejo)
+Aquí probamos que la gema respeta las reglas de RabbitMQ.
+
+Test 3.1 (Topic Wildcards):
+
+Worker escucha en notifications.*.
+
+Cliente envía a notifications.email y notifications.sms.
+
+Verificar que ambos llegan.
+
+Test 3.2 (Direct Strict):
+
+Worker escucha en orders_queue (Direct).
+
+Cliente envía con routing key incorrecta.
+
+Verificar que NO llega (o se va a Dead Letter si hubiera).
+
+Test 3.3 (Fanout Broadcast):
+
+Levantar 2 Workers escuchando el mismo Exchange Fanout.
+
+Cliente publica 1 mensaje.
+
+Verificar que AMBOS workers reciben el mensaje.
+
+🟡 Nivel 4: Observabilidad y Middlewares
+Test 4.1 (Tracing): Inyección y propagación de correlation_id (Cliente Manual -> Worker).
+
+Test 4.2 (Middleware Chain): Verificar que un middleware puede modificar el body antes de salir.

data/skills-lock.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "skills": {
+    "rabbitmq-expert": {
+      "source": "martinholovsky/claude-skills-generator",
+      "sourceType": "github",
+      "computedHash": "584e368d2811078acfb437c22ca07f1c93da52cbdcabcc8c24562128185c4b6b"
+    }
+  }
+}

data/spec/integration/client_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/integration_helper'
+
+module ClientSpec
+  class EchoController < BugBunny::Controller
+    def index
+      render status: 200, json: { received: params[:message], via: 'ClientSpec::EchoController' }
+    end
+  end
+end
+
+RSpec.describe BugBunny::Client, :integration do
+  let(:queue)    { unique('client_q') }
+  let(:exchange) { unique('client_x') }
+  let(:client)   { described_class.new(pool: TEST_POOL) }
+
+  before { BugBunny.configure { |c| c.controller_namespace = 'ClientSpec' } }
+  after  { BugBunny.configure { |c| c.controller_namespace = 'BugBunny::Controllers' } }
+
+  describe '#publish' do
+    context 'con exchange topic' do
+      it 'entrega el mensaje con el routing key correcto' do
+        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: { level: 'error' })
+
+          msg = wait_for_message(messages)
+          expect(msg[:routing_key]).to eq('logs.error')
+        end
+      end
+    end
+
+    context 'con exchange direct' do
+      it 'entrega el mensaje al routing key exacto' do
+        with_spy_worker(queue: queue, exchange: exchange, exchange_type: 'direct', routing_key: 'alerts') do |messages|
+          client.publish('alerts', exchange: exchange, exchange_type: 'direct', body: { alert: true })
+
+          msg = wait_for_message(messages)
+          expect(msg[:routing_key]).to eq('alerts')
+        end
+      end
+    end
+
+    context 'con exchange fanout' do
+      it 'entrega el mensaje ignorando el routing key' do
+        with_spy_worker(queue: queue, exchange: exchange, exchange_type: 'fanout', routing_key: '') do |messages|
+          client.publish('cualquier.key', exchange: exchange, exchange_type: 'fanout', body: { data: 1 })
+
+          msg = wait_for_message(messages)
+          expect(msg[:routing_key]).to eq('cualquier.key')
+        end
+      end
+    end
+  end
+
+  describe '#request (RPC)' do
+    context 'con exchange topic' do
+      it 'retorna la respuesta del controlador' do
+        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: 'hello_topic' })
+
+          expect(response['status']).to eq(200)
+          expect(response['body']['received']).to eq('hello_topic')
+        end
+      end
+    end
+
+    context 'con exchange direct' do
+      it 'retorna la respuesta del controlador' do
+        with_running_worker(queue: queue, exchange: exchange, exchange_type: 'direct', routing_key: 'echo') do
+          response = client.request('echo',
+            method: :get, routing_key: 'echo',
+            exchange: exchange, exchange_type: 'direct',
+            body: { message: 'hello_direct' })
+
+          expect(response['status']).to eq(200)
+          expect(response['body']['received']).to eq('hello_direct')
+        end
+      end
+    end
+
+    context 'con exchange fanout' do
+      it 'retorna la respuesta del controlador' do
+        with_running_worker(queue: queue, exchange: exchange, exchange_type: 'fanout', routing_key: '') do
+          response = client.request('echo',
+            method: :get, exchange: exchange, exchange_type: 'fanout',
+            body: { message: 'hello_fanout' })
+
+          expect(response['status']).to eq(200)
+          expect(response['body']['received']).to eq('hello_fanout')
+        end
+      end
+    end
+
+    context 'con exchange_options personalizadas (cascada nivel 3)' do
+      it 'publica sin error PRECONDITION_FAILED' do
+        custom_x = unique('custom_x')
+        conn = BugBunny.create_connection
+        ch   = conn.create_channel
+        ch.direct(custom_x, durable: true, auto_delete: true)
+
+        expect do
+          client.publish('key',
+            exchange: custom_x, exchange_type: 'direct',
+            exchange_options: { durable: true, auto_delete: true },
+            body: { test: true })
+        end.not_to raise_error
+      ensure
+        ch&.exchange_delete(custom_x) rescue nil
+        conn&.close rescue nil
+      end
+    end
+  end
+end

data/spec/integration/consumer_middleware_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/integration_helper'
+
+module MiddlewareSpec
+  class PingController < BugBunny::Controller
+    def index
+      render status: 200, json: { pong: true }
+    end
+  end
+end
+
+# Middleware de prueba que registra las llamadas en un array compartido
+class TrackingMiddleware < BugBunny::ConsumerMiddleware::Base
+  def self.calls
+    @calls ||= []
+  end
+
+  def self.reset!
+    @calls = []
+  end
+
+  def call(delivery_info, properties, body)
+    self.class.calls << {
+      routing_key: delivery_info.routing_key,
+      headers:     properties.headers
+    }
+    @app.call(delivery_info, properties, body)
+  end
+end
+
+RSpec.describe 'Consumer Middleware Stack', :integration do
+  let(:queue)    { unique('middleware_q') }
+  let(:exchange) { unique('middleware_x') }
+  let(:client)   { BugBunny::Client.new(pool: TEST_POOL) }
+
+  before do
+    BugBunny.configure { |c| c.controller_namespace = 'MiddlewareSpec' }
+    TrackingMiddleware.reset!
+    BugBunny.consumer_middlewares.use TrackingMiddleware
+  end
+
+  after do
+    BugBunny.configure { |c| c.controller_namespace = 'BugBunny::Controllers' }
+    # Limpiamos el middleware para no afectar otros specs
+    BugBunny.configuration.instance_variable_set(:@consumer_middlewares,
+      BugBunny::ConsumerMiddleware::Stack.new)
+  end
+
+  it 'ejecuta el middleware antes de process_message' do
+    with_running_worker(queue: queue, exchange: exchange, routing_key: 'ping') do
+      client.request('ping', method: :get, exchange: exchange, exchange_type: 'topic', routing_key: 'ping')
+
+      expect(TrackingMiddleware.calls).not_to be_empty
+      expect(TrackingMiddleware.calls.first[:routing_key]).to eq('ping')
+    end
+  end
+
+  it 'ejecuta el middleware para cada mensaje recibido' do
+    with_running_worker(queue: queue, exchange: exchange, routing_key: 'ping') do
+      3.times { client.request('ping', method: :get, exchange: exchange, exchange_type: 'topic', routing_key: 'ping') }
+
+      expect(TrackingMiddleware.calls.length).to eq(3)
+    end
+  end
+
+  describe 'rpc_reply_headers' do
+    it 'inyecta headers en el reply del consumer' do
+      received_headers = nil
+
+      BugBunny.configuration.rpc_reply_headers = -> { { 'X-Test-Header' => 'from-consumer' } }
+      BugBunny.configuration.on_rpc_reply = ->(headers) { received_headers = headers }
+
+      with_running_worker(queue: queue, exchange: exchange, routing_key: 'ping') do
+        client.request('ping', method: :get, exchange: exchange, exchange_type: 'topic', routing_key: 'ping')
+      end
+
+      expect(received_headers).not_to be_nil
+      expect(received_headers['X-Test-Header']).to eq('from-consumer')
+    ensure
+      BugBunny.configuration.rpc_reply_headers = nil
+      BugBunny.configuration.on_rpc_reply      = nil
+    end
+  end
+end

data/spec/integration/controller_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/integration_helper'
+
+module ControllerSpec
+  class PingController < BugBunny::Controller
+    before_action :set_user
+
+    def index
+      render status: 200, json: { pong: true, user: @user }
+    end
+
+    def show
+      render status: 200, json: { id: params[:id], user: @user }
+    end
+
+    def create
+      render status: 201, json: { created: params[:name] }
+    end
+
+    private
+
+    def set_user
+      @user = 'test_user'
+    end
+  end
+
+  class AroundController < BugBunny::Controller
+    around_action :wrap_with_timing
+
+    def index
+      render status: 200, json: { action: 'index' }
+    end
+
+    private
+
+    def wrap_with_timing
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      yield
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+      # Solo verificamos que el around_action ejecutó el bloque
+      raise 'negative elapsed' if elapsed < 0
+    end
+  end
+
+  class RescueController < BugBunny::Controller
+    rescue_from StandardError, with: :handle_error
+
+    def index
+      raise ArgumentError, 'something went wrong'
+    end
+
+    private
+
+    def handle_error(e)
+      render status: 422, json: { error: e.message }
+    end
+  end
+
+  class NodeController < BugBunny::Controller
+    def index
+      nodes = params[:q] ? [{ status: params[:q][:status] }] : []
+      render status: 200, json: nodes
+    end
+
+    def show
+      render status: 200, json: { id: params[:id] }
+    end
+
+    def create
+      render status: 201, json: { node: params[:name] }
+    end
+
+    def update
+      render status: 200, json: { id: params[:id], updated: true }
+    end
+
+    def destroy
+      render status: 200, json: { id: params[:id], deleted: true }
+    end
+  end
+end
+
+RSpec.describe BugBunny::Controller, :integration do
+  let(:queue)    { unique('controller_q') }
+  let(:exchange) { unique('controller_x') }
+  let(:client)   { BugBunny::Client.new(pool: TEST_POOL) }
+
+  before { BugBunny.configure { |c| c.controller_namespace = 'ControllerSpec' } }
+  after  { BugBunny.configure { |c| c.controller_namespace = 'BugBunny::Controllers' } }
+
+  describe 'before_action' do
+    it 'ejecuta el callback antes de la acción y expone la variable de instancia' do
+      with_running_worker(queue: queue, exchange: exchange) do
+        response = client.request('ping',
+          method: :get, exchange: exchange, exchange_type: 'topic', routing_key: 'ping')
+
+        expect(response['status']).to eq(200)
+        expect(response['body']['user']).to eq('test_user')
+      end
+    end
+  end
+
+  describe 'around_action' do
+    it 'envuelve la acción y la ejecuta correctamente' do
+      with_running_worker(queue: queue, exchange: exchange, routing_key: 'around') do
+        response = client.request('around',
+          method: :get, exchange: exchange, exchange_type: 'topic', routing_key: 'around')
+
+        expect(response['status']).to eq(200)
+        expect(response['body']['action']).to eq('index')
+      end
+    end
+  end
+
+  describe 'rescue_from' do
+    it 'captura la excepción y retorna la respuesta del handler' do
+      with_running_worker(queue: queue, exchange: exchange, routing_key: 'rescue') do
+        response = client.request('rescue',
+          method: :get, exchange: exchange, exchange_type: 'topic', routing_key: 'rescue')
+
+        expect(response['status']).to eq(422)
+        expect(response['body']['error']).to eq('something went wrong')
+      end
+    end
+  end
+
+  describe 'params desde query string' do
+    it 'parsea los params del path y los expone en el controlador' do
+      with_running_worker(queue: queue, exchange: exchange) do
+        response = client.request('ping/42',
+          method: :get, exchange: exchange, exchange_type: 'topic')
+
+        expect(response['status']).to eq(200)
+        expect(response['body']['id']).to eq('42')
+      end
+    end
+  end
+end

data/spec/integration/error_handling_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'support/integration_helper'
+
+module ErrorSpec
+  class BoomController < BugBunny::Controller
+    def index
+      raise StandardError, 'boom interno'
+    end
+  end
+end
+
+RSpec.describe 'Error handling', :integration do
+  let(:queue)    { unique('error_q') }
+  let(:exchange) { unique('error_x') }
+  let(:client)   { BugBunny::Client.new(pool: TEST_POOL) }
+
+  before { BugBunny.configure { |c| c.controller_namespace = 'ErrorSpec' } }
+  after  { BugBunny.configure { |c| c.controller_namespace = 'BugBunny::Controllers' } }
+
+  describe '404 — ruta no encontrada' do
+    it 'retorna status 404 cuando no hay ruta para el path' do
+      with_running_worker(queue: queue, exchange: exchange, routing_key: 'boom') do
+        response = client.request('ruta_inexistente',
+          method: :get, exchange: exchange, exchange_type: 'topic', routing_key: 'boom')
+
+        expect(response['status']).to eq(404)
+      end
+    end
+  end
+
+  describe '404 — controlador no encontrado' do
+    it 'retorna status 404 cuando el controlador no existe en el namespace' do
+      BugBunny.configure { |c| c.controller_namespace = 'NamespaceQueNoExiste' }
+
+      with_running_worker(queue: queue, exchange: exchange, routing_key: 'boom') do
+        response = client.request('boom',
+          method: :get, exchange: exchange, exchange_type: 'topic', routing_key: 'boom')
+
+        expect(response['status']).to eq(404)
+      end
+    end
+  end
+
+  describe '500 — excepción en el controlador' do
+    it 'retorna status 500 cuando el controlador lanza una excepción no manejada' do
+      with_running_worker(queue: queue, exchange: exchange, routing_key: 'boom') do
+        response = client.request('boom',
+          method: :get, exchange: exchange, exchange_type: 'topic', routing_key: 'boom')
+
+        expect(response['status']).to eq(500)
+        expect(response['body']['error']).to eq('Internal Server Error')
+      end
+    end
+  end
+end

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