Files
dtic-DIIAA/servicios/nexxa/test/estado_test.rb
T
2026-10-05 02:42:58 -03:00

245 lines
9.0 KiB
Ruby

# frozen_string_literal: true
# estado_test.rb — Nexxa::Estado (P335/Fase 17): motor archivo con concurrencia REAL entre procesos y motor pg con una
# conexión simulada (no toca ningún Postgres). Corre sobre una COPIA de organismo/. ruby servicios/nexxa/test/estado_test.rb
require 'minitest/autorun'
require 'tmpdir'
require 'fileutils'
require 'json'
require 'stringio'
DIR_ESTADO = Dir.mktmpdir('nexxa-estado')
Dir[File.expand_path('../organismo/*.rb', __dir__)].each { |f| FileUtils.cp(f, DIR_ESTADO) }
require File.join(DIR_ESTADO, 'lib_estado')
require File.join(DIR_ESTADO, 'lib_registro')
require File.join(DIR_ESTADO, 'lib_pools')
require File.join(DIR_ESTADO, 'cli_estado')
Minitest.after_run { FileUtils.rm_rf(DIR_ESTADO) }
class EstadoArchivoTest < Minitest::Test
E = Nexxa::Estado
R = Nexxa::Registro
def setup
ENV.delete('NEXXA_ESTADO')
FileUtils.rm_f(Dir[File.join(DIR_ESTADO, '*.json')] + [Nexxa::Usos::LOG_FILE])
end
def test_sin_variable_el_motor_es_archivo_y_uno_invalido_falla
assert_equal 'archivo', E.motor
ENV['NEXXA_ESTADO'] = 'mongo'
assert_raises(ArgumentError) { E.motor }
ensure
ENV.delete('NEXXA_ESTADO')
end
def test_guardar_es_0600_y_leer_devuelve_el_defecto_si_falta
ruta = File.join(DIR_ESTADO, 'x.json')
assert_equal({ 'a' => [] }, E.leer('x', ruta, { 'a' => [] }))
E.guardar('x', ruta, { 'a' => [1] })
assert_equal '600', format('%o', File.stat(ruta).mode & 0o777)
assert_equal({ 'a' => [1] }, E.leer('x', ruta, {}))
end
# La carrera que cierra la fase: 2 procesos x 50 incrementos sobre el mismo archivo no pierden ninguno
def test_mutar_no_pierde_escrituras_entre_procesos
ruta = File.join(DIR_ESTADO, 'contador.json')
pids = 2.times.map do
fork { 50.times { E.mutar('contador', ruta, { 'n' => 0 }) { |v| v.merge('n' => v['n'] + 1) } } }
end
pids.each { |p| Process.wait(p) }
assert_equal 100, E.leer('contador', ruta, {})['n']
end
# Dispensa atómica: 6 procesos piden a la vez de un pool de 3 keys — nunca la misma key a dos, y 3 se quedan sin
def test_dispensar_nunca_entrega_la_misma_key_dos_veces
pasado = (Time.now - 3600).iso8601(3)
R.guardar('keys' => %w[k1 k2 k3].map do |i|
{ 'provider' => 'p', 'identificador' => i, 'disponible_desde' => pasado, 'reset_segundos' => 60, 'valor_cifrado' => 'x' }
end)
lectores = 6.times.map do |n|
r, w = IO.pipe
pid = fork do
r.close
w.write(R.reservar_libre(individuo: "ind#{n}", provider: 'p')&.dig('identificador').to_s)
w.close
end
w.close
[pid, r]
end
entregadas = lectores.map { |pid, r| Process.wait(pid) && r.read.tap { r.close } }.reject(&:empty?)
assert_equal %w[k1 k2 k3], entregadas.sort
end
def test_una_key_solo_metadata_se_devuelve_sin_reservar
R.guardar('keys' => [{ 'provider' => 'p', 'identificador' => 'm', 'disponible_desde' => (Time.now - 60).iso8601(3) }])
entrada = R.reservar_libre(individuo: 'i', provider: 'p')
assert_equal 'm', entrada['identificador']
assert_nil R.leer['keys'].first['reservado_por']
end
# La hora de la próxima libre incluye la reserva: con todas reservadas, nunca una hora pasada (caso real 2026-10-05)
def test_proxima_considera_la_reserva
ahora = Time.now
R.guardar('keys' => [{ 'provider' => 'p', 'identificador' => 'k', 'disponible_desde' => (ahora - 3600).iso8601(3),
'reservado_por' => 'x', 'reservado_hasta' => (ahora + 600).iso8601(3) }])
assert_operator Time.parse(R.proxima('p')['disponible_desde']), :>, ahora
assert_nil R.disponible('p')
end
def test_usos_en_archivo_mas_reciente_primero
E.usos_registrar('provider' => 'p', 'identificador' => 'a', 'individuo' => 'i', 'evento' => 'dispensada', 'en' => '2026-10-05T01:00:00-03:00')
E.usos_registrar('provider' => 'p', 'identificador' => 'b', 'individuo' => 'i', 'evento' => 'agotada', 'en' => '2026-10-05T02:00:00-03:00')
assert_equal %w[b a], E.usos_historial.map { |u| u['identificador'] }
assert_equal ['a'], E.usos_historial(identificador: 'a').map { |u| u['identificador'] }
end
end
# Conexión simulada con la forma de PG::Connection que usa Estado (exec, exec_params, transaction_status)
class ConexionFalsa
attr_reader :sql
def initialize = (@filas = {}; @usos = []; @sql = []; @tx = 0)
def transaction_status = @tx
def exec(q)
@sql << q
return [{ 'n' => @usos.size }] if q.start_with?('SELECT count(*)')
return @usos.map { |u| %w[provider identificador individuo evento en].zip(u).to_h } if q.include?('FROM usos ORDER BY id')
@tx = 2 if q == 'BEGIN'
if %w[COMMIT ROLLBACK].include?(q)
@tx = 0
@filas = @copia if q == 'ROLLBACK' && @copia
end
@copia = Marshal.load(Marshal.dump(@filas)) if q == 'BEGIN'
[]
end
def exec_params(q, params)
@sql << q.split.first(2).join(' ')
case q
when /\AINSERT INTO usos/m then @usos << params
when /\AINSERT INTO estado .* DO NOTHING/m then @filas[params[0]] ||= params[1]
when /\AINSERT INTO estado/m, /\AUPDATE estado/m then @filas[params[0]] = params[1]
when /\ASELECT valor FROM estado/m then return @filas.key?(params[0]) ? [{ 'valor' => @filas[params[0]] }] : []
end
[]
end
end
class EstadoPgTest < Minitest::Test
E = Nexxa::Estado
def setup
ENV['NEXXA_ESTADO'] = 'pg'
@c = ConexionFalsa.new
E.con = @c
end
def teardown
ENV.delete('NEXXA_ESTADO')
E.con = nil
end
def test_leer_guardar_por_clave_sin_tocar_archivos
assert_equal({ 'keys' => [] }, E.leer('registro', '/no/existe.json', { 'keys' => [] }))
E.guardar('registro', '/no/existe.json', { 'keys' => [1] })
assert_equal({ 'keys' => [1] }, E.leer('registro', '/no/existe.json', {}))
end
def test_mutar_hace_begin_commit_y_devuelve_el_valor_nuevo
nuevo = E.mutar('pools', nil, { 'n' => 0 }) { |v| v.merge('n' => v['n'] + 1) }
assert_equal({ 'n' => 1 }, nuevo)
assert_equal 'BEGIN', @c.sql.first
assert_equal 'COMMIT', @c.sql.last
assert(@c.sql.any? { |q| q.include?('SELECT') })
assert_equal 0, @c.transaction_status
end
def test_un_error_en_el_bloque_hace_rollback_y_no_guarda
E.guardar('pools', nil, { 'n' => 5 })
assert_raises(RuntimeError) { E.mutar('pools', nil, {}) { |_v| raise 'no' } }
assert_includes @c.sql, 'ROLLBACK'
assert_equal 0, @c.transaction_status
assert_equal({ 'n' => 5 }, E.leer('pools', nil, {}))
end
def salida_no_local
E.mutar('pools', nil, {}) { |_v| return :afuera }
end
def test_un_return_en_el_bloque_no_deja_la_transaccion_abierta
assert_equal :afuera, salida_no_local
assert_equal 'ROLLBACK', @c.sql.last
assert_equal 0, @c.transaction_status
end
end
class CliEstadoTest < Minitest::Test
E = Nexxa::Estado
C = Nexxa::CliEstado
def setup
ENV.delete('NEXXA_ESTADO')
FileUtils.rm_f(Dir[File.join(DIR_ESTADO, '{*.json,.*.json,*.tgz}')] + [E::USOS_LOG])
E.con = ConexionFalsa.new
C.instance_variable_set(:@usos_archivo, nil)
E.archivo_guardar(E.ruta('registro'), { 'keys' => [{ 'provider' => 'p', 'identificador' => 'k1' }] })
E.archivo_guardar(E.ruta('usuarios'), [{ 'usuario' => 'admin' }])
File.write(E::USOS_LOG, %({"provider":"p","identificador":"k1","individuo":"i","evento":"dispensada","en":"2026-10-05T01:00:00-03:00"}\n))
end
def teardown
E.con = nil
end
def corre(accion)
out = StringIO.new
[C.call(accion, salida: out), out.string]
end
def test_migrar_es_idempotente_y_respalda_antes_de_escribir
codigo, texto = corre('migrar')
assert_equal 0, codigo, texto
assert_match(/registro: migrada/, texto)
assert_equal 1, Dir[File.join(DIR_ESTADO, 'bkp_estado_*.tgz')].size
assert_equal({ 'keys' => [{ 'provider' => 'p', 'identificador' => 'k1' }] }, E.pg_leer('registro', nil))
codigo2, texto2 = corre('migrar')
assert_equal 0, codigo2
assert_match(/igual: pg ya coincide/, texto2)
assert_equal 1, Dir[File.join(DIR_ESTADO, 'bkp_estado_*.tgz')].size, 'la segunda corrida no respalda ni escribe'
end
def test_migrar_se_niega_con_el_motor_pg_ya_activo
dropin = File.join(DIR_ESTADO, 'estado.conf')
File.write(dropin, "[Service]\nEnvironment=NEXXA_ESTADO=pg\n")
out = StringIO.new
assert_equal 1, C.migrar(out, dropin: dropin)
assert_match(/ya está activo/, out.string)
assert_nil E.pg_leer('registro', nil), 'no escribió nada'
ensure
FileUtils.rm_f(dropin)
end
def test_verificar_detecta_una_diferencia
corre('migrar')
E.archivo_guardar(E.ruta('pools'), { 'individuos' => { 'gemma' => { 'mente' => ['p/k1'] } } })
codigo, texto = corre('verificar')
assert_equal 1, codigo
assert_match(/difiere de los archivos en: pools/, texto)
end
def test_exportar_es_la_vuelta_atras
corre('migrar')
E.pg_guardar('registro', { 'keys' => [] })
FileUtils.rm_f(E::USOS_LOG)
codigo, texto = corre('exportar')
assert_equal 0, codigo, texto
assert_equal({ 'keys' => [] }, E.archivo_leer(E.ruta('registro'), nil))
assert_equal 1, File.readlines(E::USOS_LOG).size
end
end