bug_bunny 3.0.6 → 3.1.1

data/lib/bug_bunny/session.rb

@@ -1,82 +1,132 @@
-# lib/bug_bunny/session.rb
+# frozen_string_literal: true
 
 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.
+  # Implementa la lógica de "Configuración en Cascada" para Exchanges y Colas,
+  # gestionando el ciclo de vida de un `Bunny::Channel` con resiliencia y carga perezosa.
   #
   # @api private
   class Session
-    # Opciones por defecto para Exchanges: No durables, No auto-borrables.
+    # @!group Opciones por Defecto (Nivel 1: Gema)
+
+    # Opciones predeterminadas de la gema para Exchanges.
     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`.
+    # Opciones predeterminadas de la gema para Colas.
     DEFAULT_QUEUE_OPTIONS = { exclusive: false, durable: false, auto_delete: true }.freeze
 
+    # @!endgroup
+
     # @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.
+    # Factory method para declarar o recuperar un Exchange aplicando la cascada de configuración.
+    #
+    # Jerarquía de fusión:
+    # 1. Defaults de la gema (`DEFAULT_EXCHANGE_OPTIONS`)
+    # 2. Configuración global (`BugBunny.configuration.exchange_options`)
+    # 3. Opciones específicas pasadas como argumento (`opts`)
     #
-    # @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 ('direct', 'topic', 'fanout').
+    # @param opts [Hash] Opciones específicas de infraestructura para este intercambio.
+    # @return [Bunny::Exchange] El objeto exchange de Bunny configurado.
     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
+      # Aplicación de la lógica de fusión en cascada
+      merged_opts = DEFAULT_EXCHANGE_OPTIONS
+                    .merge(BugBunny.configuration.exchange_options || {})
+                    .merge(opts)
+
+      # public_send permite llamar a :topic, :direct, etc. dinámicamente según el tipo
+      channel.public_send(type, name, merged_opts)
     end
 
-    # Factory method para declarar o recuperar una Cola.
+    # Factory method para declarar o recuperar una Cola aplicando la cascada de configuración.
+    #
+    # Jerarquía de fusión:
+    # 1. Defaults de la gema (`DEFAULT_QUEUE_OPTIONS`)
+    # 2. Configuración global (`BugBunny.configuration.queue_options`)
+    # 3. Opciones específicas pasadas como argumento (`opts`)
     #
-    # @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 específicas de infraestructura para esta cola.
+    # @return [Bunny::Queue] El objeto cola de Bunny configurado.
     def queue(name, opts = {})
-      channel.queue(name.to_s, DEFAULT_QUEUE_OPTIONS.merge(opts))
+      # Aplicación de la lógica de fusión en cascada
+      merged_opts = DEFAULT_QUEUE_OPTIONS
+                    .merge(BugBunny.configuration.queue_options || {})
+                    .merge(opts)
+
+      channel.queue(name.to_s, merged_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.
-    #
+    # Cierra el canal asociado a esta sesión de forma segura.
     # @return [void]
     def close
-      @channel.close if @channel&.open?
+      @channel&.close if @channel&.open?
+      @channel = nil
+    end
+
+    private
+
+    # Crea y configura un nuevo canal con las preferencias globales.
+    # Asume que la conexión ya ha sido verificada por `ensure_connection!`.
+    #
+    # @raise [BugBunny::CommunicationError] Si falla la creación del canal.
+    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).
+    #
+    # @raise [BugBunny::CommunicationError] Si falla la reconexión.
+    def ensure_connection!
+      return if @connection.open?
+
+      BugBunny.configuration.logger.warn("[BugBunny::Session] ⚠️  Connection lost. Attempting to reconnect...")
+      @connection.start
+    rescue StandardError => e
+      BugBunny.configuration.logger.error("[BugBunny::Session] ❌ 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.1"
 end

data/lib/bug_bunny.rb

@@ -75,7 +75,7 @@ module BugBunny
 
     @global_connection.close if @global_connection.open?
     @global_connection = nil
-    configuration.logger.info('[BugBunny] Global connection closed.')
+    configuration.logger.info('[BugBunny] 🔌 Global connection closed.')
   end
 
   # @api private

data/test/integration/infrastructure_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+
+# --- CLASES DE PRUEBA (Namespace Aislado) ---
+module InfraTest
+  class PingController < BugBunny::Controller
+    # Agregamos SHOW para soportar el .find del test
+    def show
+      render status: 200, json: { id: params[:id], message: 'pong', namespace: 'InfraTest' }
+    end
+
+    def index
+      render status: 200, json: { message: 'pong_index', namespace: 'InfraTest' }
+    end
+  end
+end
+
+class InfraResource < BugBunny::Resource
+  self.resource_name = 'ping'
+  self.exchange = 'test_infra_exchange'
+  self.exchange_type = 'topic'
+end
+
+# --- SUITE DE INFRAESTRUCTURA ---
+class InfrastructureTest < Minitest::Test
+  include IntegrationHelper
+
+  def setup
+    skip "RabbitMQ no disponible" unless IntegrationHelper.rabbitmq_available?
+    @queue = "test_infra_queue_#{SecureRandom.hex(4)}"
+    @exchange = "test_infra_exchange"
+  end
+
+  def test_00_worker_lifecycle
+    with_running_worker(queue: @queue, exchange: @exchange) do
+      assert true, "El worker levantó y cedió el control al bloque"
+    end
+  end
+
+  def test_01_dynamic_namespace_resolution
+    BugBunny.configure do |c|
+      c.controller_namespace = 'InfraTest'
+    end
+
+    with_running_worker(queue: @queue, exchange: @exchange) do
+      # Enviamos GET ping/123 -> InfraTest::PingController#show
+      resource = InfraResource.find('123')
+
+      # Verificamos que volvió el objeto construido
+      assert_equal '123', resource.id
+      assert_equal 'InfraTest', resource.namespace
+      assert_equal 'pong', resource.message
+    end
+
+  ensure
+    BugBunny.configure do |c|
+      c.controller_namespace = 'Rabbit::Controllers'
+    end
+  end
+end

data/test/integration/manual_client_test.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'timeout'
+
+module ManualTest
+  class EchoController < BugBunny::Controller
+    def index
+      render status: 200, json: { 
+        received: params[:message],
+        type: headers[:type],
+        via: 'ManualTest::EchoController'
+      }
+    end
+  end
+end
+
+class ManualClientTest < Minitest::Test
+  include IntegrationHelper
+
+  def setup
+    skip "RabbitMQ no disponible" unless IntegrationHelper.rabbitmq_available?
+    
+    # 1. NOMBRES ÚNICOS: Evitamos colisiones entre tests de diferentes tipos (Direct/Fanout)
+    @queue = "test_manual_q_#{SecureRandom.hex(4)}"
+    @exchange = "test_manual_x_#{SecureRandom.hex(4)}"
+    
+    @client = BugBunny::Client.new(pool: TEST_POOL)
+    BugBunny.configure { |c| c.controller_namespace = 'ManualTest' }
+  end
+
+  def teardown
+    BugBunny.configure { |c| c.controller_namespace = 'Rabbit::Controllers' }
+  end
+
+  # ==========================================
+  # GRUPO 1: PUBLICACIÓN ASÍNCRONA (PUBLISH)
+  # ==========================================
+
+  def test_publish_topic
+    puts "\n  -> [Manual] Publish (Topic)..."
+    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: { a: 1 })
+      
+      msg = wait_for_message(messages)
+      assert_equal 'logs.error', msg[:routing_key]
+    end
+  end
+
+  def test_publish_direct
+    puts "  -> [Manual] Publish (Direct)..."
+    with_spy_worker(queue: @queue, exchange: @exchange, exchange_type: 'direct', routing_key: 'alert') do |messages|
+      
+      @client.publish('alert', exchange: @exchange, exchange_type: 'direct', body: { a: 1 })
+      
+      msg = wait_for_message(messages)
+      assert_equal 'alert', msg[:routing_key]
+    end
+  end
+
+  def test_publish_fanout
+    puts "  -> [Manual] Publish (Fanout)..."
+    with_spy_worker(queue: @queue, exchange: @exchange, exchange_type: 'fanout', routing_key: '') do |messages|
+      
+      @client.publish('ignored.key', exchange: @exchange, exchange_type: 'fanout', body: { a: 1 })
+      
+      msg = wait_for_message(messages)
+      assert_equal 'ignored.key', msg[:routing_key]
+    end
+  end
+
+  # ==========================================
+  # GRUPO 2: RPC SÍNCRONO (REQUEST)
+  # ==========================================
+
+  def test_request_topic
+    puts "  -> [Manual] RPC (Topic)..."
+    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: 'topic_rpc' }
+      )
+      assert_equal 'topic_rpc', response['body']['received']
+    end
+  end
+
+  def test_request_direct
+    puts "  -> [Manual] RPC (Direct)..."
+    direct_key = 'rpc.direct'
+    
+    with_running_worker(queue: @queue, exchange: @exchange, exchange_type: 'direct', routing_key: direct_key) do
+      
+      response = @client.request('echo',
+        method: :get,
+        routing_key: direct_key, 
+        exchange: @exchange, 
+        exchange_type: 'direct', 
+        body: { message: 'direct_rpc' }
+      )
+
+      assert_equal 200, response['status']
+      assert_equal 'direct_rpc', response['body']['received']
+    end
+  end
+
+  def test_request_fanout
+    puts "  -> [Manual] RPC (Fanout)..."
+    with_running_worker(queue: @queue, exchange: @exchange, exchange_type: 'fanout', routing_key: '') do
+      
+      response = @client.request('echo', 
+        method: :get,
+        routing_key: 'random.ignored', 
+        exchange: @exchange, 
+        exchange_type: 'fanout', 
+        body: { message: 'fanout_rpc' }
+      )
+
+      assert_equal 200, response['status']
+      assert_equal 'fanout_rpc', response['body']['received']
+    end
+  end
+
+  # ==========================================
+  # GRUPO 3: OPCIONES DE INFRAESTRUCTURA (CASCADA NIVEL 3)
+  # ==========================================
+
+  def test_publish_with_custom_exchange_options
+    puts "  -> [Manual] Publish (Custom Options Nivel 3)..."
+    custom_exchange = "custom_opts_x_#{SecureRandom.hex(4)}"
+    
+    # 1. Pre-creamos el exchange exigiendo que sea DURABLE (contrario a la config global)
+    conn = BugBunny.create_connection
+    ch = conn.create_channel
+    ch.topic(custom_exchange, durable: true, auto_delete: true)
+
+    begin
+      # 2. El cliente publica inyectando opciones dinámicas.
+      # Si esto no funcionara, RabbitMQ nos tiraría PRECONDITION_FAILED 
+      # porque la configuración global (Nivel 2) dice durable: false.
+      @client.publish('logs', 
+        exchange: custom_exchange, 
+        exchange_type: 'topic', 
+        exchange_options: { durable: true, auto_delete: true }, # Nivel 3 sobrescribe Nivel 2
+        body: { test: 'options' }
+      )
+      
+      # Si la ejecución llega aquí, significa que la Cascada funcionó perfecto.
+      assert true 
+    ensure
+      ch&.exchange_delete(custom_exchange) rescue nil
+      conn&.close
+    end
+  end
+
+  def test_request_with_custom_exchange_options
+    puts "  -> [Manual] RPC (Custom Options Nivel 3)..."
+    custom_exchange = "custom_opts_rpc_x_#{SecureRandom.hex(4)}"
+    
+    # 1. Exigimos DURABLE
+    conn = BugBunny.create_connection
+    ch = conn.create_channel
+    ch.direct(custom_exchange, durable: true, auto_delete: true)
+
+    # 2. Levantamos un worker usando esas configuraciones nativas
+    worker_thread = Thread.new do
+      q = ch.queue('', exclusive: true)
+      q.bind(custom_exchange, routing_key: 'custom.rpc')
+      q.subscribe(block: true) do |delivery, props, _body|
+        # Respuesta manual
+        ch.default_exchange.publish('{"status":200, "body":"ok"}', routing_key: props.reply_to, correlation_id: props.correlation_id)
+      end
+    end
+    sleep 0.5
+
+    begin
+      # 3. El cliente hace el request inyectando las opciones
+      response = @client.request('test',
+        exchange: custom_exchange,
+        exchange_type: 'direct',
+        routing_key: 'custom.rpc',
+        exchange_options: { durable: true, auto_delete: true }, # Nivel 3
+        body: { req: 'data' }
+      )
+
+      assert_equal 200, response['status']
+      assert_equal 'ok', response['body']
+    ensure
+      worker_thread&.kill
+      ch&.exchange_delete(custom_exchange) rescue nil
+      conn&.close
+    end
+  end
+
+  private
+
+  def wait_for_message(queue, timeout_sec = 2)
+    Timeout.timeout(timeout_sec) { queue.pop }
+  rescue Timeout::Error
+    flunk "Timeout: No llegó el mensaje al Worker en #{timeout_sec}s"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'minitest/autorun'
+# require 'minitest/reporters' 
+require 'bug_bunny'
+require 'connection_pool'
+require 'securerandom'
+require 'socket'
+
+BugBunny.configure do |config|
+  config.host = ENV.fetch('RABBITMQ_HOST', 'localhost')
+  config.username = ENV.fetch('RABBITMQ_USER', 'guest')
+  config.password = ENV.fetch('RABBITMQ_PASS', 'guest')
+  config.vhost = '/'
+  config.logger = Logger.new($stdout)
+  config.logger.level = Logger::WARN 
+
+  # ========================================================
+  # LA MAGIA DE LA CASCADA (Nivel 2: Configuración Global)
+  # ========================================================
+  # Para los tests, queremos que los exchanges y queues sean efímeros
+  config.exchange_options = { durable: false, auto_delete: true }
+  config.queue_options    = { exclusive: false, durable: false, auto_delete: true }
+end
+
+TEST_POOL = ConnectionPool.new(size: 5, timeout: 5) { BugBunny.create_connection }
+BugBunny::Resource.connection_pool = TEST_POOL
+
+module IntegrationHelper
+  def self.rabbitmq_available?
+    socket = TCPSocket.new(BugBunny.configuration.host, 5672)
+    socket.close
+    true
+  rescue Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError
+    false
+  end
+
+  def with_running_worker(queue:, exchange:, exchange_type: 'topic', routing_key: '#')
+    conn = BugBunny.create_connection
+    
+    worker_thread = Thread.new do
+      ch = conn.create_channel
+      
+      x_opts = BugBunny.configuration.exchange_options || {}
+      q_opts = BugBunny.configuration.queue_options || {}
+
+      # FIX: Usamos la API de alto nivel (public_send) idéntica a BugBunny::Session
+      ch.public_send(exchange_type, exchange, x_opts)
+      ch.close
+
+      BugBunny::Consumer.subscribe(
+        connection: conn,
+        queue_name: queue,
+        exchange_name: exchange,
+        exchange_type: exchange_type,
+        routing_key: routing_key,
+        queue_opts: q_opts,
+        block: true
+      )
+    rescue => e
+      puts "❌ WORKER CRASHED: #{e.message}"
+      puts e.backtrace.join("\n")
+    end
+
+    sleep 0.5 
+    yield
+  ensure
+    conn&.close
+    worker_thread&.kill
+    sleep 0.1
+  end
+
+  def with_spy_worker(queue:, exchange:, exchange_type: 'topic', routing_key: '#')
+    captured_messages = Thread::Queue.new
+    conn = BugBunny.create_connection
+    
+    worker_thread = Thread.new do
+      ch = conn.create_channel
+      
+      x_opts = BugBunny.configuration.exchange_options || {}
+      q_opts = BugBunny.configuration.queue_options || {}
+      
+      # FIX DEFINITIVO: Ahora 'x' es un hermoso objeto Bunny::Exchange
+      # que la función .bind() entiende perfectamente.
+      x = ch.public_send(exchange_type, exchange, x_opts)
+      q = ch.queue(queue, q_opts)
+      
+      # Bindeamos el objeto al queue
+      q.bind(x, routing_key: routing_key)
+
+      q.subscribe(block: true) do |delivery, props, body|
+        captured_messages << { 
+          body: body, 
+          routing_key: delivery.routing_key,
+          headers: props.headers 
+        }
+      end
+    rescue => e
+      puts "SPY WORKER ERROR: #{e.message}"
+    end
+
+    sleep 0.5
+    yield(captured_messages)
+  ensure
+    conn&.close
+    worker_thread&.kill
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bug_bunny
 version: !ruby/object:Gem::Version
-  version: 3.0.6
+  version: 3.1.1
 platform: ruby
 authors:
 - gabix
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-02-17 00:00:00.000000000 Z
+date: 2026-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -178,6 +178,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
 description: BugBunny is a lightweight RPC framework for Ruby on Rails over RabbitMQ.
   It simulates a RESTful architecture with an intelligent router, Active Record-like
   resources, and middleware support.
@@ -190,9 +232,6 @@ files:
 - CHANGELOG.md
 - README.md
 - Rakefile
-- bin_client.rb
-- bin_suite.rb
-- bin_worker.rb
 - initializer_example.rb
 - lib/bug_bunny.rb
 - lib/bug_bunny/client.rb
@@ -213,9 +252,9 @@ files:
 - lib/generators/bug_bunny/install/install_generator.rb
 - lib/generators/bug_bunny/install/templates/initializer.rb
 - sig/bug_bunny.rbs
-- test_controller.rb
-- test_helper.rb
-- test_resource.rb
+- test/integration/infrastructure_test.rb
+- test/integration/manual_client_test.rb
+- test/test_helper.rb
 homepage: https://github.com/gedera/bug_bunny
 licenses:
 - MIT