Tests ADN / test (push) Canceled after 0s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-Authored-By: GEMMA <noreply@gemma.dtic>
234 lines
8.6 KiB
Ruby
234 lines
8.6 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_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
|
|
|