Files
dtic-DIIAA/servicios/nexxa/test/pools_test.rb
T
63ea8a0abb
Tests ADN / test (push) Canceled after 0s
feat(nexxa): 1.5.0 — identificador de una key editable desde nexxa-web
PATCH /keys acepta 'identificador': renombra en el registro y en todos los pools, deja el evento 'renombrada (antes X)' en usos y lo rechaza si la key está reservada o el nombre existe (409). Campo Identificador en el panel de edición. Los chips de pools de APIs se refrescan tras cambiar un pool. Suite: humo HTTP 63, pools 45, revertir 10.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Co-Authored-By: GEMMA <noreply@gemma.dtic>
2026-10-04 18:05:02 -03:00

145 lines
6.9 KiB
Ruby

# 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
# --- Fase 12: CRUD completo
def test_reemplazar_deja_el_pool_exacto_y_valida_todo_antes
asignar('gemma', 'mente', 'gemini', 'g-01')
assert_equal %w[deepseek/d-01 gemini/g-red], P.reemplazar(individuo: 'gemma', rol: 'mente', refs: %w[deepseek/d-01 gemini/g-red])
assert_equal %w[deepseek/d-01 gemini/g-red], P.refs('gemma', 'mente')
assert_raises(RuntimeError) { P.reemplazar(individuo: 'gemma', rol: 'mente', refs: %w[gemini/g-01 gemini/no-existe]) }
assert_equal %w[deepseek/d-01 gemini/g-red], P.refs('gemma', 'mente') # nada cambió
P.reemplazar(individuo: 'gemma', rol: 'mente', refs: [])
assert_equal({ 'individuos' => {} }, P.leer)
end
def test_mover_entre_roles
asignar('gemma', 'mente', 'gemini', 'g-01')
assert_equal 'red', P.mover(individuo: 'gemma', de: 'mente', provider: 'gemini', identificador: 'g-01')
assert_equal [], P.refs('gemma', 'mente')
assert_equal ['gemini/g-01'], P.refs('gemma', 'red')
assert_raises(RuntimeError) { P.mover(individuo: 'gemma', de: 'mente', provider: 'gemini', identificador: 'g-01') }
end
# --- Fase 13: renombrar
def test_renombrar_actualiza_registro_y_pools
asignar('gemma', 'mente', 'gemini', 'g-01')
asignar('peggy', 'red', 'gemini', 'g-01')
R.renombrar(provider: 'gemini', de: 'g-01', a: 'g-uno')
assert P.renombrar_key(provider: 'gemini', de: 'g-01', a: 'g-uno')
assert_equal ['gemini/g-uno'], P.refs('gemma', 'mente')
assert_equal ['gemini/g-uno'], P.refs('peggy', 'red')
assert R.todas.any? { |k| k['identificador'] == 'g-uno' }
end
def test_renombrar_rechaza_invalido_existente_y_reservada
assert_raises(RuntimeError) { R.renombrar(provider: 'gemini', de: 'g-01', a: 'G 01') }
assert_raises(RuntimeError) { R.renombrar(provider: 'gemini', de: 'g-01', a: 'g-red') }
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma')
e = assert_raises(RuntimeError) { R.renombrar(provider: 'gemini', de: 'g-01', a: 'g-uno') }
assert_match(/reservada por gemma/, e.message)
end
end