bug_bunny 5.2.0 → 5.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -8,6 +8,7 @@ module BugBunny
8
8
  # Esta clase es responsable de:
9
9
  # 1. Registrar la carpeta `app/rabbit` en el autoloader de Rails (Zeitwerk).
10
10
  # 2. Gestionar la seguridad de las conexiones durante el "forking" de procesos (Puma/Spring).
11
+ # 3. Envolver cada mensaje del Consumer con el executor de Rails (ver {ConsumerMiddleware::RailsExecutor}).
11
12
  #
12
13
  # @see https://guides.rubyonrails.org/engines.html#railtie
13
14
  class Railtie < ::Rails::Railtie
@@ -34,9 +35,19 @@ module BugBunny
34
35
  end
35
36
  end
36
37
 
37
- # 3. Rake tasks (bug_bunny:sync)
38
- rake_tasks do
39
- load File.expand_path('../tasks/bug_bunny.rake', __dir__)
38
+ # 3. Executor de Rails alrededor de cada mensaje del Consumer
39
+ #
40
+ # El Consumer procesa en el hilo de Bunny, que Rails no conoce: sin esto, el estado por hilo
41
+ # pasa de un mensaje al siguiente. Va al principio de la cadena (`prepend`, no `use`) para que
42
+ # envuelva también a los middlewares que cargan ese estado, como el de tracing de ExisRay, que
43
+ # se registra en su propio `after_initialize` y en un orden que no controlamos.
44
+ config.after_initialize do
45
+ # Sin un `BugBunny.configure` previo, vale la configuración por default; un `configure` posterior la reusa.
46
+ BugBunny.configuration ||= BugBunny::Configuration.new
47
+ if BugBunny.configuration.consumer_rails_executor
48
+ require_relative 'consumer_middleware/rails_executor'
49
+ BugBunny.consumer_middlewares.prepend(BugBunny::ConsumerMiddleware::RailsExecutor)
50
+ end
40
51
  end
41
52
 
42
53
  # 4. Hook de Spring (Preloader)
@@ -1,5 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module BugBunny
4
- VERSION = '5.2.0'
4
+ VERSION = '5.4.0'
5
5
  end
@@ -41,48 +41,6 @@ module BugBunny
41
41
  empty_directory 'app/bug_bunny/controllers'
42
42
  create_file 'app/bug_bunny/controllers/.keep', ''
43
43
  end
44
-
45
- # Escribe el bloque inicial de BugBunny en CLAUDE.md del proyecto consumidor.
46
- #
47
- # Si CLAUDE.md no existe, crea uno mínimo con la sección correspondiente.
48
- # Si ya existe, agrega la sección `## Gemas internas` con el bloque de bug_bunny.
49
- # En ambos casos, el rake task `bug_bunny:sync` se encarga de las actualizaciones futuras.
50
- #
51
- # @return [void]
52
- def update_claude_md
53
- spec = Gem::Specification.find_by_name('bug_bunny')
54
- version = spec.version.to_s
55
- docs_path = File.join(spec.gem_dir, 'docs', 'ai')
56
-
57
- block = <<~BLOCK
58
- ## Gemas internas
59
-
60
- ### bug_bunny
61
- - **Version:** #{version}
62
- - **Docs:** #{docs_path}
63
- - **Updated:** #{Time.now.strftime('%Y-%m-%d')}
64
- BLOCK
65
-
66
- claude_md = File.join(destination_root, 'CLAUDE.md')
67
-
68
- if File.exist?(claude_md)
69
- content = File.read(claude_md)
70
- if content.include?('### bug_bunny')
71
- say_status :skip, 'CLAUDE.md already has a bug_bunny block — run `rake bug_bunny:sync` to update'
72
- elsif content.include?('## Gemas internas')
73
- inject_into_file 'CLAUDE.md', "\n#{block.lines.drop(2).join}", after: "## Gemas internas\n"
74
- say_status :update, 'Added bug_bunny block to existing ## Gemas internas section in CLAUDE.md'
75
- else
76
- append_to_file 'CLAUDE.md', "\n#{block}"
77
- say_status :update, 'Added ## Gemas internas section to CLAUDE.md'
78
- end
79
- else
80
- create_file 'CLAUDE.md', "# #{Rails.application.class.module_parent_name}\n\n#{block}"
81
- say_status :create, 'CLAUDE.md created with bug_bunny block'
82
- end
83
-
84
- say ' Add `bundle exec rake bug_bunny:sync` to bin/setup to keep this block up to date.'
85
- end
86
44
  end
87
45
  end
88
46
  end
data/skill/SKILL.md CHANGED
@@ -19,10 +19,12 @@ Gema Ruby: capa de routing RESTful sobre AMQP/RabbitMQ. Microservicios se comuni
19
19
 
20
20
  ## Contrato resumido (piso mínimo)
21
21
 
22
- > Resume el contrato de **`bug_bunny` 5.2.0** (anclado a `v5.2.0`). Suficiente para el uso típico sin abrir el detalle; el detalle version-locked está en el **Índice de artefactos** de abajo. Antipatrones/API completa: más abajo (embebido interim, ver Cobertura y fronteras).
22
+ > Resume el contrato de **`bug_bunny` 5.4.0** (anclado a `v5.4.0`). Suficiente para el uso típico sin abrir el detalle; el detalle version-locked está en el **Índice de artefactos** de abajo. Antipatrones/API completa: más abajo (embebido interim, ver Cobertura y fronteras).
23
23
  >
24
24
  > **Si venís de 5.1.x, un cambio de conducta (5.2.0):** una entrega cuyo middleware —o `handle_fatal_error`— levanta **antes del ack** ahora se **rechaza sin requeue** (evento `consumer.delivery_failed`), en `subscribe` y en `drain`. Antes quedaba sin ack ni reject y trababa el consumidor. Si un middleware levantaba a propósito para que el mensaje se reintentara, ahora el mensaje se pierde: el reintento es tuyo. Detalle en [`docs/behavior/behavior.md`](../docs/behavior/behavior.md).
25
25
  >
26
+ > **Si venís de 5.2.x, dos cambios de conducta dentro de Rails (5.3.0):** cada mensaje del Consumer corre dentro de `Rails.application.executor.wrap`. En Rails ≥ 7.0, un error que escapa del mensaje además se reporta a `Rails.error` (el mensaje se sigue rechazando sin requeue), y la caché de queries de ActiveRecord queda prendida durante cada mensaje. Se apagan con `config.consumer_rails_executor = false`. Detalle en [`docs/behavior/behavior.md`](../docs/behavior/behavior.md) y [`docs/config/configuracion.md`](../docs/config/configuracion.md).
27
+ >
26
28
  > **Si venís de 4.x, dos breaking a mirar antes de subir:** `5.0.0` eliminó la constante pública `BugBunny::SecurityError` (un `rescue BugBunny::SecurityError` que sobreviva revienta con `NameError` y **enmascara la excepción original**) y `4.18.0` cambió el wrapping `Bunny::Exception` → `CommunicationError`. Detalle en `CHANGELOG.md`.
27
29
 
28
30
  **Símbolos públicos clave**
@@ -63,16 +65,16 @@ client.publish('events', body: { type: 'x' }) # => { 'status' => 202 }
63
65
 
64
66
  ## Índice de artefactos (fuente de verdad)
65
67
 
66
- El detalle vive en `docs/<capa>/` (modelo `dev-*`); esta skill **indexa y resume**, no duplica. Links relativos = version-locked (mismo tag del release, `v5.2.0`; `gemspec.files` incluye `docs/**`, así que estos archivos viajan dentro del `.gem` que ya tenés instalado).
68
+ El detalle vive en `docs/<capa>/` (modelo `dev-*`); esta skill **indexa y resume**, no duplica. Links relativos = version-locked (mismo tag del release, `v5.4.0`; `gemspec.files` incluye `docs/**`, así que estos archivos viajan dentro del `.gem` que ya tenés instalado).
67
69
 
68
70
  | Capa | Artefacto | Estado |
69
71
  |---|---|---|
70
72
  | Glosario de dominio | [docs/glossary/glossary.md](../docs/glossary/glossary.md) | parcial, acreta por PR |
71
- | Comportamiento (flujos) | [docs/behavior/behavior.md](../docs/behavior/behavior.md) | completa — 6 flujos |
73
+ | Comportamiento (flujos) | [docs/behavior/behavior.md](../docs/behavior/behavior.md) | completa — 8 flujos |
72
74
  | Configuración | [docs/config/configuracion.md](../docs/config/configuracion.md) | §a-§e/§i estructura + §f/§g/§h enrich — completa |
73
75
  | Dependencias consumidas | [docs/consumed/rabbitmq.md](../docs/consumed/rabbitmq.md) | §a/§b/§d estructura + §c/§e enrich |
74
76
  | Errores | [docs/errors/errors.md](../docs/errors/errors.md) | §a/§b/§d completas; §c política inferida (verificación humana pendiente) |
75
- | Test | [docs/test/testing.md](../docs/test/testing.md) | §a-§h — 16 unit / 7 integration |
77
+ | Test | [docs/test/testing.md](../docs/test/testing.md) | §a-§h — 18 unit / 8 integration / 1 rails (`spec/rails/`, en su propio proceso) |
76
78
  | Release | [docs/release/release.md](../docs/release/release.md) | completa (régimen gema: build→publish; §e/f/g n/a) |
77
79
  | Datos | — | n/a — gema sin DB |
78
80
  | Eventos | — | n/a — la gema **es** el transporte; no declara catálogo de eventos de dominio propio |
@@ -139,7 +141,8 @@ Por RFC-008 §2: no se fabrica la capa, no se borra contrato sin destino, no se
139
141
  | `BugBunny::Producer` | Publica mensajes. Implementa tres modos: `#fire` (async), `#confirmed` (sync con `wait_for_confirms`) y `#rpc` (direct reply-to + `Concurrent::IVar`). |
140
142
  | `BugBunny::Client` | API de alto nivel. Pool de conexiones y middleware stack (onion architecture). |
141
143
  | `BugBunny::Consumer` | Subscribe loop con health check. Rutea mensajes via `BugBunny.routes`. |
142
- | `BugBunny::ConsumerMiddleware::Stack` | Pipeline de middlewares antes de `process_message`. Thread-safe. |
144
+ | `BugBunny::ConsumerMiddleware::Stack` | Pipeline de middlewares antes de `process_message`. Thread-safe. `use` agrega al final; `prepend` pone al principio (envuelve a todos). |
145
+ | `BugBunny::ConsumerMiddleware::RailsExecutor` | Sólo en Rails: envuelve cada mensaje con `Rails.application.executor.wrap`, para que el estado por hilo (`CurrentAttributes`, conexión de AR) no pase al siguiente. Lo registra el Railtie primero; se apaga con `config.consumer_rails_executor = false`. |
143
146
  | `BugBunny::Controller` | Base class tipo Rails. `before_action`, `around_action`, `after_action`, `rescue_from`, `render`. |
144
147
  | `BugBunny::Resource` | ORM sobre AMQP. `find`, `where`, `create`, `save`, `destroy`. ActiveModel validations y callbacks. |
145
148
  | `BugBunny::Routing::RouteSet` | DSL de rutas: `resources`, `namespace`, `member`, `collection`. |
@@ -147,7 +150,7 @@ Por RFC-008 §2: no se fabrica la capa, no se borra contrato sin destino, no se
147
150
  | `BugBunny::Middleware::Stack` | Builder de middlewares client-side (onion architecture tipo Faraday). |
148
151
  | BugBunny::Request | Value object del mensaje saliente con metadata AMQP completa. |
149
152
  | BugBunny::OTel | Helpers para emitir campos siguiendo las OTel semantic conventions for messaging. |
150
- | BugBunny::Railtie | Integración Rails: autoload de `app/rabbit`, fork safety (Puma, Spring). |
153
+ | BugBunny::Railtie | Integración Rails: autoload de `app/rabbit`, fork safety (Puma, Spring), executor de Rails alrededor de cada mensaje del Consumer. |
151
154
 
152
155
  ---
153
156
 
@@ -368,7 +371,7 @@ client.publish('foo', confirmed: true, mandatory: true, return_raise: false, bod
368
371
  ## FAQ
369
372
 
370
373
  ### ¿Cómo se integra con Rails?
371
- `rails generate bug_bunny:install` genera el inicializador, crea `app/bug_bunny/controllers/` y actualiza `CLAUDE.md`. El pool se define en el inicializador y se asigna a `BugBunny::Resource.connection_pool`.
374
+ `rails generate bug_bunny:install` genera el inicializador y crea `app/bug_bunny/controllers/`. El pool se define en el inicializador y se asigna a `BugBunny::Resource.connection_pool`.
372
375
 
373
376
  ### ¿Cómo funciona el Health Check?
374
377
  El consumer ejecuta un check periódico (default 60s) que verifica la conexión AMQP con un `queue.declare(passive: true)`. Si `health_check_file` está configurado, actualiza su mtime. En Kubernetes, usar un `livenessProbe` tipo `exec` que verifique recencia del archivo.
@@ -386,6 +389,9 @@ Cada slot del pool cachea su `Session` y `Producer` durante su vida útil. Esto
386
389
  ### ¿Cómo funciona fork safety?
387
390
  `BugBunny::Railtie` registra hooks en `ActiveSupport::ForkTracker` (Rails 7.1+), `Puma.events.on_worker_boot` y `Spring.after_fork` para llamar `BugBunny.disconnect` y evitar sockets TCP heredados.
388
391
 
392
+ ### ¿Por qué el estado de un mensaje no pasa al siguiente?
393
+ El Consumer procesa en el hilo de trabajo de Bunny, que Rails no conoce. En Rails, el Railtie registra `ConsumerMiddleware::RailsExecutor` al principio de la cadena (`prepend`), que envuelve cada mensaje con `Rails.application.executor.wrap`: al entrar y al salir se resetean los `CurrentAttributes`, y al salir la conexión de ActiveRecord vuelve al pool. Va primero para envolver también a los middlewares que cargan estado por hilo (el de tracing de ExisRay). **Cambios de conducta:** en Rails ≥ 7.0, un error que escapa del mensaje además se reporta a `Rails.error` con `handled: false` (el mensaje se sigue rechazando sin requeue); y la caché de queries de AR queda prendida durante cada mensaje (en el hilo de Bunny estaba apagada). Apagado: `config.consumer_rails_executor = false`.
394
+
389
395
  ---
390
396
 
391
397
  ## Antipatrones
@@ -87,6 +87,15 @@ BugBunny.configuration.consumer_middlewares.use MyTracing::Middleware
87
87
  BugBunny.configuration.consumer_middlewares.use MyAuth::Middleware
88
88
  ```
89
89
 
90
+ `use` agrega al final de la cadena; `prepend` pone al principio, envolviendo a todos.
91
+
92
+ ### Executor de Rails (automático en Rails)
93
+
94
+ En Rails, el Railtie registra `BugBunny::ConsumerMiddleware::RailsExecutor` **primero**: cada mensaje corre dentro
95
+ de `Rails.application.executor.wrap`, así que los `CurrentAttributes` no pasan de un mensaje al siguiente y la
96
+ conexión de ActiveRecord vuelve al pool. Cambios de conducta: en Rails ≥ 7.0, un error que escapa del mensaje además
97
+ se reporta a `Rails.error`, y la caché de queries de AR queda prendida durante cada mensaje. Se apaga con `config.consumer_rails_executor = false` (desde `config/initializers`).
98
+
90
99
  ### Crear Middleware
91
100
 
92
101
  ```ruby
@@ -131,7 +131,10 @@ TEST_POOL = ConnectionPool.new(size: 5) { BugBunny.create_connection }
131
131
  ## Ejecutar Tests
132
132
 
133
133
  ```bash
134
- bundle exec rspec # Todos
134
+ bundle exec rake # Todos: spec/ y spec/rails/ (cada una en su proceso)
135
+ bundle exec rspec # spec/, sin Rails (.rspec excluye spec/rails/ si no se la pide)
136
+ bundle exec rspec spec/rails # Solo el Railtie (igual que rake spec:rails)
137
+ bundle exec rake spec:rails # Solo el Railtie, con una app Rails mínima
135
138
  bundle exec rspec spec/unit/ # Solo unit
136
139
  bundle exec rspec spec/integration/ # Solo integration (requiere RabbitMQ)
137
140
  bundle exec rspec spec/unit/session_spec.rb # Archivo específico
data/spec/rails/app.rb ADDED
@@ -0,0 +1,70 @@
1
+ # frozen_string_literal: true
2
+
3
+ # App Rails mínima para probar el Railtie de BugBunny con Rails de verdad (ActiveRecord sobre SQLite
4
+ # en memoria).
5
+ #
6
+ # Rails se inicializa una vez por proceso, así que estos specs corren en su propio proceso
7
+ # (`rake spec:rails`): la suite de `spec/` sigue probando la gema fuera de Rails. Para bootear con
8
+ # otra configuración, el spec corre este archivo solo, en un subproceso (`ruby spec/rails/app.rb`),
9
+ # y lee la cadena de middlewares que imprime.
10
+ #
11
+ # `BUG_BUNNY_SPEC_EXECUTOR=off` bootea con `config.consumer_rails_executor = false`.
12
+ # `BUG_BUNNY_SPEC_CONFIGURE=none` bootea sin llamar a `BugBunny.configure` ni registrar otros middlewares:
13
+ # la configuración queda la de default.
14
+
15
+ ENV['RAILS_ENV'] = 'test'
16
+ ENV['DATABASE_URL'] = 'sqlite3::memory:'
17
+
18
+ require 'bundler/setup'
19
+ require 'logger'
20
+ require 'rails'
21
+ require 'active_record/railtie'
22
+ require 'bug_bunny'
23
+
24
+ module BugBunnyRailsSpec
25
+ # La app: sin archivos de configuración propios, todo acá.
26
+ class Application < Rails::Application
27
+ config.root = __dir__
28
+ config.eager_load = false
29
+ config.logger = Logger.new(nil)
30
+ config.secret_key_base = 'bug_bunny-rails-spec'
31
+ end
32
+
33
+ # Lo que un mensaje deja por hilo: lo que los specs miran pasar (o no) al siguiente.
34
+ class LeftoverState < ActiveSupport::CurrentAttributes
35
+ attribute :value
36
+ end
37
+
38
+ # Contexto de traza, como el `ExisRay::Tracer` de ExisRay: un `CurrentAttributes`.
39
+ class TraceContext < ActiveSupport::CurrentAttributes
40
+ attribute :trace_id
41
+ end
42
+
43
+ # Un middleware que carga estado por hilo antes de procesar el mensaje y lo limpia al salir, como
44
+ # el de tracing de ExisRay. Se registra ANTES de que el Railtie de BugBunny registre el suyo: es el
45
+ # orden que hace falta para ver si el executor lo borra.
46
+ class TracingMiddleware < BugBunny::ConsumerMiddleware::Base
47
+ def call(delivery_info, properties, body)
48
+ TraceContext.trace_id = 'from-tracing'
49
+ @app.call(delivery_info, properties, body)
50
+ ensure
51
+ TraceContext.reset
52
+ end
53
+ end
54
+ end
55
+
56
+ unless ENV['BUG_BUNNY_SPEC_CONFIGURE'] == 'none'
57
+ BugBunny.configure do |config|
58
+ config.logger = Logger.new(nil)
59
+ # El `respond_to?` deja correr estos specs contra una versión de la gema sin la opción, para ver
60
+ # que fallan sin el cambio.
61
+ if config.respond_to?(:consumer_rails_executor=)
62
+ config.consumer_rails_executor = ENV['BUG_BUNNY_SPEC_EXECUTOR'] != 'off'
63
+ end
64
+ end
65
+ BugBunny.consumer_middlewares.use(BugBunnyRailsSpec::TracingMiddleware)
66
+ end
67
+
68
+ BugBunnyRailsSpec::Application.initialize!
69
+
70
+ puts BugBunny.consumer_middlewares.instance_variable_get(:@middlewares).map(&:name) if $PROGRAM_NAME == __FILE__
@@ -0,0 +1,165 @@
1
+ # frozen_string_literal: true
2
+
3
+ require_relative 'rails_helper'
4
+ require 'open3'
5
+
6
+ # Cada mensaje del Consumer corre dentro del executor de Rails (sequre/bug_bunny#70).
7
+ #
8
+ # Las entregas se procesan en un hilo propio, como el hilo de trabajo de Bunny: Rails no lo conoce.
9
+ RSpec.describe 'BugBunny::ConsumerMiddleware::RailsExecutor' do
10
+ let(:channel) do
11
+ double('channel').tap do |ch|
12
+ allow(ch).to receive(:ack)
13
+ allow(ch).to receive(:reject)
14
+ allow(ch).to receive(:open?).and_return(true)
15
+ end
16
+ end
17
+
18
+ let(:consumer) do
19
+ session = instance_double(BugBunny::Session, channel: channel, close: nil)
20
+ described_consumer = BugBunny::Consumer.new(double('connection'))
21
+ described_consumer.instance_variable_set(:@session, session)
22
+ described_consumer
23
+ end
24
+
25
+ let(:properties) do
26
+ double('properties', type: 'probe/show', headers: { 'x-http-method' => 'GET' },
27
+ correlation_id: 'corr-1', reply_to: nil, content_type: 'application/json')
28
+ end
29
+
30
+ # Lo que hace la acción del controller en cada entrega.
31
+ let(:on_message) { -> {} }
32
+
33
+ before do
34
+ allow(BugBunny.routes).to receive(:recognize)
35
+ .and_return({ controller: 'probe', action: 'show', params: {}, namespace: nil })
36
+
37
+ handler = on_message
38
+ stub_const('BugBunny::Controllers::ProbeController', Class.new(BugBunny::Controller) do
39
+ define_method(:show) do
40
+ handler.call
41
+ render status: 200, json: {}
42
+ end
43
+ end)
44
+ end
45
+
46
+ # Procesa las entregas en orden, en un hilo propio (como el de Bunny).
47
+ def deliver_on_a_bunny_like_thread(*tags)
48
+ Thread.new do
49
+ tags.each do |tag|
50
+ delivery_info = double('delivery_info', exchange: 'x', routing_key: 'probe', delivery_tag: tag,
51
+ redelivered?: false)
52
+ yield(:before, tag) if block_given?
53
+ consumer.send(:handle_delivery, delivery_info, properties, '{}')
54
+ yield(:after, tag) if block_given?
55
+ end
56
+ end.join
57
+ end
58
+
59
+ it 'queda primero en la cadena, antes del middleware de tracing registrado antes que él' do
60
+ middlewares = BugBunny.consumer_middlewares.instance_variable_get(:@middlewares).map(&:name)
61
+
62
+ expect(middlewares).to eq(%w[BugBunny::ConsumerMiddleware::RailsExecutor BugBunnyRailsSpec::TracingMiddleware])
63
+ end
64
+
65
+ describe 'el estado por hilo no pasa de un mensaje al siguiente' do
66
+ let(:seen) { [] }
67
+ let(:on_message) do
68
+ lambda do
69
+ seen << BugBunnyRailsSpec::LeftoverState.value
70
+ BugBunnyRailsSpec::LeftoverState.value = 'left by the previous message'
71
+ end
72
+ end
73
+
74
+ it 'el segundo mensaje arranca sin lo que el primero dejó en un CurrentAttributes' do
75
+ deliver_on_a_bunny_like_thread(1, 2)
76
+
77
+ expect(seen).to eq([nil, nil])
78
+ end
79
+ end
80
+
81
+ describe 'la conexión de ActiveRecord' do
82
+ # Si el hilo tiene una conexión tomada del pool (en Rails 8.1, `active_connection?` devuelve la
83
+ # conexión, o nil).
84
+ def connection_leased?
85
+ ActiveRecord::Base.connection_pool.active_connection?.present?
86
+ end
87
+
88
+ let(:inside) { [] }
89
+ let(:on_message) do
90
+ lambda do
91
+ ActiveRecord::Base.connection.execute('SELECT 1')
92
+ inside << connection_leased?
93
+ end
94
+ end
95
+
96
+ it 'vuelve al pool al terminar el mensaje que la usó' do
97
+ after = []
98
+ deliver_on_a_bunny_like_thread(1) do |moment, _tag|
99
+ after << connection_leased? if moment == :after
100
+ end
101
+
102
+ expect(inside).to eq([true]) # el mensaje la usó
103
+ expect(after).to eq([false]) # y al terminar ya no la tiene el hilo
104
+ end
105
+ end
106
+
107
+ describe 'un middleware que carga estado antes que el executor' do
108
+ let(:seen) { [] }
109
+ let(:on_message) { -> { seen << BugBunnyRailsSpec::TraceContext.trace_id } }
110
+
111
+ it 'conserva ese estado dentro del mensaje: el executor lo envuelve y no lo borra' do
112
+ deliver_on_a_bunny_like_thread(1)
113
+
114
+ expect(seen).to eq(['from-tracing'])
115
+ end
116
+ end
117
+
118
+ describe 'un error que escapa del procesamiento del mensaje' do
119
+ let(:reports) { [] }
120
+ let(:subscriber) do
121
+ collected = reports
122
+ Class.new do
123
+ define_method(:report) { |error, handled:, **| collected << [error.message, handled] }
124
+ end.new
125
+ end
126
+
127
+ before { Rails.error.subscribe(subscriber) }
128
+ after { Rails.error.unsubscribe(subscriber) if Rails.error.respond_to?(:unsubscribe) } # no existe en Rails 7.0
129
+
130
+ it 'termina en un reject sin requeue, como hoy, y además se reporta a Rails.error' do
131
+ allow(consumer).to receive(:process_message).and_raise(RuntimeError, 'boom')
132
+
133
+ deliver_on_a_bunny_like_thread(7)
134
+
135
+ expect(channel).to have_received(:reject).with(7, false)
136
+ expect(reports).to eq([['boom', false]])
137
+ end
138
+ end
139
+
140
+ describe 'config.consumer_rails_executor' do
141
+ # Rails se inicializa una vez por proceso: la app se bootea de nuevo en un subproceso.
142
+ # Las líneas de stdout que nombran un middleware: un warning del entorno no las rompe.
143
+ def middlewares_after_boot(env)
144
+ app = File.expand_path('app.rb', __dir__)
145
+ stdout, stderr, status = Open3.capture3(env, RbConfig.ruby, app)
146
+ raise "la app no booteó:\n#{stderr}" unless status.success?
147
+
148
+ stdout.lines.map(&:strip).grep(/\ABugBunny/)
149
+ end
150
+
151
+ it 'con false, no registra el middleware' do
152
+ expect(middlewares_after_boot('BUG_BUNNY_SPEC_EXECUTOR' => 'off')).to eq(['BugBunnyRailsSpec::TracingMiddleware'])
153
+ end
154
+
155
+ it 'con true, lo registra primero' do
156
+ expect(middlewares_after_boot('BUG_BUNNY_SPEC_EXECUTOR' => 'on'))
157
+ .to eq(%w[BugBunny::ConsumerMiddleware::RailsExecutor BugBunnyRailsSpec::TracingMiddleware])
158
+ end
159
+
160
+ it 'sin BugBunny.configure previo, bootea y lo registra: la opción ausente vale su default' do
161
+ expect(middlewares_after_boot('BUG_BUNNY_SPEC_CONFIGURE' => 'none'))
162
+ .to eq(['BugBunny::ConsumerMiddleware::RailsExecutor'])
163
+ end
164
+ end
165
+ end
@@ -0,0 +1,66 @@
1
+ # frozen_string_literal: true
2
+
3
+ require_relative 'rails_helper'
4
+ require 'rails/generators'
5
+ require 'stringio'
6
+ require 'tmpdir'
7
+ require 'generators/bug_bunny/install/install_generator'
8
+
9
+ # El generador de instalación no escribe nada fuera de lo que la gema necesita: ni crea ni modifica
10
+ # el `CLAUDE.md` del repo que la usa (sequre/bug_bunny#72).
11
+ RSpec.describe BugBunny::Generators::InstallGenerator do
12
+ let(:template) { File.expand_path('../../lib/generators/bug_bunny/install/templates/initializer.rb', __dir__) }
13
+
14
+ # Corre el generador sobre `dir` y devuelve lo que imprimió.
15
+ def run_generator(dir)
16
+ output = StringIO.new
17
+ original_stdout = $stdout
18
+ $stdout = output
19
+ described_class.start([], destination_root: dir)
20
+ output.string
21
+ ensure
22
+ $stdout = original_stdout
23
+ end
24
+
25
+ around do |example|
26
+ Dir.mktmpdir('bug_bunny-generator') do |dir|
27
+ @dir = dir
28
+ example.run
29
+ end
30
+ end
31
+
32
+ let(:claude_md) { File.join(@dir, 'CLAUDE.md') }
33
+
34
+ it 'does not create CLAUDE.md' do
35
+ run_generator(@dir)
36
+
37
+ expect(File.exist?(claude_md)).to be(false)
38
+ end
39
+
40
+ it 'leaves an existing CLAUDE.md untouched' do
41
+ original = "# App\n\n## Gemas internas\n"
42
+ File.write(claude_md, original)
43
+
44
+ run_generator(@dir)
45
+
46
+ expect(File.read(claude_md)).to eq(original)
47
+ end
48
+
49
+ it 'still creates the initializer and the controllers directory' do
50
+ run_generator(@dir)
51
+
52
+ expect(File.read(File.join(@dir, 'config/initializers/bug_bunny.rb'))).to eq(File.read(template))
53
+ expect(File.exist?(File.join(@dir, 'app/bug_bunny/controllers/.keep'))).to be(true)
54
+ end
55
+
56
+ it 'does not mention CLAUDE.md nor bug_bunny:sync in its output' do
57
+ output = run_generator(@dir)
58
+
59
+ expect(output).not_to include('CLAUDE.md')
60
+ expect(output).not_to include('bug_bunny:sync')
61
+ end
62
+
63
+ it 'only runs the initializer and directories steps' do
64
+ expect(described_class.all_tasks.keys).to eq(%w[create_initializer create_directories])
65
+ end
66
+ end
@@ -0,0 +1,6 @@
1
+ # frozen_string_literal: true
2
+
3
+ # Helper de los specs que corren dentro de Rails. Se carga sólo desde `rake spec:rails`, en un
4
+ # proceso aparte del resto de la suite (ver spec/rails/app.rb).
5
+
6
+ require_relative 'app'
@@ -0,0 +1,21 @@
1
+ # frozen_string_literal: true
2
+
3
+ require_relative 'rails_helper'
4
+ require 'rake'
5
+
6
+ # El Railtie no registra tareas de rake: la que había, `bug_bunny:sync`, escribía el `CLAUDE.md` del repo
7
+ # que usa la gema (sequre/bug_bunny#72).
8
+ RSpec.describe 'BugBunny::Railtie rake tasks' do
9
+ before(:all) do
10
+ Rake.application = Rake::Application.new
11
+ Rails.application.load_tasks
12
+ end
13
+
14
+ it 'does not define bug_bunny:sync' do
15
+ expect(Rake::Task.task_defined?('bug_bunny:sync')).to be(false)
16
+ end
17
+
18
+ it 'loads the application tasks' do
19
+ expect(Rake::Task.task_defined?('environment')).to be(true)
20
+ end
21
+ end
@@ -188,6 +188,12 @@ RSpec.describe BugBunny::Configuration do
188
188
  end
189
189
  end
190
190
 
191
+ describe 'consumer_rails_executor flag' do
192
+ it 'tiene default true (el Railtie envuelve cada mensaje con el executor de Rails)' do
193
+ expect(BugBunny::Configuration.new.consumer_rails_executor).to be(true)
194
+ end
195
+ end
196
+
191
197
  describe 'nack_raise flag' do
192
198
  it 'tiene default true (raise PublishNacked en NACK)' do
193
199
  expect(BugBunny::Configuration.new.nack_raise).to be(true)
@@ -47,6 +47,19 @@ RSpec.describe BugBunny::ConsumerMiddleware::Stack do
47
47
  end
48
48
  end
49
49
 
50
+ describe '#prepend' do
51
+ it 'registra el middleware al principio: envuelve a los ya registrados' do
52
+ log = []
53
+ stack.use(tracking_middleware(log, :a))
54
+ result = stack.prepend(tracking_middleware(log, :first))
55
+
56
+ stack.call(delivery_info, properties, body) { log << :core }
57
+
58
+ expect(result).to be(stack)
59
+ expect(log).to eq(%i[first_before a_before core a_after first_after])
60
+ end
61
+ end
62
+
50
63
  describe '#empty?' do
51
64
  it 'retorna true cuando no hay middlewares' do
52
65
  expect(stack.empty?).to be(true)
@@ -0,0 +1,19 @@
1
+ # frozen_string_literal: true
2
+
3
+ require 'spec_helper'
4
+
5
+ # Fuera de Rails la gema se comporta como antes de sequre/bug_bunny#70: el middleware del executor
6
+ # lo registra el Railtie, y el Railtie no se carga.
7
+ RSpec.describe 'BugBunny fuera de Rails' do
8
+ it 'no carga el Railtie' do
9
+ expect(defined?(Rails)).to be_nil
10
+ expect(defined?(BugBunny::Railtie)).to be_nil
11
+ end
12
+
13
+ it 'no carga el middleware del executor ni lo pone en la cadena del Consumer' do
14
+ middlewares = BugBunny.consumer_middlewares.instance_variable_get(:@middlewares).map(&:name)
15
+
16
+ expect(defined?(BugBunny::ConsumerMiddleware::RailsExecutor)).to be_nil
17
+ expect(middlewares).not_to include('BugBunny::ConsumerMiddleware::RailsExecutor')
18
+ end
19
+ end