504 lines
26 KiB
C#
504 lines
26 KiB
C#
using System.Reflection;
|
|
using System.Text.Json;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.Extensions.Caching.Memory;
|
|
using Microsoft.Extensions.Logging.Abstractions;
|
|
using RutasDBUS.Components.Pages;
|
|
using RutasDBUS.Modelos.Historial;
|
|
using RutasDBUS.Modelos.Planificacion;
|
|
using RutasDBUS.Servicios.Caminata;
|
|
using RutasDBUS.Servicios.Configuracion;
|
|
using RutasDBUS.Servicios.Planificacion;
|
|
|
|
static void Check(bool result, string message)
|
|
{
|
|
if (!result) throw new Exception(message);
|
|
Console.WriteLine("OK " + message);
|
|
}
|
|
|
|
var baseMethod = typeof(PlanificadorRutas).GetMethod("CrearConfiguracionBaseHistorial", BindingFlags.Static | BindingFlags.NonPublic)!;
|
|
var defaults = (ConfiguracionHistorialRuta)baseMethod.Invoke(null, null)!;
|
|
Check(defaults.PesoTransbordoRankingMinutos == 6, "Penalizacion inicial de 6 minutos");
|
|
|
|
var panelSinCambios = new PlanificadorRutas();
|
|
var alternarPanel = typeof(PlanificadorRutas).GetMethod(
|
|
"ToggleConfigPanel",
|
|
BindingFlags.Instance | BindingFlags.NonPublic)!;
|
|
var solicitarCierre = typeof(PlanificadorRutas).GetMethod(
|
|
"SolicitarCierreConfiguracionAvanzada",
|
|
BindingFlags.Instance | BindingFlags.NonPublic)!;
|
|
alternarPanel.Invoke(panelSinCambios, null);
|
|
Check(
|
|
solicitarCierre.Invoke(panelSinCambios, null) is true,
|
|
"Configuracion avanzada sin cambios se cierra directamente");
|
|
|
|
var panelConCambios = new PlanificadorRutas();
|
|
alternarPanel.Invoke(panelConCambios, null);
|
|
typeof(PlanificadorRutas)
|
|
.GetField("_velocidadPieKmH", BindingFlags.Instance | BindingFlags.NonPublic)!
|
|
.SetValue(panelConCambios, 4.2);
|
|
Check(
|
|
solicitarCierre.Invoke(panelConCambios, null) is false &&
|
|
(bool)typeof(PlanificadorRutas)
|
|
.GetField("_mostrarConfirmacionCerrarConfiguracion", BindingFlags.Instance | BindingFlags.NonPublic)!
|
|
.GetValue(panelConCambios)!,
|
|
"Configuracion avanzada avisa antes de descartar cambios");
|
|
|
|
var folder = Path.Combine(Path.GetTempPath(), "rutasdbus-regression-" + Guid.NewGuid().ToString("N"));
|
|
IConfiguration Config() => new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string, string?>
|
|
{
|
|
["ValoresFabrica:Directorio"] = folder
|
|
}).Build();
|
|
ServicioValoresFabrica Service() => new(Config(), NullLogger<ServicioValoresFabrica>.Instance);
|
|
|
|
try
|
|
{
|
|
defaults.PesoTransbordoRankingMinutos = 9;
|
|
defaults.FechaSimulada = null;
|
|
defaults.HoraSimulada = null;
|
|
Directory.CreateDirectory(folder);
|
|
var file = Path.Combine(folder, "configuracion-fabrica.json");
|
|
await File.WriteAllTextAsync(file, JsonSerializer.Serialize(defaults));
|
|
var loaded = await Service().CargarAsync();
|
|
Check(loaded?.PesoTransbordoRankingMinutos == 9, "Valores compartidos entre instancias");
|
|
Check(loaded is { FechaSimulada: null, HoraSimulada: null }, "Valores antiguos sin fecha y hora siguen siendo validos");
|
|
|
|
var guardadaConFecha = defaults.Clonar();
|
|
guardadaConFecha.FechaSimulada = "2026-09-16";
|
|
guardadaConFecha.HoraSimulada = "13:40:00";
|
|
Check(await Service().GuardarAsync(guardadaConFecha), "Los valores de fabrica permiten guardar fecha y hora");
|
|
var cargadaConFecha = await Service().CargarAsync();
|
|
Check(
|
|
cargadaConFecha is { FechaSimulada: "2026-09-16", HoraSimulada: "13:40:00" },
|
|
"Los valores de fabrica recuperan la fecha y hora guardadas");
|
|
|
|
var pagina = new PlanificadorRutas();
|
|
typeof(PlanificadorRutas)
|
|
.GetField("_configuracionFabrica", BindingFlags.Instance | BindingFlags.NonPublic)!
|
|
.SetValue(pagina, cargadaConFecha);
|
|
var crearPredeterminada = typeof(PlanificadorRutas).GetMethod(
|
|
"CrearConfiguracionPredeterminadaHistorial",
|
|
BindingFlags.Instance | BindingFlags.NonPublic)!;
|
|
var predeterminada = (ConfiguracionHistorialRuta)crearPredeterminada.Invoke(pagina, null)!;
|
|
Check(
|
|
predeterminada is { FechaSimulada: "2026-09-16", HoraSimulada: "13:40:00" },
|
|
"Restaurar conserva la fecha y hora de los valores de fabrica");
|
|
|
|
File.WriteAllText(file, "{incompleto");
|
|
Check(await Service().CargarAsync() is null, "JSON danado permite usar valores base");
|
|
}
|
|
finally
|
|
{
|
|
// Solo datos temporales creados por esta prueba.
|
|
if (Directory.Exists(folder)) Directory.Delete(folder, recursive: true);
|
|
}
|
|
|
|
var fake = new FakeValhalla();
|
|
var planner = new PlanificadorRutasServicio(null!, null!, fake, null!, null!, null!, null!);
|
|
var walk = typeof(PlanificadorRutasServicio).GetMethod("WalkValhallaCached", BindingFlags.Instance | BindingFlags.NonPublic)!;
|
|
async Task<(double[,]? linea, double distancia, double duracion)> Walk(List<List<double[]>>? zones = null) =>
|
|
await (Task<(double[,]?, double, double)>)walk.Invoke(planner, new object?[] { 43.31, -1.99, 43.32, -1.98, zones, null })!;
|
|
List<double[]> Ring(double lon, double lat, double size) =>
|
|
new() { new[] { lon, lat }, new[] { lon + size, lat }, new[] { lon + size, lat + size },
|
|
new[] { lon, lat + size }, new[] { lon, lat } };
|
|
string Polyline6(params (double lat, double lon)[] puntos)
|
|
{
|
|
var texto = new System.Text.StringBuilder();
|
|
var latitudAnterior = 0;
|
|
var longitudAnterior = 0;
|
|
foreach (var punto in puntos)
|
|
{
|
|
Codificar((int)Math.Round(punto.lat * 1_000_000) - latitudAnterior, texto);
|
|
Codificar((int)Math.Round(punto.lon * 1_000_000) - longitudAnterior, texto);
|
|
latitudAnterior = (int)Math.Round(punto.lat * 1_000_000);
|
|
longitudAnterior = (int)Math.Round(punto.lon * 1_000_000);
|
|
}
|
|
return texto.ToString();
|
|
|
|
static void Codificar(int diferencia, System.Text.StringBuilder texto)
|
|
{
|
|
var valor = diferencia < 0 ? ~(diferencia << 1) : diferencia << 1;
|
|
while (valor >= 0x20)
|
|
{
|
|
texto.Append((char)((0x20 | (valor & 0x1f)) + 63));
|
|
valor >>= 5;
|
|
}
|
|
texto.Append((char)(valor + 63));
|
|
}
|
|
}
|
|
|
|
await Walk();
|
|
var far = new List<List<double[]>> { Ring(-2.3, 43.0, .01) };
|
|
await Walk(far);
|
|
Check(fake.Calls == 2 && fake.Zones == 1, "Toda zona activa se envia a V2 aunque este lejos de la ruta previa");
|
|
var near = new List<List<double[]>> { Ring(-1.985, 43.315, .001), Ring(-1.982, 43.317, .001) };
|
|
await Walk(near);
|
|
Check(fake.Zones == 2, "Se envian todos los poligonos");
|
|
await Walk(near);
|
|
Check(fake.Calls == 3, "Mismas zonas reutilizan cache restringida");
|
|
near[0][0][0] += .00001;
|
|
await Walk(near);
|
|
Check(fake.Calls == 4, "Mover un vertice invalida esa entrada de cache");
|
|
await Walk(new() { Ring(-2.2, 43.1, .5) });
|
|
Check(fake.Calls == 5, "Una zona que rodea la ruta no se ignora aunque sus vertices esten lejos");
|
|
fake.Fail = true;
|
|
var retry = new List<List<double[]>> { Ring(-1.984, 43.312, .0002) };
|
|
await Walk(retry);
|
|
fake.Fail = false;
|
|
await Walk(retry);
|
|
Check(fake.Calls == 7, "Un fallo temporal no queda guardado en cache de zonas");
|
|
var puntos = new List<double[]> { new[] { 43.314, -1.984 }, new[] { 43.315, -1.983 } };
|
|
await (Task<(double[,]?, double, double)>)walk.Invoke(planner,
|
|
new object?[] { 43.31, -1.99, 43.32, -1.98, near, puntos })!;
|
|
Check(fake.Zones == 2 && fake.Points == 2, "Se envian juntos todos los poligonos y puntos activos");
|
|
var retryHandler = new RetryValhallaHandler();
|
|
var retryConfig = new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string, string?>
|
|
{
|
|
["Caminata:Valhalla:BaseUrl"] = "http://v2.test"
|
|
}).Build();
|
|
var retryClient = new ClienteValhalla(new HttpClient(retryHandler), retryConfig);
|
|
await retryClient.ObtenerRutaAsync(
|
|
43.316344, -1.983193, 43.315282, -1.985457,
|
|
excludePolygons: new() { Ring(-1.9848, 43.3158, .0001) });
|
|
Check(retryHandler.Bodies.Count == 8,
|
|
"V2 amplia progresivamente la busqueda y prueba la alternativa puntual cuando recibe 442");
|
|
using (var primerIntento = JsonDocument.Parse(retryHandler.Bodies[0]))
|
|
using (var segundoIntento = JsonDocument.Parse(retryHandler.Bodies[1]))
|
|
using (var tercerIntento = JsonDocument.Parse(retryHandler.Bodies[2]))
|
|
using (var cuartoIntento = JsonDocument.Parse(retryHandler.Bodies[3]))
|
|
{
|
|
var primeraUbicacionInicial = primerIntento.RootElement.GetProperty("locations")[0];
|
|
var primeraUbicacionReintento = segundoIntento.RootElement.GetProperty("locations")[0];
|
|
var primeraUbicacionSegundoReintento = tercerIntento.RootElement.GetProperty("locations")[0];
|
|
var primeraUbicacionTercerReintento = cuartoIntento.RootElement.GetProperty("locations")[0];
|
|
Check(!primeraUbicacionInicial.TryGetProperty("radius", out _) &&
|
|
primeraUbicacionReintento.GetProperty("radius").GetInt32() == 50 &&
|
|
primeraUbicacionSegundoReintento.GetProperty("radius").GetInt32() == 100 &&
|
|
primeraUbicacionTercerReintento.GetProperty("radius").GetInt32() == 200,
|
|
"Los reintentos buscan una arista alternativa hasta un radio controlado de 200 metros");
|
|
}
|
|
var polygonFallbackHandler = new PolygonNoPathThenPointSuccessHandler(
|
|
Polyline6((43.31, -1.99), (43.32, -1.98)),
|
|
Polyline6((43.31, -1.99), (43.31, -1.98), (43.32, -1.98)));
|
|
var polygonFallbackClient = new ClienteValhalla(new HttpClient(polygonFallbackHandler), retryConfig);
|
|
var rutaConPoligonoConvertido = await polygonFallbackClient.ObtenerRutaAsync(
|
|
43.31, -1.99, 43.32, -1.98,
|
|
excludePolygons: new() { Ring(-1.9855, 43.3145, .001) });
|
|
Check(rutaConPoligonoConvertido.Linea is not null && polygonFallbackHandler.Bodies.Count == 6,
|
|
"Un poligono que devuelve 442 se sustituye por puntos y encuentra una alternativa");
|
|
using (var peticionConPuntos = JsonDocument.Parse(polygonFallbackHandler.Bodies[^1]))
|
|
{
|
|
Check(peticionConPuntos.RootElement.GetProperty("exclude_polygons").ValueKind == JsonValueKind.Null &&
|
|
peticionConPuntos.RootElement.GetProperty("exclude_locations").GetArrayLength() > 0,
|
|
"El fallback conserva la zona como validacion y envia a v2 las aristas afectadas");
|
|
}
|
|
var poligonoValidacion = Ring(-1.9855, 43.3145, .001);
|
|
var validationHandler = new PolygonValidationValhallaHandler(
|
|
Polyline6((43.31, -1.99), (43.32, -1.98)),
|
|
Polyline6((43.31, -1.99), (43.31, -1.98), (43.32, -1.98)));
|
|
var validationClient = new ClienteValhalla(new HttpClient(validationHandler), retryConfig);
|
|
var rutaValidada = await validationClient.ObtenerRutaAsync(
|
|
43.31, -1.99, 43.32, -1.98, excludePolygons: new() { poligonoValidacion });
|
|
Check(validationHandler.Bodies.Count == 2 && rutaValidada.Linea is not null,
|
|
"V2 recalcula una ruta que atraviesa una zona activa");
|
|
using (var peticionReforzada = JsonDocument.Parse(validationHandler.Bodies[1]))
|
|
{
|
|
Check(peticionReforzada.RootElement.GetProperty("exclude_locations").GetArrayLength() > 0,
|
|
"La ruta conflictiva refuerza la exclusion sobre las aristas atravesadas");
|
|
}
|
|
var parametrosConExclusion = new ParametrosPlanificadorRuta
|
|
{
|
|
UsarValhallaParaCaminatas = true,
|
|
PoligonosExclusionCaminata = new() { Ring(-1.985, 43.315, .001) }
|
|
};
|
|
var caminataNoResuelta = typeof(PlanificadorRutasServicio).GetMethod(
|
|
"CaminataNoResueltaConExclusiones", BindingFlags.Static | BindingFlags.NonPublic)!;
|
|
bool RechazarCaminata(ParametrosPlanificadorRuta parametros, double directa, double[,]? linea, double distancia) =>
|
|
(bool)caminataNoResuelta.Invoke(null, new object?[] { parametros, directa, linea, distancia })!;
|
|
Check(RechazarCaminata(parametrosConExclusion, 100, null, 0),
|
|
"Una caminata V2 sin ruta se descarta cuando hay exclusiones");
|
|
Check(!RechazarCaminata(new ParametrosPlanificadorRuta { UsarValhallaParaCaminatas = true }, 100, null, 0),
|
|
"Sin exclusiones se conserva el fallback historico");
|
|
Check(!RechazarCaminata(parametrosConExclusion, 100, new[,] { { 43.31, -1.99 }, { 43.32, -1.98 } }, 120),
|
|
"Una caminata V2 valida se conserva con exclusiones");
|
|
var puntoDentro = typeof(PlanificadorRutasServicio).GetMethod(
|
|
"PuntoDentroDePoligonoExclusion", BindingFlags.Static | BindingFlags.NonPublic)!;
|
|
Check((bool)puntoDentro.Invoke(null, new object?[] { 43.3155, -1.9845, parametrosConExclusion.PoligonosExclusionCaminata })!,
|
|
"Las paradas interiores a una zona se detectan antes de calcular");
|
|
var page = new PlanificadorRutas();
|
|
var flags = BindingFlags.Instance | BindingFlags.NonPublic;
|
|
var fabricaHistorial = (ConfiguracionHistorialRuta)baseMethod.Invoke(null, null)!;
|
|
fabricaHistorial.FactorEquilibradoAndarBus = 6;
|
|
fabricaHistorial.UsarHoraSimulada = true;
|
|
fabricaHistorial.FechaSimulada = "2026-09-16";
|
|
fabricaHistorial.HoraSimulada = "13:40:00";
|
|
typeof(PlanificadorRutas).GetField("_configuracionFabrica", flags)!.SetValue(page, fabricaHistorial);
|
|
var crearPredeterminadaHistorial = typeof(PlanificadorRutas).GetMethod(
|
|
"CrearConfiguracionPredeterminadaParaHistorial", flags)!;
|
|
var crearGuardadaHistorial = typeof(PlanificadorRutas).GetMethod(
|
|
"CrearConfiguracionGuardadaHistorial", flags)!;
|
|
var configuracionGuardada = fabricaHistorial.Clonar();
|
|
configuracionGuardada.UsarHoraSimulada = true;
|
|
configuracionGuardada.FechaSimulada = "2026-04-08";
|
|
configuracionGuardada.HoraSimulada = "08:46:17";
|
|
configuracionGuardada.FactorEquilibradoAndarBus = 99;
|
|
var registroConHora = new RegistroHistorialRuta { Configuracion = configuracionGuardada };
|
|
var predeterminadaHistorial = (ConfiguracionHistorialRuta)crearPredeterminadaHistorial.Invoke(page, null)!;
|
|
Check(predeterminadaHistorial.UsarHoraSimulada &&
|
|
predeterminadaHistorial.FechaSimulada == "2026-09-16" &&
|
|
predeterminadaHistorial.HoraSimulada == "13:40:00" &&
|
|
predeterminadaHistorial.FactorEquilibradoAndarBus == 6,
|
|
"Predeterminada usa tambien la fecha y hora de fabrica");
|
|
var guardada = (ConfiguracionHistorialRuta)crearGuardadaHistorial.Invoke(
|
|
page, new object[] { registroConHora })!;
|
|
Check(guardada.UsarHoraSimulada &&
|
|
guardada.FechaSimulada == "2026-04-08" &&
|
|
guardada.HoraSimulada == "08:46:17" &&
|
|
guardada.FactorEquilibradoAndarBus == 99,
|
|
"Guardada conserva la fecha, hora y parametros del historial");
|
|
var paginaCierreHistorial = new PlanificadorRutas();
|
|
typeof(PlanificadorRutas).GetField("_mostrarHistorialRutas", flags)!
|
|
.SetValue(paginaCierreHistorial, true);
|
|
typeof(PlanificadorRutas).GetField("_factorEquilibradoAndarBus", flags)!
|
|
.SetValue(paginaCierreHistorial, 99.0);
|
|
var configuracionAnteriorHistorial = fabricaHistorial.Clonar();
|
|
configuracionAnteriorHistorial.FactorEquilibradoAndarBus = 6;
|
|
typeof(PlanificadorRutas).GetField("_configuracionTemporalPreviaHistorial", flags)!
|
|
.SetValue(paginaCierreHistorial, configuracionAnteriorHistorial);
|
|
var alternarHistorial = typeof(PlanificadorRutas).GetMethod("ToggleHistorialPanel", flags)!;
|
|
await (Task)alternarHistorial.Invoke(paginaCierreHistorial, null)!;
|
|
Check(
|
|
!(bool)typeof(PlanificadorRutas).GetField("_mostrarHistorialRutas", flags)!
|
|
.GetValue(paginaCierreHistorial)! &&
|
|
(double)typeof(PlanificadorRutas).GetField("_factorEquilibradoAndarBus", flags)!
|
|
.GetValue(paginaCierreHistorial)! == 99.0,
|
|
"Cerrar el historial conserva la configuracion de la ruta visible");
|
|
typeof(PlanificadorRutas).GetField("_factorEquilibradoAndarBus", flags)!.SetValue(page, 6.0);
|
|
typeof(PlanificadorRutas).GetField("_factorPenalizacionDistanciaPie", flags)!.SetValue(page, 1.8);
|
|
typeof(PlanificadorRutas).GetField("_parametroPenalizacionDistanciaPieMetros", flags)!.SetValue(page, 200.0);
|
|
typeof(PlanificadorRutas).GetField("_pesoTransbordoRankingMinutos", flags)!.SetValue(page, 6.0);
|
|
typeof(PlanificadorRutas).GetField("_velocidadBusKmH", flags)!.SetValue(page, 16.0);
|
|
typeof(PlanificadorRutas).GetField("_mostrarElevacionesRuta", flags)!.SetValue(page, true);
|
|
var alternativaDesglose = new AlternativaRuta
|
|
{
|
|
AlternativaBus = new RutaBusAlternativa { DistanciaTotalBus = 6000 },
|
|
DistanciasPiePorTramoAprox = new List<double> { 100, 300 },
|
|
EsfuerzoExtraPendienteMetros = 25,
|
|
NumeroTransbordosReales = 1
|
|
};
|
|
var calcularScore = typeof(PlanificadorRutas).GetMethod("CalcularScoreEquilibradoFactor", flags)!;
|
|
var crearDesglose = typeof(PlanificadorRutas).GetMethod("CrearDesgloseScoreEquilibrado", flags)!;
|
|
var scoreCalculado = (double)calcularScore.Invoke(page, new object?[] { alternativaDesglose })!;
|
|
var desgloseCalculado = crearDesglose.Invoke(page, new object?[] { alternativaDesglose })!;
|
|
var scoreDesglosado = (double)desgloseCalculado.GetType().GetProperty("ScoreTotal")!
|
|
.GetValue(desgloseCalculado)!;
|
|
Check(Math.Abs(scoreCalculado - scoreDesglosado) < 0.0001,
|
|
"El desglose y el ranking usan exactamente el mismo score");
|
|
var formatearEtiqueta = typeof(PlanificadorRutas).GetMethod("FormatearEtiquetaAlternativaTarjeta", flags)!;
|
|
Check((string)formatearEtiqueta.Invoke(page, new object[]
|
|
{ new AlternativaRuta { Etiqueta = "Equilibrada" }, 0 })! == "Opción 1",
|
|
"Las alternativas de bus se muestran numeradas sin etiquetas de criterio");
|
|
Check((string)formatearEtiqueta.Invoke(page, new object[]
|
|
{ new AlternativaRuta { EsSoloAPie = true, Etiqueta = "Solo a pie (v2)" }, 3 })! == "Solo a pie (v2)",
|
|
"Las dos alternativas solo a pie conservan su identificacion");
|
|
var maximoExclusiones = typeof(PlanificadorRutas).GetField(
|
|
"MaximoExclusionesCaminata", BindingFlags.Static | BindingFlags.NonPublic)!;
|
|
Check((int)maximoExclusiones.GetRawConstantValue()! == 25,
|
|
"Las exclusiones quedan limitadas a 25 elementos");
|
|
typeof(PlanificadorRutas).GetField("_configuracionFabrica", flags)!.SetValue(page, defaults.Clonar());
|
|
typeof(PlanificadorRutas).GetField("_activarRangoLineas", flags)!.SetValue(page, true);
|
|
typeof(PlanificadorRutas).GetField("_lineaMin", flags)!.SetValue(page, 40);
|
|
typeof(PlanificadorRutas).GetField("_lineaMax", flags)!.SetValue(page, 40);
|
|
typeof(PlanificadorRutas).GetField("_activarRangoItinerarios", flags)!.SetValue(page, false);
|
|
typeof(PlanificadorRutas).GetField("_itinerarioMin", flags)!.SetValue(page, 7);
|
|
typeof(PlanificadorRutas).GetField("_itinerarioMax", flags)!.SetValue(page, 7);
|
|
typeof(PlanificadorRutas).GetMethod("AplicarValoresFabricaConservandoSeleccion", flags)!.Invoke(page, null);
|
|
Check(!(bool)typeof(PlanificadorRutas).GetField("_activarRangoLineas", flags)!.GetValue(page)! &&
|
|
(int)typeof(PlanificadorRutas).GetField("_lineaMin", flags)!.GetValue(page)! == defaults.LineaMin &&
|
|
(int)typeof(PlanificadorRutas).GetField("_lineaMax", flags)!.GetValue(page)! == defaults.LineaMax &&
|
|
(bool)typeof(PlanificadorRutas).GetField("_activarRangoItinerarios", flags)!.GetValue(page)! &&
|
|
(int)typeof(PlanificadorRutas).GetField("_itinerarioMin", flags)!.GetValue(page)! == defaults.ItinerarioMin &&
|
|
(int)typeof(PlanificadorRutas).GetField("_itinerarioMax", flags)!.GetValue(page)! == defaults.ItinerarioMax,
|
|
"Restaurar aplica tambien los valores de lineas e itinerarios");
|
|
var campoModoHistorial = typeof(PlanificadorRutas).GetField("_modoConfiguracionHistorial", flags)!;
|
|
var modoGuardada = Enum.Parse(campoModoHistorial.FieldType, "Guardada");
|
|
campoModoHistorial.SetValue(page, modoGuardada);
|
|
typeof(PlanificadorRutas).GetMethod("AplicarValoresFabricaConservandoSeleccion", flags)!.Invoke(page, null);
|
|
Check(Equals(campoModoHistorial.GetValue(page), modoGuardada),
|
|
"Restaurar valores conserva el modo de configuracion del historial");
|
|
var options = (List<AlternativaRuta>)typeof(PlanificadorRutas).GetField("_opcionesRuta", flags)!.GetValue(page)!;
|
|
var selected = typeof(PlanificadorRutas).GetField("_indiceAlternativaSeleccionada", flags)!;
|
|
var remember = typeof(PlanificadorRutas).GetMethod("ObtenerProveedorSoloAPieParaRecalculo", flags)!;
|
|
string? Remember(bool keep) => (string?)remember.Invoke(page, new object[] { keep });
|
|
options.Add(new() { EsSoloAPie = true, ProveedorRuta = "v1" });
|
|
options.Add(new() { EsSoloAPie = true, ProveedorRuta = "v2" });
|
|
selected.SetValue(page, 1);
|
|
Check(Remember(true) == "v2", "Se conserva la version andando seleccionada");
|
|
options.Clear();
|
|
Check(Remember(true) == "v2", "Otro cambio de punto durante el calculo conserva v2");
|
|
options.Add(new() { EsSoloAPie = false });
|
|
selected.SetValue(page, 0);
|
|
Check(Remember(true) is null, "Seleccionar bus libera la preferencia andando");
|
|
options.Clear();
|
|
Check(Remember(false) is null, "Nueva seleccion de criterio no hereda la preferencia andando");
|
|
var osmHandler = new OsmWidthHandler();
|
|
using var osmCache = new MemoryCache(new MemoryCacheOptions());
|
|
var osmConfig = new ConfigurationBuilder().AddInMemoryCollection(new Dictionary<string, string?>
|
|
{
|
|
["Caminata:Osm:BaseUrl"] = "https://osm.test/api/0.6"
|
|
}).Build();
|
|
var osmClient = new ClienteAtributosOsm(new HttpClient(osmHandler), osmCache, osmConfig);
|
|
var anchos = await osmClient.ObtenerAnchurasAsync([101, 102, 103]);
|
|
Check(anchos[101] == new AnchuraViaOsm("4.5", false) &&
|
|
anchos[102] == new AnchuraViaOsm("2", true) &&
|
|
!anchos.ContainsKey(103),
|
|
"La anchura exacta y la estimada se leen de las etiquetas OSM");
|
|
await osmClient.ObtenerAnchurasAsync([101, 102, 103]);
|
|
Check(osmHandler.Calls == 1, "Las anchuras OSM se reutilizan desde cache");
|
|
var formatearSuperficieSinDatos = typeof(PlanificadorRutas).GetMethod(
|
|
"FormatearSuperficieSegmento", BindingFlags.Static | BindingFlags.NonPublic)!;
|
|
var superficieSinDatos = (string)formatearSuperficieSinDatos.Invoke(null, [null])!;
|
|
Check(superficieSinDatos.Contains("Carriles: -") &&
|
|
superficieSinDatos.Contains("Anchura: -"),
|
|
"El tooltip mantiene todos los atributos cuando no hay datos de via");
|
|
Console.WriteLine("Pruebas completadas.");
|
|
|
|
sealed class FakeValhalla : IClienteValhalla
|
|
{
|
|
public Task<InformacionSueloTramo?> ObtenerInformacionSueloAsync(
|
|
double[,] linea, CancellationToken cancellationToken = default)
|
|
=> Task.FromResult<InformacionSueloTramo?>(null);
|
|
|
|
public int Calls { get; private set; }
|
|
public int Zones { get; private set; }
|
|
public int Points { get; private set; }
|
|
public bool Fail { get; set; }
|
|
public Task<(double[,]? Linea, double DistanciaMetros, double DuracionSegundos)> ObtenerRutaAsync(
|
|
double latitudDesde, double longitudDesde, double latitudHasta, double longitudHasta,
|
|
string costing = "pedestrian", List<List<double[]>>? excludePolygons = null,
|
|
List<double[]>? excludeLocations = null)
|
|
{
|
|
Calls++;
|
|
Zones = excludePolygons?.Count ?? 0;
|
|
Points = excludeLocations?.Count ?? 0;
|
|
return Task.FromResult<(double[,]?, double, double)>(Fail ? (null, 0, 0) :
|
|
(new[,] { { latitudDesde, longitudDesde }, { latitudHasta, longitudHasta } }, 100, 100));
|
|
}
|
|
}
|
|
|
|
sealed class OsmWidthHandler : HttpMessageHandler
|
|
{
|
|
public int Calls { get; private set; }
|
|
|
|
protected override Task<HttpResponseMessage> SendAsync(
|
|
HttpRequestMessage request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
Calls++;
|
|
const string contenido = """
|
|
{
|
|
"elements": [
|
|
{ "type": "way", "id": 101, "tags": { "width": "4.5" } },
|
|
{ "type": "way", "id": 102, "tags": { "est_width": "2" } },
|
|
{ "type": "way", "id": 103, "tags": { "highway": "residential" } }
|
|
]
|
|
}
|
|
""";
|
|
return Task.FromResult(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
|
|
{
|
|
Content = new StringContent(contenido, System.Text.Encoding.UTF8, "application/json")
|
|
});
|
|
}
|
|
}
|
|
|
|
sealed class RetryValhallaHandler : HttpMessageHandler
|
|
{
|
|
public List<string> Bodies { get; } = new();
|
|
|
|
protected override async Task<HttpResponseMessage> SendAsync(
|
|
HttpRequestMessage request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
Bodies.Add(await request.Content!.ReadAsStringAsync(cancellationToken));
|
|
return new HttpResponseMessage(System.Net.HttpStatusCode.BadRequest)
|
|
{
|
|
Content = new StringContent(
|
|
"{\"error_code\":442,\"error\":\"No path could be found for input\"}",
|
|
System.Text.Encoding.UTF8,
|
|
"application/json")
|
|
};
|
|
}
|
|
}
|
|
|
|
sealed class PolygonValidationValhallaHandler(string primeraForma, string segundaForma) : HttpMessageHandler
|
|
{
|
|
public List<string> Bodies { get; } = new();
|
|
|
|
protected override async Task<HttpResponseMessage> SendAsync(
|
|
HttpRequestMessage request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
Bodies.Add(await request.Content!.ReadAsStringAsync(cancellationToken));
|
|
var forma = Bodies.Count == 1 ? primeraForma : segundaForma;
|
|
var contenido = JsonSerializer.Serialize(new
|
|
{
|
|
trip = new
|
|
{
|
|
units = "kilometers",
|
|
summary = new { length = 1.0, time = 600.0 },
|
|
legs = new[] { new { shape = forma } }
|
|
}
|
|
});
|
|
return new HttpResponseMessage(System.Net.HttpStatusCode.OK)
|
|
{
|
|
Content = new StringContent(contenido, System.Text.Encoding.UTF8, "application/json")
|
|
};
|
|
}
|
|
}
|
|
|
|
sealed class PolygonNoPathThenPointSuccessHandler(string formaConflictiva, string formaAlternativa)
|
|
: HttpMessageHandler
|
|
{
|
|
public List<string> Bodies { get; } = new();
|
|
|
|
protected override async Task<HttpResponseMessage> SendAsync(
|
|
HttpRequestMessage request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var cuerpo = await request.Content!.ReadAsStringAsync(cancellationToken);
|
|
Bodies.Add(cuerpo);
|
|
using var documento = JsonDocument.Parse(cuerpo);
|
|
var raiz = documento.RootElement;
|
|
var tienePoligonos = raiz.TryGetProperty("exclude_polygons", out var poligonos) &&
|
|
poligonos.ValueKind == JsonValueKind.Array &&
|
|
poligonos.GetArrayLength() > 0;
|
|
if (tienePoligonos)
|
|
{
|
|
return new HttpResponseMessage(System.Net.HttpStatusCode.BadRequest)
|
|
{
|
|
Content = new StringContent(
|
|
"{\"error_code\":442,\"error\":\"No path could be found for input\"}",
|
|
System.Text.Encoding.UTF8,
|
|
"application/json")
|
|
};
|
|
}
|
|
|
|
var tienePuntos = raiz.TryGetProperty("exclude_locations", out var puntos) &&
|
|
puntos.ValueKind == JsonValueKind.Array &&
|
|
puntos.GetArrayLength() > 0;
|
|
var contenido = JsonSerializer.Serialize(new
|
|
{
|
|
trip = new
|
|
{
|
|
units = "kilometers",
|
|
summary = new { length = 1.0, time = 600.0 },
|
|
legs = new[] { new { shape = tienePuntos ? formaAlternativa : formaConflictiva } }
|
|
}
|
|
});
|
|
return new HttpResponseMessage(System.Net.HttpStatusCode.OK)
|
|
{
|
|
Content = new StringContent(contenido, System.Text.Encoding.UTF8, "application/json")
|
|
};
|
|
}
|
|
}
|