bug_bunny 3.0.6 → 3.1.0

data/lib/bug_bunny/resource.rb

@@ -1,71 +1,44 @@
-# lib/bug_bunny/resource.rb
+# frozen_string_literal: true
+
 require 'active_model'
 require 'active_support/core_ext/string/inflections'
 require 'uri'
+require 'set' # Necesario para el tracking manual
 require 'rack/utils'
 
 module BugBunny
   # Clase base para modelos remotos que implementan **Active Record over AMQP (RESTful)**.
   #
-  # Esta clase transforma operaciones CRUD estándar en peticiones RPC utilizando
-  # verbos HTTP semánticos (GET, POST, PUT, DELETE) transportados sobre headers AMQP.
-  #
-  # También gestiona la serialización automática de parámetros ("wrapping") para
-  # compatibilidad con Strong Parameters de Rails.
+  # Soporta un esquema híbrido de datos:
+  # 1. **Atributos Tipados:** Definidos con `attribute :name, :type`.
+  # 2. **Atributos Dinámicos:** Asignados al vuelo sin definición previa.
   #
-  # @example Definición de un recurso
-  #   class User < BugBunny::Resource
-  #     self.exchange = 'app.topic'
-  #     self.resource_name = 'users'
-  #     # Opcional: Personalizar la clave raíz del JSON
-  #     self.param_key = 'user_data'
-  #   end
+  # Implementa un sistema de "Dirty Tracking" híbrido para detectar cambios
+  # tanto en atributos tipados (via ActiveModel) como dinámicos (via Set manual).
   #
-  # @example Uso con contexto temporal
-  #   # La instancia 'user' recordará que debe usar la routing_key 'urgent'
-  #   user = User.with(routing_key: 'urgent').new(name: 'Gaby')
-  #   user.save # Enviará a la cola 'urgent' aunque estemos fuera del bloque .with
+  # @author Gabriel
+  # @since 3.0.6
   class Resource
     include ActiveModel::API
+    include ActiveModel::Attributes
     include ActiveModel::Dirty
     include ActiveModel::Validations
     extend ActiveModel::Callbacks
 
     define_model_callbacks :save, :create, :update, :destroy
 
-    # @return [HashWithIndifferentAccess] Contenedor de los atributos remotos (JSON crudo).
     attr_reader :remote_attributes
-
-    # @return [Boolean] Indica si el objeto ha sido guardado en el servicio remoto.
     attr_accessor :persisted
-
-    # @return [String, nil] Routing Key capturada en el momento de la instanciación.
-    attr_accessor :routing_key
-
-    # @return [String, nil] Exchange capturado en el momento de la instanciación.
-    attr_accessor :exchange
-
-    # @return [String, nil] Tipo de Exchange capturado en el momento de la instanciación.
-    attr_accessor :exchange_type
+    attr_accessor :routing_key, :exchange, :exchange_type
 
     class << self
-      # Configuración heredable
       attr_writer :connection_pool, :exchange, :exchange_type, :resource_name, :routing_key, :param_key
 
-      # Lee la configuración del Thread actual (usado por el scope .with).
-      # @api private
-      def thread_config(key)
-        Thread.current["bb_#{object_id}_#{key}"]
-      end
+      def thread_config(key); Thread.current["bb_#{object_id}_#{key}"]; end
 
-      # Resuelve la configuración buscando en: 1. Thread (Scope), 2. Clase, 3. Herencia.
-      # @api private
       def resolve_config(key, instance_var)
-        # 1. Prioridad: Contexto de hilo (.with)
         val = thread_config(key)
         return val if val
-
-        # 2. Prioridad: Jerarquía de clases
         target = self
         while target <= BugBunny::Resource
           value = target.instance_variable_get(instance_var)
@@ -75,38 +48,23 @@ module BugBunny
         nil
       end
 
-      # @return [ConnectionPool] El pool de conexiones asignado.
       def connection_pool; resolve_config(:pool, :@connection_pool); end
-
-      # @return [String] El exchange configurado.
-      # @raise [ArgumentError] Si no se ha definido un exchange.
       def current_exchange; resolve_config(:exchange, :@exchange) || raise(ArgumentError, "Exchange not defined"); end
-
-      # @return [String] El tipo de exchange (default: direct).
       def current_exchange_type; resolve_config(:exchange_type, :@exchange_type) || 'direct'; end
 
-      # @return [String] El nombre del recurso (ej: 'users'). Se infiere del nombre de la clase si no existe.
       def resource_name
         resolve_config(:resource_name, :@resource_name) || name.demodulize.underscore.pluralize
       end
 
-      # Define la clave raíz para envolver el payload JSON (Wrapping).
-      #
-      # Por defecto utiliza `model_name.element`, lo que elimina los namespaces.
-      # Ej: `Manager::Service` -> `'service'`.
-      #
-      # @return [String] La clave paramétrica.
       def param_key
         resolve_config(:param_key, :@param_key) || model_name.element
       end
 
-      # Define un middleware para el cliente HTTP/AMQP de este recurso.
       def client_middleware(&block)
         @client_middleware_stack ||= []
         @client_middleware_stack << block
       end
 
-      # @api private
       def resolve_middleware_stack
         stack = []
         target = self
@@ -118,28 +76,19 @@ module BugBunny
         stack
       end
 
-      # Instancia un cliente configurado con el pool y middlewares del recurso.
-      # @return [BugBunny::Client]
       def bug_bunny_client
         pool = connection_pool
         raise BugBunny::Error, "Connection pool missing for #{name}" unless pool
-
         BugBunny::Client.new(pool: pool) do |conn|
           resolve_middleware_stack.each { |block| block.call(conn) }
         end
       end
 
-      # Ejecuta un bloque (o retorna un Proxy) con una configuración temporal.
-      # Útil para cambiar de exchange o routing_key para una operación específica.
-      #
-      # @example
-      #   User.with(routing_key: 'urgent').create(params)
       def with(exchange: nil, routing_key: nil, exchange_type: nil, pool: nil)
         keys = { exchange: "bb_#{object_id}_exchange", exchange_type: "bb_#{object_id}_exchange_type", pool: "bb_#{object_id}_pool", routing_key: "bb_#{object_id}_routing_key" }
         old_values = {}
         keys.each { |k, v| old_values[k] = Thread.current[v] }
 
-        # Seteamos valores temporales
         Thread.current[keys[:exchange]] = exchange if exchange
         Thread.current[keys[:exchange_type]] = exchange_type if exchange_type
         Thread.current[keys[:pool]] = pool if pool
@@ -152,40 +101,25 @@ module BugBunny
         end
       end
 
-      # Proxy para permitir encadenamiento: User.with(...).find(1)
       class ScopeProxy < BasicObject
         def initialize(target, keys, old_values); @target = target; @keys = keys; @old_values = old_values; end
         def method_missing(method, *args, &block); @target.public_send(method, *args, &block); ensure; @keys.each { |k, v| ::Thread.current[v] = @old_values[k] }; end
       end
 
-      # Calcula la Routing Key.
-      # @return [String]
       def calculate_routing_key(id = nil)
-        # 1. Contexto .with
         manual_rk = thread_config(:routing_key)
         return manual_rk if manual_rk
-
-        # 2. Configuración estática
         static_rk = resolve_config(:routing_key, :@routing_key)
         return static_rk if static_rk.present?
-
-        # 3. Default: Resource name
         resource_name
       end
 
-      # @!group Acciones CRUD RESTful (Clase)
-
-      # Busca recursos que coincidan con los filtros.
-      # Envía: GET resource?query
+      # @!group Acciones CRUD RESTful
       def where(filters = {})
         rk = calculate_routing_key
         path = resource_name
-
-        # Usamos Rack para serializar anidamiento (q[service]=val)
         path += "?#{Rack::Utils.build_nested_query(filters)}" if filters.present?
-
         response = bug_bunny_client.request(path, method: :get, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk)
-
         return [] unless response['body'].is_a?(Array)
         response['body'].map do |attrs|
           inst = new(attrs)
@@ -197,26 +131,18 @@ module BugBunny
 
       def all; where({}); end
 
-      # Busca un recurso por ID.
-      # Envía: GET resource/id
       def find(id)
         rk = calculate_routing_key(id)
         path = "#{resource_name}/#{id}"
-
         response = bug_bunny_client.request(path, method: :get, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk)
-
         return nil if response.nil? || response['status'] == 404
-
-        attributes = response['body']
-        return nil unless attributes.is_a?(Hash)
-
-        instance = new(attributes)
+        return nil unless response['body'].is_a?(Hash)
+        instance = new(response['body'])
         instance.persisted = true
         instance.send(:clear_changes_information)
         instance
       end
 
-      # Crea un nuevo recurso.
       def create(payload)
         instance = new(payload)
         instance.save
@@ -226,45 +152,32 @@ module BugBunny
 
     # @!group Instancia
 
-    # Inicializa una nueva instancia del recurso.
-    #
-    # **IMPORTANTE:** Captura la configuración del contexto actual (`.with`)
-    # y la guarda en la instancia. Esto permite que objetos creados dentro de un bloque `with`
-    # mantengan esa configuración (routing_key, exchange) durante todo su ciclo de vida,
-    # incluso si `save` se llama fuera del bloque.
-    #
-    # @param attributes [Hash] Atributos iniciales.
     def initialize(attributes = {})
       @remote_attributes = {}.with_indifferent_access
+      @dynamic_changes = Set.new # Rastreo manual para atributos dinámicos
       @persisted = false
-
-      # === CAPTURA DE CONTEXTO ===
       @routing_key = self.class.thread_config(:routing_key)
       @exchange = self.class.thread_config(:exchange)
       @exchange_type = self.class.thread_config(:exchange_type)
 
-      assign_attributes(attributes)
       super()
+      assign_attributes(attributes)
     end
 
-    # Prioridad Routing Key: 1. Instancia (Capturada), 2. Clase
-    def calculate_routing_key(id=nil)
-      return @routing_key if @routing_key
-      self.class.calculate_routing_key(id)
-    end
-
-    # Prioridad Exchange: 1. Instancia (Capturada), 2. Clase
-    def current_exchange
-      @exchange || self.class.current_exchange
+    # Limpia tanto el rastreo de ActiveModel como nuestro rastreo dinámico.
+    def clear_changes_information
+      super
+      @dynamic_changes.clear
     end
 
-    # Prioridad Exchange Type: 1. Instancia (Capturada), 2. Clase
-    def current_exchange_type
-      @exchange_type || self.class.current_exchange_type
+    def attributes_for_serialization
+      @remote_attributes.merge(attributes)
     end
 
+    def calculate_routing_key(id=nil); @routing_key || self.class.calculate_routing_key(id); end
+    def current_exchange; @exchange || self.class.current_exchange; end
+    def current_exchange_type; @exchange_type || self.class.current_exchange_type; end
     def bug_bunny_client; self.class.bug_bunny_client; end
-
     def persisted?; !!@persisted; end
 
     def assign_attributes(new_attributes)
@@ -277,19 +190,36 @@ module BugBunny
       save
     end
 
-    # Retorna solo los atributos que han cambiado.
+    # Retorna el hash combinado de cambios (Tipados + Dinámicos).
     def changes_to_send
-      return changes.transform_values(&:last) unless changes.empty?
-      @remote_attributes.except('id', 'ID', 'Id', '_id')
+      # 1. Cambios de ActiveModel (Tipados)
+      # changes returns { 'attr' => [old, new] } -> nos quedamos con new
+      payload = changes.transform_values(&:last)
+
+      # 2. Cambios Dinámicos (Manuales)
+      @dynamic_changes.each do |key|
+        payload[key] = @remote_attributes[key]
+      end
+
+      return payload unless payload.empty?
+
+      # Fallback: Si no hay cambios detectados, enviamos todo (útil para create)
+      attributes_for_serialization.except('id', 'ID', 'Id', '_id')
     end
 
-    # Métodos mágicos para atributos.
+    # Intercepta asignaciones dinámicas y las marca como sucias.
     def method_missing(method_name, *args, &block)
       attribute_name = method_name.to_s
       if attribute_name.end_with?('=')
         key = attribute_name.chop
         val = args.first
-        attribute_will_change!(key) unless @remote_attributes[key] == val
+
+        # Dirty Tracking Manual
+        # Si el valor cambia, lo marcamos en nuestro Set
+        if @remote_attributes[key] != val
+          @dynamic_changes << key
+        end
+
         @remote_attributes[key] = val
       else
         @remote_attributes.key?(attribute_name) ? @remote_attributes[attribute_name] : super
@@ -301,50 +231,45 @@ module BugBunny
     end
 
     def id
-      @remote_attributes['id'] || @remote_attributes['ID'] || @remote_attributes['Id'] || @remote_attributes['_id']
+      attributes['id'] || @remote_attributes['id'] || @remote_attributes['ID'] || @remote_attributes['Id'] || @remote_attributes['_id']
     end
 
     def id=(value)
-      @remote_attributes['id'] = value
+      if self.class.attribute_names.include?('id')
+        super(value)
+      else
+        @remote_attributes['id'] = value
+      end
     end
 
     def read_attribute_for_validation(attr)
-      @remote_attributes[attr.to_s]
+      attr_s = attr.to_s
+      self.class.attribute_names.include?(attr_s) ? attribute(attr_s) : @remote_attributes[attr_s]
     end
 
-    # @!group Persistencia RESTful
+    # @!group Persistencia
 
-    # Guarda el registro.
-    # Envía POST si es nuevo, PUT si ya existe.
-    #
-    # **AUTOMÁTICO:** Envuelve los parámetros en la clave del modelo (`param_key`).
-    # Ej: Manager::Service -> "service". Esto facilita `params.require(:service)`.
-    #
-    # @return [Boolean] true si se guardó correctamente.
     def save
       return false unless valid?
 
       run_callbacks(:save) do
         is_new = !persisted?
         rk = calculate_routing_key(id)
-
-        # 1. Obtenemos el payload plano (atributos modificados)
         flat_payload = changes_to_send
-
-        # 2. Wrappeamos automáticamente en la clave del modelo
         key = self.class.param_key
         wrapped_payload = { key => flat_payload }
 
-        # Mapeo a verbos HTTP
-        if is_new
-          # REST: POST resource (Create)
-          path = self.class.resource_name
-          response = bug_bunny_client.request(path, method: :post, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk, body: wrapped_payload)
-        else
-          # REST: PUT resource/id (Update)
-          path = "#{self.class.resource_name}/#{id}"
-          response = bug_bunny_client.request(path, method: :put, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk, body: wrapped_payload)
-        end
+        path = is_new ? self.class.resource_name : "#{self.class.resource_name}/#{id}"
+        method = is_new ? :post : :put
+
+        response = bug_bunny_client.request(
+          path,
+          method: method,
+          exchange: current_exchange,
+          exchange_type: current_exchange_type,
+          routing_key: rk,
+          body: wrapped_payload
+        )
 
         handle_save_response(response)
       end
@@ -353,17 +278,12 @@ module BugBunny
       false
     end
 
-    # Elimina el registro.
-    # Envía DELETE resource/id.
     def destroy
       return false unless persisted?
-
       run_callbacks(:destroy) do
         path = "#{self.class.resource_name}/#{id}"
         rk = calculate_routing_key(id)
-
         bug_bunny_client.request(path, method: :delete, exchange: current_exchange, exchange_type: current_exchange_type, routing_key: rk)
-
         self.persisted = false
       end
       true
@@ -381,7 +301,6 @@ module BugBunny
       elsif response['status'] >= 400
         raise BugBunny::ClientError
       end
-
       assign_attributes(response['body'])
       self.persisted = true
       clear_changes_information

data/lib/bug_bunny/session.rb

@@ -3,80 +3,101 @@
 module BugBunny
   # Clase interna que encapsula una unidad de trabajo sobre una conexión RabbitMQ.
   #
-  # Su responsabilidad principal es gestionar el ciclo de vida de un `Bunny::Channel`.
-  # En RabbitMQ, las conexiones TCP son costosas, pero los canales son ligeros.
-  # Esta clase toma una conexión abierta del Pool, abre un canal exclusivo para esta sesión,
-  # configura el QoS y facilita la creación de Exchanges y Colas.
+  # Gestiona el ciclo de vida de un `Bunny::Channel` implementando:
+  # 1. Carga Perezosa (Lazy Loading): El canal solo se abre al usarse.
+  # 2. Resiliencia: Intenta recuperar la conexión TCP si está cerrada.
   #
   # @api private
   class Session
-    # Opciones por defecto para Exchanges: No durables, No auto-borrables.
+    # Opciones por defecto (Mantenemos las que tenías en tu repo)
     DEFAULT_EXCHANGE_OPTIONS = { durable: false, auto_delete: false }.freeze
-
-    # Opciones por defecto para Colas: No exclusivas, No durables, Auto-borrables.
-    # @note Por defecto las colas son volátiles (`auto_delete: true`). Para workers persistentes,
-    #   se debe pasar explícitamente `durable: true, auto_delete: false`.
     DEFAULT_QUEUE_OPTIONS = { exclusive: false, durable: false, auto_delete: true }.freeze
 
     # @return [Bunny::Session] La conexión TCP subyacente.
     attr_reader :connection
 
-    # @return [Bunny::Channel] El canal AMQP abierto para esta sesión.
-    attr_reader :channel
+    # Inicializa una nueva sesión sin abrir canales todavía.
+    #
+    # @param connection [Bunny::Session] Una conexión (puede estar abierta o cerrada temporalmente).
+    def initialize(connection)
+      @connection = connection
+      @channel = nil
+    end
 
-    # Inicializa una nueva sesión.
+    # Obtiene el canal actual o crea uno nuevo si es necesario.
     #
-    # 1. Verifica que la conexión esté viva.
-    # 2. Abre un nuevo canal.
-    # 3. Habilita "Publisher Confirms" para garantizar que los mensajes lleguen al broker.
-    # 4. Configura el "Prefetch" (QoS) global para este canal.
+    # Este método es el punto central de la robustez. Verifica la salud
+    # de la conexión y del canal antes de devolverlo.
     #
-    # @param connection [Bunny::Session] Una conexión abierta.
-    # @raise [BugBunny::Error] Si la conexión es nil o está cerrada.
-    def initialize(connection)
-      raise BugBunny::Error, "Connection is closed or nil" unless connection&.open?
+    # @return [Bunny::Channel] Un canal abierto y configurado.
+    # @raise [BugBunny::CommunicationError] Si no se puede restablecer la conexión.
+    def channel
+      # Si el canal existe y está abierto, lo devolvemos rápido.
+      return @channel if @channel&.open?
 
-      @connection = connection
-      # Creamos canal nuevo para esta sesión (Thread-safe dentro del contexto del Pool)
-      @channel = connection.create_channel
-      @channel.confirm_select
-      @channel.prefetch(BugBunny.configuration.channel_prefetch)
+      # Si no, intentamos asegurar la conexión y crear el canal.
+      ensure_connection!
+      create_channel!
+
+      @channel
     end
 
     # Factory method para declarar o recuperar un Exchange.
+    # Usa el método robusto `channel` internamente.
     #
-    # @param name [String, nil] El nombre del exchange. Si es nil/vacío, retorna el Default Exchange.
-    # @param type [String, Symbol] El tipo de exchange (:direct, :topic, :fanout, :headers).
-    # @param opts [Hash] Opciones de configuración (durable, auto_delete, arguments).
-    # @return [Bunny::Exchange] La instancia del exchange.
+    # @param name [String, nil] Nombre del exchange.
+    # @param type [String, Symbol] Tipo de exchange.
+    # @param opts [Hash] Opciones adicionales.
     def exchange(name: nil, type: 'direct', opts: {})
       return channel.default_exchange if name.nil? || name.empty?
 
       merged_opts = DEFAULT_EXCHANGE_OPTIONS.merge(opts)
-      case type.to_sym
-      when :topic   then channel.topic(name, merged_opts)
-      when :direct  then channel.direct(name, merged_opts)
-      when :fanout  then channel.fanout(name, merged_opts)
-      when :headers then channel.headers(name, merged_opts)
-      else channel.direct(name, merged_opts)
-      end
+      # public_send permite llamar a :topic, :direct, etc. dinámicamente
+      channel.public_send(type, name, merged_opts)
     end
 
     # Factory method para declarar o recuperar una Cola.
+    # Usa el método robusto `channel` internamente.
     #
-    # @param name [String] El nombre de la cola.
-    # @param opts [Hash] Opciones de configuración (durable, auto_delete, exclusive, arguments).
-    # @return [Bunny::Queue] La instancia de la cola.
+    # @param name [String] Nombre de la cola.
+    # @param opts [Hash] Opciones adicionales.
     def queue(name, opts = {})
       channel.queue(name.to_s, DEFAULT_QUEUE_OPTIONS.merge(opts))
     end
 
-    # Cierra el canal asociado a esta sesión.
-    # No cierra la conexión TCP (ya que esta pertenece al Pool), solo libera el canal virtual.
-    #
-    # @return [void]
+    # Cierra el canal asociado a esta sesión de forma segura.
     def close
-      @channel.close if @channel&.open?
+      @channel&.close if @channel&.open?
+      @channel = nil
+    end
+
+    private
+
+    # Crea y configura un nuevo canal.
+    # Asume que la conexión ya ha sido verificada por `ensure_connection!`.
+    def create_channel!
+      @channel = @connection.create_channel
+
+      # Configuraciones globales de BugBunny
+      @channel.confirm_select
+
+      if BugBunny.configuration.channel_prefetch
+        @channel.prefetch(BugBunny.configuration.channel_prefetch)
+      end
+    rescue StandardError => e
+      raise BugBunny::CommunicationError, "Failed to create channel: #{e.message}"
+    end
+
+    # Garantiza que la conexión TCP esté abierta.
+    # Si está cerrada, intenta reconectarla (Reconexión Transparente).
+    def ensure_connection!
+      return if @connection.open?
+
+      BugBunny.configuration.logger.warn("[BugBunny] Connection lost. Attempting to reconnect...")
+      @connection.start
+    rescue StandardError => e
+      BugBunny.configuration.logger.error("[BugBunny] Critical connection failure: #{e.message}")
+      raise BugBunny::CommunicationError, "Could not reconnect to RabbitMQ: #{e.message}"
     end
   end
 end

data/lib/bug_bunny/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BugBunny
-  VERSION = "3.0.6"
+  VERSION = "3.1.0"
 end

data/test/integration/fire_and_forget_test.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'connection_pool'
+
+class FireAndForgetTest < Minitest::Test
+  def setup
+    skip "RabbitMQ no disponible" unless TestHelper.rabbitmq_available?
+
+    # 1. Configuración
+    BugBunny.configure do |c|
+      c.host = 'localhost'
+      c.username = 'wisproMQ'
+      c.password = 'wisproMQ'
+      c.port = 5672
+      c.logger = Logger.new(nil)
+    end
+
+    @pool = ConnectionPool.new(size: 1, timeout: 5) { BugBunny.create_connection }
+
+    # 2. Infraestructura de Test
+    @queue_name = 'test_fire_queue'
+    @exchange_name = 'test_fire_exchange'
+    @routing_key = 'logs.error'
+
+    # Usamos una Queue de Ruby para pasar el mensaje del Consumer al Test
+    @message_bucket = Queue.new
+
+    # 3. Consumidor "Espía"
+    @conn_consumer = BugBunny.create_connection
+    @consumer_thread = Thread.new do
+      ch = @conn_consumer.create_channel
+      # IMPORTANTE: Aquí declaramos el exchange como TOPIC
+      x = ch.topic(@exchange_name)
+      q = ch.queue(@queue_name).bind(x, routing_key: @routing_key)
+
+      q.subscribe(block: true) do |delivery_info, properties, body|
+        @message_bucket << {
+          body: body,
+          routing_key: delivery_info.routing_key
+        }
+      end
+    end
+    sleep 0.5 # Wait boot
+  end
+
+  def teardown
+    return unless @conn_consumer
+    @conn_consumer.close
+    @consumer_thread.kill
+  end
+
+  def test_publish_directly
+    client = BugBunny::Client.new(pool: @pool)
+    payload = { system: 'payment', error: 'timeout' }
+
+    # 1. Disparamos (Fire)
+    client.publish(
+      'logs/error',
+      body: payload,
+      exchange: @exchange_name,
+      exchange_type: 'topic',
+      routing_key: @routing_key
+    )
+
+    # 2. Verificamos asíncronamente
+    received = nil
+    Timeout.timeout(2) do
+      received = @message_bucket.pop
+    end
+
+    # 3. Aserciones
+    assert_equal payload.to_json, received[:body]
+    assert_equal @routing_key, received[:routing_key]
+  end
+end