#!/usr/bin/env ruby # frozen_string_literal: true # tool_humo_pool.rb — Pool de tests de humo: rotación + salud + mecanismo de # reserva/reporte (P204/Fase3-4) # ============================================================================== # Formaliza las verificaciones ad-hoc hechas durante P204 (pedido del Operador: # re-correrlas cuando se toque el mecanismo de nuevo, no reinventarlas cada # vez). Corre LOCAL contra lib_registro.rb — sin pasar por HTTP/server.rb, mismo # criterio que las pruebas aisladas de Fase 3. # # Todo lo destructivo (reserva, rotación, reportar) usa un provider/keys # DESCARTABLES ('selftest', nunca un provider real) — nunca toca keys reales # ni su estado. La única sección de solo-lectura ("salud actual") sí lee el # registro real, pero nunca dispensa ni reserva nada (mismo espíritu que # dry_run) — reporta el estado tal cual está, no lo cambia. # ============================================================================== # Uso: ruby tool_humo_pool.rb (correr como usuario 'nexxa' — dueño de # registro.json — o con permisos de lectura/ # escritura sobre él) # ============================================================================== require_relative 'lib_registro' require_relative 'lib_tokens' require_relative 'lib_envelope' require 'openssl' require 'base64' PROVIDER_TEST = 'selftest' INDIVIDUO_TEST = 'selftest' $fallas = 0 $total = 0 def test(nombre) $total += 1 yield puts " ✅ #{nombre}" rescue StandardError => e $fallas += 1 puts " ❌ #{nombre} — #{e.class}: #{e.message}" end def assert(cond, msg) raise msg unless cond end def limpiar_provider_test Nexxa::Registro.leer['keys'] .select { |k| k['provider'] == PROVIDER_TEST } .each { |k| Nexxa::Registro.eliminar(provider: PROVIDER_TEST, identificador: k['identificador']) } end puts "\n🧪 Pool de tests NEXXA — rotación + salud + reserva/reporte (P204)\n\n" # ------------------------------------------------------------------ puts '→ Salud actual (solo lectura, keys REALES — nunca dispensa)' ahora = Time.now providers_reales = Nexxa::Registro.leer['keys'].map { |k| k['provider'] }.uniq test('lee el registro real sin explotar') do assert(Nexxa::Registro.leer.is_a?(Hash), 'leer() no devolvió un Hash') end providers_reales.each do |provider| # El estado de la taxonomía única (Registro.estado_de, P337/Fase 1), nunca recalculado acá Nexxa::Registro.estado_pool(provider, ahora).each do |k| icono = { 'disponible' => '🟢', 'en_uso' => '🔵', 'en_pausa' => '🟡', 'agotada' => '🔴', 'desactivada' => '⚪', 'sin_valor' => '▫️' }[k['estado']] puts " #{icono} #{provider}/#{k['identificador']}: #{k['estado']}#{k['hasta'] ? " hasta #{k['hasta']}" : ''}" end end # ------------------------------------------------------------------ puts "\n→ Mecanismo de reserva/reporte (provider descartable '#{PROVIDER_TEST}')" limpiar_provider_test Nexxa::Registro.registrar(provider: PROVIDER_TEST, identificador: 'k1', cuenta_origen: 'test', reset_segundos: 3) test('key recén registrada está disponible') do assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'no debería estar nil') end test('reservar bloquea la key para otros consumidores') do Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA') assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'sigue apareciendo disponible con reserva activa') end test('reportar rechaza a un individuo que no tiene la reserva') do begin Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testB', estado: 'sana') raise 'no lanzó excepción' rescue RuntimeError # esperado end end test("estado 'sana' renueva la reserva (sigue no disponible)") do Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'sana') assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'debería seguir reservada tras "sana"') end test("estado 'liberada' libera de inmediato") do Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'liberada') assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería estar disponible tras "liberada"') end test("estado 'agotada' con liberar_en_segundos aplica el valor custom, no reset_segundos") do Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA') Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'agotada', liberar_en_segundos: 2) assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'debería estar agotada inmediatamente después') sleep 2.2 assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería liberarse tras los 2s custom') end test('reserva sin ningún reporte vence sola (pasivo)') do Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA') state = Nexxa::Registro.leer entrada = state['keys'].find { |k| k['identificador'] == 'k1' } entrada['reservado_hasta'] = (Time.now - 1).iso8601(3) Nexxa::Registro.guardar(state) assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería estar libre con reserva vencida') end # ------------------------------------------------------------------ puts "\n→ Rotación del pool (menos usada recientemente, no siempre la primera)" limpiar_provider_test %w[k1 k2 k3].each { |id| Nexxa::Registro.registrar(provider: PROVIDER_TEST, identificador: id, cuenta_origen: 'test', reset_segundos: 100) } # ultimo_uso explícito y bien separado (determinismo — 3 registrar() seguidos # pueden empatar en el mismo milisegundo según qué tan rápido corra la CPU/ # disco, sin relación con el mecanismo real que se está probando) state = Nexxa::Registro.leer base = Time.now - 30 %w[k1 k2 k3].each_with_index do |id, i| entrada = state['keys'].find { |k| k['provider'] == PROVIDER_TEST && k['identificador'] == id } entrada['ultimo_uso'] = (base + i).iso8601(3) end Nexxa::Registro.guardar(state) test('6 pedidos seguidos rotan k1→k2→k3→k1→k2→k3, sin repetir de corrido') do orden = [] 6.times do k = Nexxa::Registro.disponible(PROVIDER_TEST) orden << k['identificador'] Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot') Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot', estado: 'liberada') # separación real entre picks — evita empates de milisegundo entre # reservar() consecutivos en un loop apretado (nunca pasa en uso real: # nadie dispensa+reporta 2 keys en el mismo milisegundo) sleep 0.01 end esperado = %w[k1 k2 k3 k1 k2 k3] assert(orden == esperado, "orden real: #{orden.join('→')} (esperado: #{esperado.join('→')})") end test('una key agotada no entra en la rotación hasta liberarse') do Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k2', individuo: 'rot') Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k2', individuo: 'rot', estado: 'agotada', liberar_en_segundos: 999) 3.times do k = Nexxa::Registro.disponible(PROVIDER_TEST) assert(k['identificador'] != 'k2', 'k2 no debería salir elegida estando agotada') Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot') Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot', estado: 'liberada') end end limpiar_provider_test # ------------------------------------------------------------------ puts "\n→ Cifrado de punta a punta (P204, envelope RSA-OAEP)" def limpiar_individuo_test state = Nexxa::Tokens.leer state['tokens'].reject! { |t| t['individuo'] == INDIVIDUO_TEST } Nexxa::Tokens.guardar(state) end limpiar_individuo_test Nexxa::Tokens.generar(INDIVIDUO_TEST) par_test = OpenSSL::PKey::RSA.generate(2048) test('registrar_clave_publica guarda y releer coincide exacto') do Nexxa::Tokens.registrar_clave_publica(individuo: INDIVIDUO_TEST, clave_publica_pem: par_test.public_key.to_pem) assert(Nexxa::Tokens.clave_publica(INDIVIDUO_TEST) == par_test.public_key.to_pem, 'la clave releída no coincide con la guardada') end test('rechaza una clave pública inválida (no PEM)') do begin Nexxa::Tokens.registrar_clave_publica(individuo: INDIVIDUO_TEST, clave_publica_pem: 'no es una clave') raise 'no lanzó excepción' rescue RuntimeError # esperado end end test('rechaza registrar clave para un individuo sin token') do begin Nexxa::Tokens.registrar_clave_publica(individuo: 'no-existe-de-verdad', clave_publica_pem: par_test.public_key.to_pem) raise 'no lanzó excepción' rescue RuntimeError # esperado end end test('Envelope.cifrar_para produce algo distinto del valor real') do valor = 'valor-de-prueba-no-es-un-secreto-real' cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor) assert(cifrado != valor, 'el cifrado es igual al valor real — no cifró nada') end test('round-trip: cifrar con la pública + descifrar con la privada = valor original') do valor = 'valor-de-prueba-no-es-un-secreto-real' cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor) descifrado = par_test.private_decrypt(Base64.strict_decode64(cifrado), OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING) assert(descifrado == valor, "descifrado (#{descifrado.inspect}) no coincide con el original") end test('la clave pública sola NO alcanza para descifrar (asimetría real)') do valor = 'valor-de-prueba-no-es-un-secreto-real' cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor) begin par_test.public_decrypt(Base64.strict_decode64(cifrado)) raise 'se pudo descifrar solo con la pública — esto NO debería pasar' rescue OpenSSL::PKey::RSAError # esperado — confirma que es asimétrico de verdad end end test('sin clave pública registrada, empaquetar_valor cae a texto plano (compatibilidad)') do assert(Nexxa::Tokens.clave_publica('individuo-sin-clave-nunca-registrada').nil?, 'debería ser nil para un individuo sin clave') end limpiar_individuo_test # ------------------------------------------------------------------ puts "\n#{$fallas.zero? ? '✅' : '❌'} #{$total - $fallas}/#{$total} tests OK\n\n" exit($fallas.zero? ? 0 : 1)