bug_bunny 2.0.2 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fccb3590fd16133119a7e2cea4c05002964846ac5a35e0714925f2d87115a06
-  data.tar.gz: 839ab64bb406eebee8e59f99c010c640a033dab15cd0f531e66f0fbc1e201c82
+  metadata.gz: 730ae48562650742b536036de0db8b811efa48855790ef08bffc15713867654e
+  data.tar.gz: c4d16c6b17307831dd9cfc3be7ef2f78ecc52254034ded5187b2a19f00490aa3
 SHA512:
-  metadata.gz: 4be8016e660aec70394814ffc85ecba71759aeb94df817abac412c201685ebee89c447fdd76b9904dfb5d2bc5f73e208ed0eed2d9bbc016a307c09978254c76e
-  data.tar.gz: 741552a099ae0aadb5717cb46fc4ff24c77c9f31f7dae677131dc158f784a75bca1a739bb6cf65eba42bff84fba853d25a2df54ca0d5884a23f679fa72c679b0
+  metadata.gz: 5551a1bff89d318faf4155dead6e042ac991b57a30459efa2bfcad9029191b12391e6e058e275dda39bdaa4ed7cd2413e46ececa048905836009e4294b8d85e2
+  data.tar.gz: dd6af676b128f77d01c885d1107b773080d3ebd80b0a49477f3f6d4db511f91acdf8d2775281fa4cae529e17161cf7180caf41c983aece183112f6ab93fedf69

data/CHANGELOG.md

@@ -1,3 +1,40 @@
 # Changelog
+
+## [3.0.1] - 2026-02-10
+
+### 🚀 Features: RESTful Architecture
+* **HTTP Verbs over AMQP:** Implemented support for semantic HTTP verbs (`GET`, `POST`, `PUT`, `DELETE`) within AMQP headers (`x-http-method`). This enables a true RESTful design over RabbitMQ.
+* **Smart Router:** The `BugBunny::Consumer` now behaves like a Rails Router. It automatically infers the controller action based on the combination of the **Verb** and the **URL Path** (e.g., `GET users/1` dispatches to `show`, `POST users` to `create`).
+* **Resource CRUD Mapping:** `BugBunny::Resource` now maps Ruby operations to their specific REST verbs:
+    * `create` -> `POST`
+    * `update` -> `PUT`
+    * `destroy` -> `DELETE`
+    * `find/where` -> `GET`.
+
+### 🛠 Improvements
+* **Client API:** Updated `BugBunny::Client#request` and `#publish` to accept a `method:` argument (e.g., `client.request('users', method: :post)`), giving developers full control over the request semantics without changing the method signature.
+* **Request Metadata:** `BugBunny::Request` now handles the `method` attribute and ensures it is properly injected into the AMQP headers for the consumer to read.
+
+## [3.0.0] - 2026-02-05
+
+### ⚠ Breaking Changes
+* **Architecture Overhaul:** Complete rewrite implementing the "Active Record over AMQP" philosophy. The framework now simulates a RESTful architecture where messages contain "URLs" (via `type` header) that map to Controllers.
+* **Resource Configuration:** Removed `routing_key_prefix` in favor of `resource_name`. By default, `resource_name` is now automatically pluralized (Rails-style) to determine routing keys and headers.
+* **Schema-less Resources:** Removed strict `ActiveModel::Attributes` dependency. `BugBunny::Resource` no longer requires defining attributes manually. It now uses a dynamic storage (`@remote_attributes`) supporting arbitrary keys (including PascalCase for Docker APIs) via `method_missing`.
+
+### 🚀 New Features
+* **Middleware Stack:** Implemented an "Onion Architecture" for the `Client` similar to Faraday. Added support for middleware chains to intercept requests/responses.
+    * `Middleware::JsonResponse`: Automatically parses JSON bodies and provides `IndifferentAccess`.
+    * `Middleware::RaiseError`: Maps AMQP/HTTP status codes to Ruby exceptions (e.g., 404 to `BugBunny::NotFound`).
+* **REST-over-AMQP Routing:** The `Consumer` now parses the `type` header as a URL (e.g., `users/show/12?active=true`) to dispatch actions to specific Controllers.
+* **Direct Reply-To RPC:** Optimized RPC calls to use RabbitMQ's native `amq.rabbitmq.reply-to` feature, eliminating the need for temporary reply queues and improving performance.
+* **Config Inheritance:** `BugBunny::Resource` configurations (like `connection_pool`, `exchange`) are now inherited by child classes, simplifying setup for groups of models.
+
+### 🛠 Improvements
+* **Connection Pooling:** Full integration with `connection_pool` to ensure thread safety in multi-threaded environments (Puma/Sidekiq).
+* **Error Handling:** Unified exception hierarchy under `BugBunny::Error`, with specific classes for Client (4xx) and Server (5xx) errors.
+* **Rails Integration:** Added `Railtie` with hooks for Puma and Spring to safely handle connection forks.
+* **Documentation:** Added comprehensive YARD documentation for all core classes.
+
 ## Version 0.1.0
-Migration bunny logic from utils
+* Migration bunny logic from utils

data/README.md

@@ -1,183 +1,315 @@
-# BugBunny
+# 🐰 BugBunny
 
-## Configuration
+**BugBunny** es un framework RPC para Ruby on Rails sobre **RabbitMQ**.
+
+Su filosofía es **"Active Record over AMQP"**. Abstrae la complejidad de colas y exchanges transformando patrones de mensajería en una arquitectura **RESTful simulada**.
+
+A diferencia de otros clientes de RabbitMQ, BugBunny viaja con **Verbos HTTP** (`GET`, `POST`, `PUT`, `DELETE`) inyectados en los headers AMQP. Esto permite construir una API semántica donde un **Router Inteligente** despacha los mensajes a controladores Rails estándar.
+
+---
+
+## 📦 Instalación
+
+Agrega la gema a tu `Gemfile`:
+
+```ruby
+gem 'bug_bunny'
+```
+
+Ejecuta el bundle:
+
+```bash
+bundle install
+```
+
+Corre el instalador para generar la configuración inicial:
+
+```bash
+rails g bug_bunny:install
+```
+
+---
+
+## ⚙️ Configuración
+
+Configura tus credenciales y el Pool de conexiones en el inicializador `config/initializers/bug_bunny.rb`.
 
 ```ruby
-config/initializers/bug_bunny.rb
 BugBunny.configure do |config|
-  config.host = 'Host'
-  config.username = 'Username'
-  config.password = 'Password'
-  config.vhost = '/'
-  config.logger = Rails.logger
-  config.automatically_recover = false
+  config.host     = ENV.fetch('RABBITMQ_HOST', 'localhost')
+  config.username = ENV.fetch('RABBITMQ_USER', 'guest')
+  config.password = ENV.fetch('RABBITMQ_PASS', 'guest')
+  config.vhost    = ENV.fetch('RABBITMQ_VHOST', '/')
+
+  # Timeouts y Recuperación
+  config.rpc_timeout = 10       # Segundos a esperar respuesta síncrona
   config.network_recovery_interval = 5
-  config.connection_timeout = 10
-  config.read_timeout = 30
-  config.write_timeout = 30
-  config.heartbeat = 15
-  config.continuation_timeout = 15_000
 end
+
+# ⚠️ CRÍTICO: Definimos el Pool Global
+# Es vital usar ConnectionPool para garantizar la seguridad en entornos
+# multi-hilo como Puma o Sidekiq.
+BUG_BUNNY_POOL = ConnectionPool.new(size: ENV.fetch('RAILS_MAX_THREADS', 5).to_i, timeout: 5) do
+  BugBunny.create_connection
+end
+
+# Inyectamos el pool por defecto a los recursos
+BugBunny::Resource.connection_pool = BUG_BUNNY_POOL
 ```
 
-## Publish
+---
 
-### Rutas
+## 🚀 Modo Resource (ORM / Active Record)
 
-```
-# config/rabbit_rest.yml
-default: &default
-  healt_check:
-    up: 'healt_check/up'
-  manager:
-      services:
-        index: 'services/index'
-        create: 'services/create'
-        show: 'services/%<id>s/show'
-        update: 'services/%<id>s/update'
-        destroy: 'services/%<id>s/destroy'
-      swarm:
-        info: 'swarm/info'
-        version: 'swarm/version'
-        swarm: 'swarm/swarm'
-      tasks:
-        index: 'tasks/index'
-
-development:
-  <<: *default
-
-test:
-  <<: *default
-
-production:
-  <<: *default
+Define modelos que actúan como proxies de recursos remotos. BugBunny separa la **Lógica de Transporte** (RabbitMQ) de la **Lógica de Aplicación** (Controladores).
+
+### Definición del Modelo
 
+```ruby
+class RemoteUser < BugBunny::Resource
+  # 1. Configuración de Transporte
+  self.exchange = 'app.topic'
+  self.exchange_type = 'topic'
+  
+  # 2. Configuración Lógica (Routing)
+  # Define el nombre del recurso. Se usa para:
+  # - Routing Key automática: 'users' (Topic)
+  # - URL Base: 'users'
+  self.resource_name = 'users'
+
+  # Nota: BugBunny es Schema-less. No necesitas definir atributos.
+  # Soporta acceso dinámico: user.Name, user.email, etc.
+end
 ```
 
-### Configuration
+### Consumiendo el Servicio (CRUD RESTful)
+
+BugBunny traduce automáticamente las llamadas de Ruby a peticiones HTTP simuladas.
 
 ```ruby
-# config/initializers/bug_bunny.rb
-BUG_BUNNY_ENDPOINTS = Rails.application.config_for(:rabbit_rest)
+# --- READ COLLECTION (Index) ---
+# Envia: GET users?active=true
+# Routing Key: "users"
+users = RemoteUser.where(active: true)
+
+# --- READ MEMBER (Show) ---
+# Envia: GET users/123
+# Routing Key: "users"
+user = RemoteUser.find(123)
+puts user.email 
+
+# --- CREATE ---
+# Envia: POST users
+# Routing Key: "users"
+# Body: { "email": "test@test.com", "role": "admin" }
+user = RemoteUser.create(email: "test@test.com", role: "admin")
+
+# --- UPDATE ---
+# Envia: PUT users/123
+# Routing Key: "users"
+user.update(email: "edit@test.com") 
+# Dirty Tracking: Solo se envían los campos modificados.
+
+# --- DESTROY ---
+# Envia: DELETE users/123
+# Routing Key: "users"
+user.destroy
+```
+
+### Estrategias de Routing
+
+Tienes 3 formas de controlar la `routing_key` hacia donde se envían los mensajes:
+
+| Nivel | Método | Descripción | Ejemplo Config |
+| :--- | :--- | :--- | :--- |
+| **1. Dinámico** | `resource_name` | (Por defecto) Usa el nombre del recurso. | `self.resource_name = 'users'` -> Key `users` |
+| **2. Estático** | `routing_key` | Fuerza TODO a una sola cola. | `self.routing_key = 'cola_manager'` |
+| **3. Temporal** | `.with(...)` | Override solo para esa petición. | `User.with(routing_key: 'urgent').create` |
 
-BUNNY_POOL = ConnectionPool.new(size: RABBIT_MAX_THREADS) do
-  BugBunny::Rabbit.create_connection(host: RABBIT_HOST, username: RABBIT_USER, password: RABBIT_PASS, vhost: RABBIT_VIRTUAL_HOST)
+---
+
+## 🔌 Modo Publisher (Cliente Manual)
+
+Si no necesitas mapear un recurso o quieres enviar mensajes crudos, utiliza `BugBunny::Client`. Soporta semántica REST pasando el argumento `method:`.
+
+### 1. Instanciar el Cliente
+
+```ruby
+client = BugBunny::Client.new(pool: BUG_BUNNY_POOL) do |conn|
+  # Puedes inyectar middlewares aquí
+  conn.use BugBunny::Middleware::JsonResponse
 end
 ```
 
-### Publisher
+### 2. Request (RPC Síncrono)
 
-Creamos cualquier clase que herede de `BugBunny::Publisher`, luego definimos metodos de clase y dentro de cada una de ella su implementacion
+Envía el mensaje, **bloquea el hilo** y espera la respuesta JSON. Ideal para obtener datos.
 
-1. Mensajes sincronicos
+```ruby
+# GET (Leer)
+response = client.request('users/123', method: :get)
+puts response['body']
 
-```
-class Rabbit::Publisher::Manager < BugBunny::Publisher
-  ROUTING_KEY = :manager
-  ROUTES = BUG_BUNNY_ENDPOINTS[:manager][:swarm]
+# POST (Crear / Ejecutar)
+response = client.request('math/calc', method: :post, body: { a: 10, b: 20 })
 
-  def self.info(exchange:, message: nil)
-    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:info], message: message)
-    obj.publish_and_consume!
-  end
+# PUT (Actualizar)
+client.request('users/123', method: :put, body: { active: true })
 
-  def self.version(exchange:, message: nil)
-    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:version], message: message)
-    obj.publish_and_consume!
-  end
-end
+# DELETE (Borrar)
+client.request('users/123', method: :delete)
 ```
 
-2. Mensajes Asincronicos
+### 3. Publish (Asíncrono / Fire-and-Forget)
+
+Envía el mensaje y retorna inmediatamente. No espera respuesta. Por defecto usa `method: :post` si no se especifica.
 
+```ruby
+# Enviar log o evento
+client.publish('logs/error', method: :post, body: { msg: 'Disk full' })
 ```
-class Rabbit::Publisher::Manager < BugBunny::Publisher
-  ROUTING_KEY = :manager
-  ROUTES = BUG_BUNNY_ENDPOINTS[:manager][:swarm]
 
-  def self.info(exchange:, message: nil)
-    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:info], message: message)
-    obj.publish!
-  end
+### 4. Configuración Avanzada (Bloques)
 
-  def self.version(exchange:, message: nil)
-    obj = new(pool: NEW_BUNNY_POOL, exchange_name: exchange, action: self::ROUTES[:version], message: message)
-    obj.publish!
-  end
+Puedes usar un bloque para configurar opciones de bajo nivel de AMQP (prioridad, expiración, headers, app_id).
+
+```ruby
+client.publish('jobs/process') do |req|
+  req.method = :post
+  req.body = { image_id: 99 }
+  
+  # Metadatos AMQP
+  req.priority = 9         # Alta prioridad (0-9)
+  req.expiration = '5000'  # TTL 5 segundos (ms)
+  req.app_id = 'web-frontend'
+  req.headers['X-Trace-Id'] = 'abc-123'
 end
 ```
 
-3. Attributes del objeto BugBunny::Publisher
-
-- content_type
-- content_encoding
-- correlation_id
-- reply_to
-- message_id
-- timestamp
-- priority
-- expiration
-- user_id
-- app_id
-- action
-- aguments
-- cluster_id
-- persistent
-- expiration
-
-## Consumer
+### 5. Referencia de Opciones
 
-```
-class Rabbit::Controllers::Application < BugBunny::Controller
-end
+Estas opciones pueden pasarse como argumentos (`client.request(key: val)`) o dentro del bloque (`req.key = val`).
+
+| Opción / Atributo | Tipo | Descripción | Default |
+| :--- | :--- | :--- | :--- |
+| `body` | `Hash/String` | El contenido del mensaje. | `nil` |
+| `method` | `Symbol` | Verbo HTTP (`:get`, `:post`, `:put`, `:delete`). | `:get` (en request) |
+| `exchange` | `String` | Nombre del Exchange destino. | `''` (Default Ex) |
+| `routing_key` | `String` | Clave de ruteo. Si falta, usa el `path`. | `path` |
+| `headers` | `Hash` | Headers personalizados. | `{}` |
+| `timeout` | `Integer` | (Solo RPC) Segundos máx de espera. | Config global |
+| `app_id` | `String` | ID de la aplicación origen. | `nil` |
+| `priority` | `Integer` | Prioridad del mensaje (0-9). | `0` |
+| `expiration` | `String` | TTL del mensaje en ms. | `nil` |
 
-class Rabbit::Controllers::Swarm < Rabbit::Controllers::Application
-  def info
-    render status: :ok, json: Api::Docker.info
+---
+
+## 📡 Modo Servidor (El Worker)
+
+BugBunny incluye un **Router Inteligente** que funciona igual que el `config/routes.rb` de Rails. Infiere la acción basándose en el **Verbo HTTP** y la estructura de la **URL**.
+
+### 1. Definir Controladores
+
+Crea tus controladores en `app/rabbit/controllers/`. Heredan de `BugBunny::Controller`.
+
+```ruby
+# app/rabbit/controllers/users_controller.rb
+class UsersController < BugBunny::Controller
+
+  # GET users
+  def index
+    users = User.where(active: params[:active])
+    render status: 200, json: users
   end
 
-  def version
-    render status: :ok, json: Api::Docker.version
+  # GET users/123
+  def show
+    user = User.find(params[:id])
+    render status: 200, json: user
   end
 
-  def swarm
-    render status: :ok, json: Api::Docker.swarm
+  # POST users
+  def create
+    user = User.new(params)
+    if user.save
+      render status: 201, json: user
+    else
+      # Estos errores se propagan como BugBunny::UnprocessableEntity
+      render status: 422, json: { errors: user.errors }
+    end
+  end
+  
+  # PUT users/123
+  def update
+    # ...
   end
-end
 
+  # DELETE users/123
+  def destroy
+    # ...
+  end
+end
 ```
 
-## Resource
-Solo para recursos que se adaptan al crud de rails estoy utilizando automaticamente la logica de los publicadores. Los atributos solo se ponen si son necesarios, si no la dejas vacia y actua igual que active resource.
+### 2. Tabla de Ruteo (Convención)
+
+El Router despacha automáticamente según esta tabla:
+
+| Header `x-http-method` | Header `type` (URL) | Controlador | Acción |
+| :--- | :--- | :--- | :--- |
+| `GET` | `users` | `UsersController` | `index` |
+| `GET` | `users/12` | `UsersController` | `show` |
+| `POST` | `users` | `UsersController` | `create` |
+| `PUT` | `users/12` | `UsersController` | `update` |
+| `DELETE` | `users/12` | `UsersController` | `destroy` |
+| `POST` | `users/12/promote` | `UsersController` | `promote` (Custom) |
 
+### 3. Ejecutar el Worker
+
+```bash
+bundle exec rake bug_bunny:work
 ```
-class Manager::Application < BugBunny::Resource
-  self.resource_path = 'rabbit/publisher/manager'
-
-  attribute :id         # 'ID'
-  attribute :version    # 'Version'
-  attribute :created_at # 'CreatedAt'
-  attribute :update_at  # 'UpdatedAt'
-  attribute :spec       # 'Spec'
-end
 
-class Manager::Service < Manager::Application
-  attribute :endpoint # 'Endpoint'
-end
+---
+
+## 🏗 Arquitectura REST-over-AMQP
+
+BugBunny desacopla el transporte de la lógica usando headers AMQP estándar.
+
+| Concepto | REST (HTTP) | BugBunny (AMQP) |
+| :--- | :--- | :--- |
+| **Recurso** | `POST /users` | Header `type`: `users` + Header `x-http-method`: `POST` |
+| **Parametros** | Query String / Body | Header `type` (Query) + Body (Payload) |
+| **Destino** | DNS / IP | Routing Key (ej: `users`) |
+| **Status** | HTTP Code (200, 404) | JSON Response `status` |
+
+---
 
+## 🛠 Middlewares
+
+BugBunny usa una pila de middlewares para procesar peticiones y respuestas, permitiendo logging, manejo de errores y transformación de datos.
+
+```ruby
+# Configuración global en el Resource
+BugBunny::Resource.client_middleware do |conn|
+  # 1. Lanza excepciones Ruby para errores 4xx/5xx
+  conn.use BugBunny::Middleware::RaiseError
+
+  # 2. Parsea JSON a HashWithIndifferentAccess
+  conn.use BugBunny::Middleware::JsonResponse
+end
 ```
 
-## Exceptions
-- Error General:
- - `BugBunny::Error` hereda de `::StandardError` (Captura cualquier error de la gema.)
-- Error de Publicadores:
- - `BugBunny::PublishError` hereda de `BugBunny::Error` (Para fallos de envío o conexión.)
-- Error de Respuestas:
- - `BugBunny::ResponseError::Base` hereda de `BugBunny::Error` (Captura todos los errores de respuesta).
-- Errores Específicos de Respuesta:
- - `BugBunny::ResponseError::BadRequest`
- - `BugBunny::ResponseError::NotFound`
- - `BugBunny::ResponseError::NotAcceptable`
- - `BugBunny::ResponseError::RequestTimeout`
- - `BugBunny::ResponseError::UnprocessableEntity`: En este el error viene el error details a lo rails.
- - `BugBunny::ResponseError::InternalServerError`
+### Excepciones Soportadas
+
+* `BugBunny::BadRequest` (400)
+* `BugBunny::NotFound` (404)
+* `BugBunny::RequestTimeout` (408)
+* `BugBunny::UnprocessableEntity` (422) - Incluye errores de validación.
+* `BugBunny::InternalServerError` (500)
+
+---
+
+## 📄 Licencia
+
+Código abierto bajo [MIT License](https://opensource.org/licenses/MIT).

data/bin_client.rb

@@ -0,0 +1,51 @@
+# bin_client.rb
+require_relative 'lib/bug_bunny'
+$stdout.sync = true # <--- Agrega esto
+
+# 1. Configuración
+BugBunny.configure do |config|
+  config.host = 'localhost'
+  config.username = 'wisproMQ'
+  config.password = 'wisproMQ'
+  config.vhost = 'sync.devel'
+  config.logger = Logger.new(STDOUT)
+  config.rpc_timeout = 5
+end
+
+# 2. Pool
+POOL = ConnectionPool.new(size: 2, timeout: 5) do
+  BugBunny.create_connection
+end
+
+# 3. Cliente
+client = BugBunny.new(pool: POOL)
+
+# --- PRUEBA 1: Publish ---
+puts "\n[1] Enviando mensaje asíncrono (Publish)..."
+
+# AGREGADO: exchange_type: 'topic'
+client.publish('test/ping', exchange: 'test_exchange', exchange_type: 'topic', routing_key: 'test.ping') do |req|
+  req.body = { msg: 'Hola, soy invisible' }
+end
+
+puts "    -> Enviado."
+sleep 1
+
+# --- PRUEBA 2: RPC ---
+puts "\n[2] Enviando petición síncrona (Request)..."
+
+begin
+  # AGREGADO: exchange_type: 'topic'
+  response = client.request('test/123/ping', exchange: 'test_exchange', exchange_type: 'topic', routing_key: 'test.ping') do |req|
+    req.body = { data: 'Importante' }
+    req.timeout = 3
+    req.headers['X-Source'] = 'Terminal'
+  end
+
+  puts "    -> ✅ RESPUESTA RECIBIDA:"
+  puts "       Status: #{response['status']}"
+  puts "       Body:   #{response['body']}"
+
+rescue BugBunny::RequestTimeout
+  puts "    -> ❌ Error: Timeout esperando respuesta."
+end

data/bin_suite.rb

@@ -0,0 +1,77 @@
+# bin_suite.rb
+require_relative 'test_helper'
+require_relative 'test_resource' # Cargamos la clase TestUser
+
+# Cliente "Raw" para pruebas manuales
+raw_client = BugBunny.new(pool: TEST_POOL)
+
+def assert(condition, msg)
+  if condition
+    puts "  ✅ PASS: #{msg}"
+  else
+    puts "  ❌ FAIL: #{msg}"
+  end
+end
+
+puts "\n🔎 --- INICIANDO SUITE DE PRUEBAS BUG BUNNY ---"
+
+# ---------------------------------------------------------
+# TEST 1: RPC Manual (Raw Client)
+# ---------------------------------------------------------
+puts "\n[1] Probando RPC Manual (Client#request)..."
+begin
+  # Notar la routing key: test_user.ping
+  response = raw_client.request('test_user/ping', exchange: 'test_exchange', exchange_type: 'topic', routing_key: 'test_user.ping')
+  assert(response['body']['message'] == 'Pong!', "Respuesta RPC recibida correctamente")
+rescue => e
+  assert(false, "Error RPC: #{e.message}")
+end
+
+# ---------------------------------------------------------
+# TEST 2: Resource Finder (ORM)
+# ---------------------------------------------------------
+puts "\n[2] Probando BugBunny::Resource (Estilo Rails)..."
+
+# YA NO NECESITAS with_scope
+puts "    -> Buscando usuario ID 123..."
+user = TestUser.find(123)
+
+assert(user.is_a?(TestUser), "El objeto retornado es un TestUser")
+assert(user.name == "Gabriel", "El nombre cargó correctamente")
+assert(user.persisted?, "El objeto figura como persistido")
+# ---------------------------------------------------------
+# TEST 3: Resource Create (ORM)
+# ---------------------------------------------------------
+puts "\n[3] Probando Resource Creation..."
+puts "    -> Creando usuario nuevo..."
+new_user = TestUser.create(name: "Nuevo User", email: "new@test.com")
+assert(new_user.persisted?, "El usuario se guardó y recibió ID")
+assert(new_user.id.present?, "Tiene ID asignado por el worker (#{new_user.id})")
+
+# ---------------------------------------------------------
+# TEST 4: Validaciones Locales
+# ---------------------------------------------------------
+puts "\n[4] Probando Validaciones Locales..."
+invalid_user = TestUser.new(email: "sin_nombre@test.com")
+assert(invalid_user.valid? == false, "Usuario sin nombre es inválido")
+assert(invalid_user.errors[:name].any?, "Tiene error en el campo :name")
+
+puts "\n🏁 SUITE FINALIZADA"
+
+# ---------------------------------------------------------
+# TEST 5: Probando Configuración Dinámica (.with)...
+# ---------------------------------------------------------
+puts "\n[5] Probando Configuración Dinámica (.with)..."
+
+# Probamos cambiar el routing key prefix temporalmente
+# El worker escucha 'test_user.*', así que si cambiamos a 'bad_prefix', debería fallar o no encontrar nada
+begin
+  # Forzamos una routing key que no existe para ver si respeta el cambio
+  TestUser.with(routing_key: 'ruta.incorrecta').find(123)
+rescue BugBunny::RequestTimeout
+  puts "  ✅ PASS: El override funcionó (timeout esperado en ruta incorrecta)"
+end
+
+# Probamos que vuelve a la normalidad
+user = TestUser.find(123)
+assert(user.present?, "  ✅ PASS: La configuración volvió a la normalidad")

data/bin_worker.rb

@@ -0,0 +1,20 @@
+# bin_worker.rb
+require_relative 'test_helper'
+require_relative 'test_controller'
+
+puts "🐰 WORKER INICIADO (Exchange: Topic)..."
+
+# Creamos la conexión (o usamos una del pool si quisieras)
+connection = BugBunny.create_connection
+
+# Usamos el método de clase directo.
+# Al no pasar 'block: false', esto bloqueará la ejecución aquí mismo eternamente.
+BugBunny::Consumer.subscribe(
+  connection: connection,
+  queue_name: 'test_users_queue',
+  exchange_name: 'test_exchange',
+  exchange_type: 'topic',
+  routing_key: 'test_user.#'
+)
+
+# ¡Ya no necesitas el loop! El subscribe mantiene vivo el proceso.

data/initializer_example.rb

@@ -0,0 +1,27 @@
+# config/initializers/bug_bunny.rb
+
+# 1. Configuración Global de Conexión (Credenciales)
+BugBunny.configure do |config|
+  config.host = ENV.fetch('RABBITMQ_HOST', 'localhost')
+  config.vhost = ENV.fetch('RABBITMQ_VHOST', '/')
+  config.username = ENV.fetch('RABBITMQ_USER', 'guest')
+  config.password = ENV.fetch('RABBITMQ_PASS', 'guest')
+  config.logger = Rails.logger
+end
+
+# 2. Crear el Pool de Conexiones (Vital para Puma/Sidekiq)
+# Usamos una constante global o un singleton para mantener el pool vivo
+BUG_BUNNY_POOL = ConnectionPool.new(size: ENV.fetch('RAILS_MAX_THREADS', 5).to_i, timeout: 5) do
+  BugBunny.create_connection
+end
+
+# 3. Inyectar el Pool en los Recursos
+# Así todos tus modelos (User, Invoice, etc.) usan este pool por defecto
+BugBunny::Resource.connection_pool = BUG_BUNNY_POOL
+
+# 4. (Opcional) Configurar Middlewares Globales
+# Si en el futuro quieres que BugBunny::Resource use middlewares (logs, tracing),
+# podrías inyectar un cliente pre-configurado en lugar del pool directo.
+# Por ahora, con el pool es suficiente para la v1.0.
+
+puts "🐰 BugBunny inicializado con Pool de #{BUG_BUNNY_POOL.size} conexiones."