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

- 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:
Ricardo Monla
2026-10-04 16:42:13 -03:00
co-authored by Claude Opus 5.5 GEMMA
parent 50ac0d0fdf
commit a60758875d
31 changed files with 5653 additions and 0 deletions
+96
View File
@@ -0,0 +1,96 @@
# frozen_string_literal: true
# humo_http_test.rb — Humo HTTP REAL del server de NEXXA sobre una copia aislada (P335/Fase 5).
# El server de prueba lo arma lib_servidor_prueba.rb (copia aislada, estado falso, 127.0.0.1). Nunca toca el nodo
# ni secretos reales. Correr después de cada cambio de la API: ruby servicios/nexxa/test/humo_http_test.rb
require 'minitest/autorun'
require 'net/http'
require 'json'
require 'time'
require_relative 'lib_servidor_prueba'
PRUEBA = ServidorPrueba.armar(individuos: %w[gemma-humo liberar-humo])
PUERTO = PRUEBA[:puerto]
TOKEN_IND = PRUEBA[:tokens]['gemma-humo']
TOKEN_LIB = PRUEBA[:tokens]['liberar-humo'] # individuo propio del test de liberar: no comparte estado
PID = ServidorPrueba.arrancar(PRUEBA)
Minitest.after_run { ServidorPrueba.detener(PID, PRUEBA) }
# El server invalida las sesiones al arrancar (P204): se entra por /login, como un usuario real.
def login(usuario)
password = ServidorPrueba::USUARIOS.fetch(usuario).first
r = Net::HTTP.post(URI("http://127.0.0.1:#{PUERTO}/login"), { usuario: usuario, password: password }.to_json,
'Content-Type' => 'application/json')
r['Set-Cookie'].to_s[/nexxa_session=([0-9a-f]+)/, 1] or raise "login de #{usuario} falló: #{r.code} #{r.body}"
end
SES_ADMIN = login('humo-admin')
SES_OPER = login('humo-oper')
class HumoHttpTest < Minitest::Test
def pedir(metodo, ruta, cuerpo: nil, sesion: nil, token: nil)
req = Net::HTTP.const_get(metodo.capitalize).new(ruta)
req['Cookie'] = "nexxa_session=#{sesion}" if sesion
req['Authorization'] = "Bearer #{token}" if token
if cuerpo
req['Content-Type'] = 'application/json'
req.body = cuerpo.to_json
end
r = Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.request(req) }
[r.code.to_i, (JSON.parse(r.body) rescue r.body)]
end
def test_ciclo_pools_y_disponible_por_rol
# sin pool asignado: explícito, nunca cae al provider
assert_equal [404, 'pool_vacio'], pedir('get', '/disponible/mente', token: TOKEN_IND).then { |c, b| [c, b['error']] }
# operador lee pero no asigna; admin asigna
assert_equal 403, pedir('post', '/pools/gemma-humo/mente', cuerpo: { provider: 'deepseek', identificador: 'd-01' }, sesion: SES_OPER)[0]
assert_equal 200, pedir('post', '/pools/gemma-humo/mente', cuerpo: { provider: 'deepseek', identificador: 'd-01' }, sesion: SES_ADMIN)[0]
assert_equal 200, pedir('post', '/pools/gemma-humo/red', cuerpo: { provider: 'gemini', identificador: 'g-02' }, sesion: SES_ADMIN)[0]
assert_equal 400, pedir('post', '/pools/gemma-humo/otro', cuerpo: { provider: 'gemini', identificador: 'g-02' }, sesion: SES_ADMIN)[0]
c, b = pedir('get', '/pools', sesion: SES_OPER)
assert_equal [200, ['d-01']], [c, b.dig('individuos', 'gemma-humo', 'mente').map { |f| f['identificador'] }]
# mente y red dispensan su propia key, con el provider real
c, b = pedir('get', '/disponible/mente', token: TOKEN_IND)
assert_equal [200, 'deepseek', 'd-01'], [c, b['provider'], b['identificador']]
c, b = pedir('get', '/disponible/red?dry_run=1', token: TOKEN_IND)
assert_equal [200, 'gemini', 'g-02'], [c, b['provider'], b['identificador']]
# reportar por rol exige provider; con provider marca agotada con motivo y el estado lo muestra
assert_equal 400, pedir('post', '/disponible/mente/reportar', cuerpo: { identificador: 'd-01', estado: 'agotada' }, token: TOKEN_IND)[0]
c, = pedir('post', '/disponible/mente/reportar', cuerpo: { provider: 'deepseek', identificador: 'd-01', estado: 'agotada', motivo: 'humo' }, token: TOKEN_IND)
assert_equal 200, c
c, b = pedir('get', '/disponible/mente/estado', token: TOKEN_IND)
assert_equal [200, 'mente', %w[agotada humo]], [c, b['rol'], b['keys'][0].values_at('estado', 'motivo')]
assert_equal 'agotado', pedir('get', '/disponible/mente', token: TOKEN_IND)[1]['error']
# compatibilidad: por provider sigue como antes
c, b = pedir('get', '/disponible/gemini?dry_run=1', token: TOKEN_IND)
assert_equal [200, 'gemini'], [c, b['provider']]
# quitar (admin) y borrar una key la saca de todos los pools
assert_equal 200, pedir('delete', '/pools/gemma-humo/mente/deepseek/d-01', sesion: SES_ADMIN)[0]
assert_equal 404, pedir('delete', '/pools/gemma-humo/mente/deepseek/d-01', sesion: SES_ADMIN)[0]
assert_equal 200, pedir('delete', '/keys/gemini/g-02', sesion: SES_ADMIN)[0]
assert_equal({}, pedir('get', '/pools', sesion: SES_OPER)[1]['individuos'])
end
def test_liberar_desde_la_web_solo_admin
# key (groq) e individuo propios: este test no toca nada de lo que usa el ciclo de pools
assert_equal 200, pedir('get', '/disponible/groq', token: TOKEN_LIB)[0]
pedir('post', '/disponible/groq/reportar', cuerpo: { identificador: 'q-lib', estado: 'agotada', motivo: 'humo-web' }, token: TOKEN_LIB)
key = -> { pedir('get', '/keys', sesion: SES_OPER)[1].find { |k| k['identificador'] == 'q-lib' } }
assert_equal %w[liberar-humo humo-web], key.call.values_at('agotada_por', 'motivo_agotada')
assert_equal 'agotado', pedir('get', '/disponible/groq', token: TOKEN_LIB)[1]['error']
assert_equal 403, pedir('post', '/keys/groq/q-lib/liberar', sesion: SES_OPER)[0]
assert_equal 404, pedir('post', '/keys/groq/no-existe/liberar', sesion: SES_ADMIN)[0]
assert_equal 200, pedir('post', '/keys/groq/q-lib/liberar', sesion: SES_ADMIN)[0]
assert_equal [nil, nil], key.call.values_at('agotada_por', 'motivo_agotada')
assert_equal 200, pedir('get', '/disponible/groq?dry_run=1', token: TOKEN_LIB)[0]
end
def test_sin_token_ni_sesion
assert_equal 401, pedir('get', '/disponible/mente')[0]
assert_equal 401, pedir('get', '/pools')[0]
end
end
@@ -0,0 +1,59 @@
# frozen_string_literal: true
# lib_servidor_prueba.rb — NEXXA de PRUEBA sobre una copia aislada (P335/Fase 7). Fuente única para el humo HTTP y para
# mirar nexxa-web en un navegador real sin tocar el nodo ni secretos reales.
# Copia organismo/ y web/ a un directorio temporal, cambia el server a 127.0.0.1 y un puerto libre, y siembra estado
# FALSO: master key, keys con valores inventados, usuarios humo-admin/humo-oper y tokens de individuos.
require 'tmpdir'
require 'fileutils'
require 'socket'
module ServidorPrueba
BASE = File.expand_path('..', __dir__)
USUARIOS = { 'humo-admin' => ['humo-admin-123', 'admin'], 'humo-oper' => ['humo-oper-123', 'operador'] }.freeze
KEYS = [%w[gemini g-01], %w[gemini g-02], %w[deepseek d-01], %w[groq q-lib]].freeze
module_function
# => { dir:, org:, puerto:, tokens: { individuo => token } }
def armar(individuos: %w[gemma-humo liberar-humo], puerto: nil)
dir = Dir.mktmpdir('nexxa-prueba')
%w[organismo web].each { |d| FileUtils.cp_r(File.join(BASE, d), dir) }
org = File.join(dir, 'organismo')
puerto ||= TCPServer.new('127.0.0.1', 0).then { |s| s.addr[1].tap { s.close } }
srv = File.read(File.join(org, 'server.rb'))
.sub(/^PORT = \d+/, "PORT = #{puerto}").sub("BindAddress: '0.0.0.0'", "BindAddress: '127.0.0.1'")
File.write(File.join(org, 'server.rb'), srv)
%w[lib_cripto lib_registro lib_tokens lib_auth lib_pools].each { |f| require File.join(org, f) }
Nexxa::MasterKey.generar_si_falta!
KEYS.each do |p, i|
Nexxa::Registro.registrar(provider: p, identificador: i, cuenta_origen: 'prueba', reset_segundos: 86_400, valor: "falso-#{i}")
end
USUARIOS.each { |u, (pw, perfil)| Nexxa::Auth.crear_usuario(usuario: u, password: pw, perfil: perfil) }
tokens = individuos.to_h { |ind| [ind, Nexxa::Tokens.generar(ind)] }
{ dir: dir, org: org, puerto: puerto, tokens: tokens }
end
# Arranca server.rb de la copia y espera el puerto. => pid
def arrancar(prueba, log: File.join(prueba[:dir], 'server.log'))
pid = Process.spawn('ruby', 'server.rb', chdir: prueba[:org], out: File::NULL, err: log)
60.times { abierto?(prueba[:puerto]) ? break : sleep(0.25) }
raise "El server de prueba no abrió el puerto #{prueba[:puerto]} (ver #{log})" unless abierto?(prueba[:puerto])
pid
end
def detener(pid, prueba)
Process.kill('TERM', pid) rescue nil
Process.wait(pid) rescue nil
FileUtils.rm_rf(prueba[:dir])
end
def abierto?(puerto)
TCPSocket.new('127.0.0.1', puerto).close
true
rescue SystemCallError
false
end
end
+106
View File
@@ -0,0 +1,106 @@
# frozen_string_literal: true
# pools_test.rb — Pools por individuo (P335/Fase 4). Corre sobre una COPIA de organismo/ en un directorio temporal:
# registro.json/pools.json de prueba, nunca los reales. ruby servicios/nexxa/test/pools_test.rb
require 'minitest/autorun'
require 'tmpdir'
require 'fileutils'
DIR_PRUEBA = Dir.mktmpdir('nexxa-pools')
Dir[File.expand_path('../organismo/*.rb', __dir__)].each { |f| FileUtils.cp(f, DIR_PRUEBA) }
require File.join(DIR_PRUEBA, 'lib_registro')
require File.join(DIR_PRUEBA, 'lib_pools')
Minitest.after_run { FileUtils.rm_rf(DIR_PRUEBA) }
class PoolsTest < Minitest::Test
R = Nexxa::Registro
P = Nexxa::Pools
def setup
FileUtils.rm_f([R::STATE_FILE, P::STATE_FILE])
pasado = (Time.now - 3600).iso8601(3)
key = ->(p, i, extra = {}) { { 'provider' => p, 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 86_400 }.merge(extra) }
R.guardar('keys' => [key.('gemini', 'g-01', 'ultimo_uso' => (Time.now - 60).iso8601(3)),
key.('deepseek', 'd-01', 'ultimo_uso' => (Time.now - 600).iso8601(3)),
key.('gemini', 'g-red'),
key.('gemini', 'g-off', 'activo' => false)])
end
def asignar(ind, rol, p, i) = P.asignar(individuo: ind, rol: rol, provider: p, identificador: i)
def test_pool_mezcla_proveedores_y_da_la_menos_usada
asignar('gemma', 'mente', 'gemini', 'g-01')
asignar('gemma', 'mente', 'deepseek', 'd-01')
k = R.disponible_en(P.refs('gemma', 'mente'))
assert_equal %w[deepseek d-01], [k['provider'], k['identificador']]
end
def test_red_separada_de_mente_y_compartida_entre_individuos
asignar('gemma', 'mente', 'gemini', 'g-01')
asignar('gemma', 'red', 'gemini', 'g-red')
asignar('peggy', 'red', 'gemini', 'g-red')
assert_equal 'g-red', R.disponible_en(P.refs('gemma', 'red'))['identificador']
assert_equal [{ 'individuo' => 'gemma', 'rol' => 'red' }, { 'individuo' => 'peggy', 'rol' => 'red' }],
P.de_key('gemini', 'g-red')
end
def test_asignar_es_idempotente_y_valida
2.times { asignar('gemma', 'mente', 'gemini', 'g-01') }
assert_equal ['gemini/g-01'], P.refs('gemma', 'mente')
assert_raises(RuntimeError) { asignar('gemma', 'otro', 'gemini', 'g-01') }
assert_raises(RuntimeError) { asignar('gemma', 'mente', 'gemini', 'no-existe') }
end
def test_desactivada_o_reservada_no_se_da_y_proxima_responde
asignar('gemma', 'mente', 'gemini', 'g-off')
assert_nil R.disponible_en(P.refs('gemma', 'mente'))
assert_nil R.proxima_en(P.refs('gemma', 'mente'))
asignar('gemma', 'mente', 'gemini', 'g-01')
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma')
assert_nil R.disponible_en(P.refs('gemma', 'mente'))
assert_equal 'g-01', R.proxima_en(P.refs('gemma', 'mente'))['identificador']
end
def test_quitar_y_olvidar_no_dejan_refs_colgadas
asignar('gemma', 'mente', 'gemini', 'g-01')
asignar('peggy', 'red', 'gemini', 'g-01')
assert P.quitar(individuo: 'gemma', rol: 'mente', provider: 'gemini', identificador: 'g-01')
refute P.quitar(individuo: 'gemma', rol: 'mente', provider: 'gemini', identificador: 'g-01')
assert P.olvidar_key(provider: 'gemini', identificador: 'g-01')
assert_equal({ 'individuos' => {} }, P.leer)
assert_equal '600', format('%o', File.stat(P::STATE_FILE).mode & 0o777)
end
def test_pool_vacio_no_cae_al_provider
assert_nil R.disponible_en(P.refs('nadie', 'mente'))
assert P.pool_vacio?('nadie', 'mente')
assert_nil P.disponible('nadie', 'mente')
end
# --- Fase 5: selección por nombre (rol o provider) y estado
def test_nombre_rol_usa_el_pool_y_nombre_provider_sigue_igual
asignar('gemma', 'mente', 'deepseek', 'd-01')
assert_equal 'd-01', P.disponible('gemma', 'mente')['identificador']
assert_equal 'gemini', P.disponible('gemma', 'gemini')['provider'] # compatibilidad: por provider, sin pools
refute P.pool_vacio?('gemma', 'gemini')
refute P.rol?('gemini')
end
def test_estado_por_rol_trae_provider_motivo_y_quien
asignar('gemma', 'mente', 'gemini', 'g-01')
asignar('gemma', 'mente', 'deepseek', 'd-01')
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma', estado: 'agotada', motivo: 'cuota diaria')
filas = P.estado('gemma', 'mente').to_h { |f| [f['identificador'], f] }
assert_equal %w[d-01 g-01], filas.keys.sort
assert_equal %w[agotada gemini gemma cuota\ diaria],
filas['g-01'].values_at('estado', 'provider', 'agotada_por', 'motivo')
assert_equal 'disponible', filas['d-01']['estado']
assert_equal 'deepseek', P.disponible('gemma', 'mente')['provider']
end
def test_con_estado_para_la_web
asignar('gemma', 'red', 'gemini', 'g-red')
assert_equal ['g-red'], P.con_estado.dig('gemma', 'red').map { |f| f['identificador'] }
end
end
+56
View File
@@ -0,0 +1,56 @@
# frozen_string_literal: true
# revertir_test.rb — Revertir el 'agotada' propio y estado del pool por key (P334/Fase 4, integrado en P335/Fase 6).
# Corre sobre una COPIA de organismo/ en un directorio temporal: nunca el registro real.
# ruby servicios/nexxa/test/revertir_test.rb
require 'minitest/autorun'
require 'tmpdir'
require 'fileutils'
DIR_REVERTIR = Dir.mktmpdir('nexxa-revertir')
Dir[File.expand_path('../organismo/*.rb', __dir__)].each { |f| FileUtils.cp(f, DIR_REVERTIR) }
require File.join(DIR_REVERTIR, 'lib_registro')
Minitest.after_run { FileUtils.rm_rf(DIR_REVERTIR) }
class RevertirTest < Minitest::Test
R = Nexxa::Registro
def setup
FileUtils.rm_f([R::STATE_FILE, Nexxa::Usos::LOG_FILE])
pasado = (Time.now - 3600).iso8601(3)
R.guardar('keys' => %w[g-01 g-02 g-03].map { |i| { 'provider' => 'gemini', 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 86_400, 'reservado_por' => nil } } +
[{ 'provider' => 'gemini', 'identificador' => 'g-off', 'activo' => false, 'disponible_desde' => pasado }])
end
def test_quien_la_agoto_puede_deshacerlo_aunque_ya_no_la_tenga_reservada
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada')
assert_equal 'agotada', R.estado_pool('gemini').find { |k| k['identificador'] == 'g-01' }['estado']
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'liberada')
e = R.estado_pool('gemini').find { |k| k['identificador'] == 'g-01' }
assert_equal 'disponible', e['estado']
assert_includes File.read(Nexxa::Usos::LOG_FILE), 'revertida'
end
def test_otro_individuo_no_puede_liberar_lo_que_agoto_otro
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada')
assert_raises(RuntimeError) { R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'peggy-f1', estado: 'liberada') }
end
def test_el_flujo_original_de_reserva_sigue_igual
R.reservar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1')
assert_raises(RuntimeError) { R.reportar(provider: 'gemini', identificador: 'g-02', individuo: 'otro', estado: 'sana') }
R.reportar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1', estado: 'liberada')
assert_equal 'disponible', R.estado_pool('gemini').find { |k| k['identificador'] == 'g-02' }['estado']
end
def test_estado_del_pool_sin_valores_y_con_los_cuatro_estados
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reservar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-02', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60)
est = R.estado_pool('gemini').to_h { |k| [k['identificador'], k] }
assert_equal %w[reservada agotada disponible inactiva], %w[g-01 g-02 g-03 g-off].map { |i| est[i]['estado'] }
assert_equal 'gemma-f1', est['g-02']['agotada_por']
refute est.values.any? { |k| k.key?('valor') || k.key?('valor_cifrado') }
end
end
+16
View File
@@ -0,0 +1,16 @@
# frozen_string_literal: true
# servidor_prueba.rb — Deja corriendo un NEXXA de PRUEBA (copia aislada, estado falso) para mirar nexxa-web en un
# navegador real (P335/Fase 7). Ctrl+C lo detiene y borra la copia.
# ruby servicios/nexxa/test/servidor_prueba.rb [--puerto 14568]
# Entra con humo-admin / humo-admin-123 (o humo-oper / humo-oper-123): usuarios INVENTADOS de la copia, no del nodo.
require_relative 'lib_servidor_prueba'
puerto = ARGV[ARGV.index('--puerto') + 1].to_i if ARGV.include?('--puerto')
prueba = ServidorPrueba.armar(individuos: %w[gemma-prueba peggy-prueba], puerto: puerto)
pid = ServidorPrueba.arrancar(prueba)
puts "NEXXA de prueba en http://127.0.0.1:#{prueba[:puerto]}/ (pid #{pid}) — usuarios: #{ServidorPrueba::USUARIOS.keys.join(', ')}"
$stdout.flush
trap('INT') { ServidorPrueba.detener(pid, prueba); exit }
trap('TERM') { ServidorPrueba.detener(pid, prueba); exit }
Process.wait(pid)