feat(nexxa): NEXXA versionada en dtic-DIIAA (1.3.0): pools por individuo mente/red, API por rol y gestión desde nexxa-web
Tests ADN / test (push) Canceled after 0s
Tests ADN / test (push) Canceled after 0s
- Base: código de producción de srvv-nexxa (1.2.1), importado y verificado por hash (P335/F3) - Pools por individuo (lib_pools): mente y red, mezclan proveedores, keys compartidas o exclusivas - API: /disponible/mente|red y /estado por rol, pool_vacio explícito, /pools (CRUD admin), liberar admin - Revertir el agotada propio + motivo y quién la agotó (de P334/F4) - nexxa-web: sección Pools, motivo y botón Liberar, provider libre con sugerencias, escape de texto externo - Convención REG002: lib_*, cli_*, tool_humo_pool; contratos externos con su nombre - Suite local sobre copia aislada: humo HTTP, pools, revertir; servidor_prueba para mirar la web Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-Authored-By: GEMMA <noreply@gemma.dtic>
This commit is contained in:
co-authored by
Claude Opus 5.5
GEMMA
parent
50ac0d0fdf
commit
a60758875d
@@ -0,0 +1,245 @@
|
||||
#!/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|
|
||||
keys = Nexxa::Registro.leer['keys'].select { |k| k['provider'] == provider }
|
||||
keys.each do |k|
|
||||
agotada = Time.parse(k['disponible_desde']) > ahora
|
||||
reservada = !agotada && k['reservado_hasta'] && Time.parse(k['reservado_hasta']) > ahora
|
||||
estado = if k['activo'] == false then 'desactivada'
|
||||
elsif agotada then 'agotada'
|
||||
elsif reservada then 'reservada'
|
||||
else 'disponible'
|
||||
end
|
||||
icono = { 'disponible' => '🟢', 'reservada' => '🔵', 'agotada' => '🔴', 'desactivada' => '⚪' }[estado]
|
||||
puts " #{icono} #{provider}/#{k['identificador']}: #{estado}"
|
||||
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)
|
||||
Reference in New Issue
Block a user