Tests ADN / test (push) Canceled after 0s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-Authored-By: GEMMA <noreply@gemma.dtic>
178 lines
11 KiB
Ruby
178 lines
11 KiB
Ruby
# 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
|
|
BASE_NEXXA_ORG = File.join(ServidorPrueba::BASE, 'organismo')
|
|
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
|
|
|
|
# Fase 12: CRUD completo (individuo propio 'crud-humo', se deja vacío al final: no interfiere con los otros tests)
|
|
def test_crud_editar_mover_vaciar_y_pools_por_key
|
|
base = '/pools/crud-humo/mente'
|
|
assert_equal 403, pedir('put', base, cuerpo: { refs: %w[gemini/g-01] }, sesion: SES_OPER)[0]
|
|
c, b = pedir('put', base, cuerpo: { refs: %w[gemini/g-01 deepseek/d-01] }, sesion: SES_ADMIN)
|
|
assert_equal [200, %w[gemini/g-01 deepseek/d-01]], [c, b['pool']]
|
|
# una ref mala: 400 y no cambia nada
|
|
assert_equal 400, pedir('put', base, cuerpo: { refs: %w[gemini/g-01 gemini/no-existe] }, sesion: SES_ADMIN)[0]
|
|
assert_equal 400, pedir('put', base, cuerpo: { otra: 1 }, sesion: SES_ADMIN)[0]
|
|
filas = pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'crud-humo', 'mente').map { |f| f['identificador'] }
|
|
assert_equal %w[g-01 d-01].sort, filas.sort
|
|
# la key sabe en qué pools está
|
|
g01 = pedir('get', '/keys', sesion: SES_OPER)[1].find { |k| k['identificador'] == 'g-01' }
|
|
assert_includes g01['pools'], { 'individuo' => 'crud-humo', 'rol' => 'mente' }
|
|
# mover al otro rol
|
|
c, b = pedir('post', "#{base}/gemini/g-01/mover", sesion: SES_ADMIN)
|
|
assert_equal [200, 'red'], [c, b['a']]
|
|
assert_equal 400, pedir('post', "#{base}/gemini/g-01/mover", sesion: SES_ADMIN)[0] # ya no está en mente
|
|
# vaciar los dos roles
|
|
assert_equal 200, pedir('put', base, cuerpo: { refs: [] }, sesion: SES_ADMIN)[0]
|
|
assert_equal 200, pedir('put', '/pools/crud-humo/red', cuerpo: { refs: [] }, sesion: SES_ADMIN)[0]
|
|
assert_nil pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'crud-humo')
|
|
end
|
|
|
|
# Fase 12: Individuos con resumen de pools; revocar borra sus pools (individuo propio, creado y revocado acá)
|
|
def test_individuos_con_pools_y_revocar_los_limpia
|
|
assert_equal 201, pedir('post', '/consumidores', cuerpo: { individuo: 'revocar-humo' }, sesion: SES_ADMIN)[0]
|
|
assert_equal 200, pedir('put', '/pools/revocar-humo/mente', cuerpo: { refs: %w[gemini/g-01] }, sesion: SES_ADMIN)[0]
|
|
c = pedir('get', '/consumidores', sesion: SES_OPER)[1].find { |x| x['individuo'] == 'revocar-humo' }
|
|
assert_equal({ 'total' => 1, 'disponibles' => 1 }, c.dig('pools', 'mente'))
|
|
assert_equal({ 'total' => 0, 'disponibles' => 0 }, c.dig('pools', 'red'))
|
|
assert_equal 200, pedir('delete', '/consumidores/revocar-humo', sesion: SES_ADMIN)[0]
|
|
assert_nil pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'revocar-humo')
|
|
end
|
|
|
|
# Cache busting: el HTML referencia js/css con ?v=<versión> y no se cachea (P335: app.js viejo dejaba Pools vacío)
|
|
def test_html_trae_estaticos_con_version_y_no_se_cachea
|
|
version = File.read(File.join(BASE_NEXXA_ORG, 'VERSION')).strip
|
|
r = Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.get('/') } # sin sesión: login.html
|
|
assert_includes r.body, "/css/estilos.css?v=#{version}"
|
|
assert_includes r.body, "/js/login.js?v=#{version}"
|
|
assert_equal 'no-cache', r['Cache-Control']
|
|
req = Net::HTTP::Get.new('/')
|
|
req['Cookie'] = "nexxa_session=#{SES_OPER}"
|
|
r = Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.request(req) } # con sesión: index.html
|
|
assert_includes r.body, "/js/app.js?v=#{version}"
|
|
assert_equal 200, Net::HTTP.start('127.0.0.1', PUERTO) { |h| h.get("/js/app.js?v=#{version}") }.code.to_i
|
|
end
|
|
|
|
# P337/Fase 1: estado calculado en /keys, registro filtrable y resumen, por HTTP y con el locale C del nodo
|
|
def test_estado_registro_y_resumen_por_http
|
|
keys = pedir('get', '/keys', sesion: SES_OPER)[1]
|
|
assert(keys.all? { |k| %w[disponible en_uso en_pausa agotada desactivada sin_valor].include?(k['estado']) })
|
|
refute(keys.any? { |k| k.key?('valor_cifrado') })
|
|
cod, usos = pedir('get', '/usos?evento=alta&horas=24', sesion: SES_OPER)
|
|
assert_equal 200, cod
|
|
assert(usos.all? { |u| u['evento'] == 'alta' })
|
|
cod, res = pedir('get', '/resumen?horas=24', sesion: SES_OPER)
|
|
assert_equal 200, cod
|
|
assert_equal keys.size, res['ahora'].values.sum
|
|
assert_equal 401, pedir('get', '/resumen')[0]
|
|
end
|
|
|
|
# Fase 13: renombrar una key (key propia d-ren; vuelve a su nombre al final)
|
|
def test_renombrar_key_actualiza_pools_y_valida
|
|
assert_equal 200, pedir('put', '/pools/ren-humo/red', cuerpo: { refs: %w[deepseek/d-ren] }, sesion: SES_ADMIN)[0]
|
|
assert_equal 403, pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'd-ren2' }, sesion: SES_OPER)[0]
|
|
assert_equal 409, pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'D REN' }, sesion: SES_ADMIN)[0]
|
|
assert_equal 409, pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'd-01' }, sesion: SES_ADMIN)[0]
|
|
assert_equal 404, pedir('patch', '/keys/deepseek/no-existe', cuerpo: { identificador: 'x' }, sesion: SES_ADMIN)[0]
|
|
c, b = pedir('patch', '/keys/deepseek/d-ren', cuerpo: { identificador: 'd-ren2', cuenta_origen: 'otra' }, sesion: SES_ADMIN)
|
|
assert_equal [200, 'd-ren2', 'otra'], [c, b['identificador'], b['cuenta_origen']]
|
|
refs = pedir('get', '/pools', sesion: SES_OPER)[1].dig('individuos', 'ren-humo', 'red').map { |f| f['identificador'] }
|
|
assert_equal ['d-ren2'], refs
|
|
assert pedir('get', '/usos', sesion: SES_OPER)[1].to_a.any? { |u| u['evento'] == 'renombrada' && u['motivo'] == 'antes d-ren' }
|
|
# limpieza: vuelve a su nombre y se vacía el pool
|
|
assert_equal 200, pedir('patch', '/keys/deepseek/d-ren2', cuerpo: { identificador: 'd-ren' }, sesion: SES_ADMIN)[0]
|
|
assert_equal 200, pedir('put', '/pools/ren-humo/red', cuerpo: { refs: [] }, sesion: SES_ADMIN)[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
|