Files
dtic-DIIAA/servicios/nexxa/test/revertir_test.rb
T

103 lines
6.2 KiB
Ruby

# 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, 'valor_cifrado' => 'x' } } +
[{ 'provider' => 'gemini', 'identificador' => 'g-off', 'activo' => false, 'disponible_desde' => pasado, 'valor_cifrado' => 'x' },
{ 'provider' => 'gemini', 'identificador' => 'g-meta', '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
# Taxonomía cerrada (P337/Fase 1): un bloqueo de 60 s es una PAUSA por límite, uno largo es AGOTADA; sin valor y
# desactivada se distinguen; campos uniformes hasta/por/motivo
def test_estado_del_pool_sin_valores_y_con_la_taxonomia_completa
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, motivo: '429')
R.reservar(provider: 'gemini', identificador: 'g-03', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-03', individuo: 'gemma-f1', estado: 'agotada', motivo: 'cuota diaria')
est = R.estado_pool('gemini').to_h { |k| [k['identificador'], k] }
assert_equal %w[en_uso en_pausa agotada desactivada sin_valor], %w[g-01 g-02 g-03 g-off g-meta].map { |i| est[i]['estado'] }
assert_equal %w[gemma-f1 429], est['g-02'].values_at('por', 'motivo')
assert_operator Time.parse(est['g-02']['hasta']), :>, Time.now
assert_equal 'gemma-f1', est['g-01']['por']
refute est.values.any? { |k| k.key?('valor') || k.key?('valor_cifrado') }
end
# Registro completo: cada paso queda con su evento, motivo y hasta
def test_el_registro_anota_cada_paso
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'sana')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60, motivo: '429 por minuto')
R.actualizar(provider: 'gemini', identificador: 'g-03', activo: false, por: 'web:admin')
R.eliminar(provider: 'gemini', identificador: 'g-off', por: 'web:admin')
h = Nexxa::Usos.historial
assert_equal %w[baja editada pausada renovada dispensada], h.map { |u| u['evento'] }
assert_equal '429 por minuto', h[2]['motivo']
refute_nil h[2]['hasta']
assert_equal 'activo: nil → false', h[1]['motivo']
assert_equal ['web:admin'], Nexxa::Usos.historial(individuo: 'web:admin', evento: 'baja').map { |u| u['individuo'] }
end
def test_resumen_cuenta_todos_los_estados_y_los_eventos_de_la_ventana
R.reservar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1')
R.reportar(provider: 'gemini', identificador: 'g-01', individuo: 'gemma-f1', estado: 'agotada', liberar_en_segundos: 60)
r = Nexxa::Usos.resumen(R.todas_con_estado, horas: 24)
assert_equal R::ESTADOS.sort, r['ahora'].keys.sort, 'todos los estados, también los que están en 0'
assert_equal 1, r['ahora']['en_pausa']
assert_equal 0, r['ahora']['en_uso']
assert_equal({ 'dispensada' => 1, 'pausada' => 1 }, r['eventos'].select { |_, n| n.positive? })
g01 = r['por_key'].find { |k| k['identificador'] == 'g-01' }
assert_equal 'pausada', g01['ultimo_evento']['evento']
refute r['por_key'].any? { |k| k.key?('valor_cifrado') }
end
# Un 'agotada' anterior a 2.0.0 (sin hasta) no infla los agotamientos de cuota: se cuenta aparte, con su texto
def test_un_agotada_previo_a_2_0_0_se_cuenta_aparte
Nexxa::Usos.registrar(provider: 'gemini', identificador: 'g-01', individuo: 'x', evento: 'agotada')
r = Nexxa::Usos.resumen(R.todas_con_estado, horas: 24)
assert_equal 0, r['eventos']['agotada']
assert_equal 1, r['eventos']['agotada-previa']
u = Nexxa::Usos.historial.first
assert_equal 'agotada-previa', u['clase']
assert_match(/anterior a 2\.0\.0/, u['texto'])
end
end