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,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
|
||||
@@ -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
|
||||
@@ -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
|
||||
@@ -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)
|
||||
Reference in New Issue
Block a user