feat(paises): add country browser and extract shared radio transport

Extracts ServicioRadio's transport loop (server discovery, host rotation,
bounded retries, User-Agent, timeout, status check, json.decode, sticky-host
bookkeeping) out of `_get` into a new `_getJson(path, params) ->
Future<List<dynamic>>` helper, moved as one block with no logic edits. `_get`
is reimplemented on top, still owning every station-specific concern:
`lastcheckok: '1'`, `Emisora.fromApi` + the empty-uuid/url filter, and the
`_compararCalidad` quality sort. `_getJson` is deliberately sort-agnostic and
filter-agnostic so a non-station endpoint can reuse the resilience behaviour
without inheriting station-only semantics.

Non-negotiable ordering followed per design ADR-4: new
test/servicios/servicio_radio_transporte_test.dart characterises all 8
existing station calls (7 via `_get` plus `registrarClick`, which builds its
own URI) against the UNMODIFIED `_get` first - green by construction -
pinning path, lastcheckok=1, hidebroken=true, a non-empty User-Agent, exact
order/reverse/limit/offset, and the exact returned UUID sequence from a
fixture with deliberately shuffled bitrate/clickcount/votes. That last
assertion is what makes the extraction safe: a sort that silently sank into
transport would pass every other check. Re-running the same file after the
extraction is byte-identical green. test/servicios/servicio_radio_test.dart
is untouched by this work unit - its passing unmodified is itself a signal
that transport wasn't disturbed.

The 6 pre-existing `order: bitrate` occurrences (obtenerPopulares,
buscarPorNombre, buscarPorPais, buscarPorIdioma, buscarPorTag, buscar) are
untouched - a deliberate server-side quality bias deciding which stations
return within `limit`, unrelated to and never to be confused with the
user-facing "Ordenar" control, which stays entirely client-side via the
existing OrdenEmisoras (Engram reference/radio-browser-sort-order).

Behaviour delta, accepted per ADR-4, not a regression: moving
`_servidorActual` bookkeeping into `_getJson` means a successful
`/json/countries` call now warms the sticky host for subsequent station
calls too - one shared warm mirror per instance, desirable, not per-call-type
state.

Adds the Paises browser over the verified `/json/countries` contract (Engram
reference/radio-browser-countries-endpoint): new lib/modelos/pais_radio.dart
(`PaisRadio.fromApi` parses `stationcount` via `int.tryParse` since the API
returns it as a JSON string, not an int - an `as int` cast would throw),
`obtenerPaises()` sends neither `lastcheckok` nor `order` (the screen sorts
client-side by name; the API's raw byte order isn't proper collation for any
locale this app ships), and inherits `hidebroken=true` from the unchanged
`_uri` (desirable here too, since the endpoint's own default is false).
`EstadoBusqueda` gains `paises`/`cargandoPaises`/`cargarPaises()` with an
in-memory cache guard so re-entering the screen never refetches.

New PantallaPaises (lib/pantallas/pantalla_paises.dart): a "Tus idiomas"
shortlist (one representative country per the app's 13 supported locales,
matched against the fetched list - the proposal/spec name this section but
don't specify its derivation) above the full alphabetical list, each entry
showing its parsed station count. Reachable from Buscar's discovery landing
state via a new entry row, added now rather than left dangling per this
file's own forward-reference comment (and the WU15/WU15b lesson: a
fully-tested but unreachable screen is a real defect, not a follow-up).

New ARB keys (en/es only, matching this change's established precedent):
countriesScreenTitle, countriesYourLanguagesTitle, countriesAllTitle,
radioCountriesError.

Tests: 631 -> 649 (2 skipped, unchanged). flutter analyze unchanged at 1
pre-existing info. grep confirms `countrycodes` appears nowhere in lib/.
This commit is contained in:
2026-07-29 09:36:31 +02:00
parent 9bd828139f
commit c6f16c81b5
27 changed files with 1087 additions and 46 deletions
@@ -0,0 +1,293 @@
import 'dart:convert';
import 'package:flutter_test/flutter_test.dart';
import 'package:http/http.dart' as http;
import 'package:http/testing.dart';
import 'package:pluriwave/modelos/emisora.dart';
import 'package:pluriwave/servicios/servicio_radio.dart';
/// Characterisation tests for all 8 existing `ServicioRadio` station calls,
/// written against the CURRENT (unmodified) `_get`/`registrarClick` — green
/// by construction, per design ADR-4's strict-TDD sequence: "naive 'the test
/// must fail first' does not apply to characterisation."
///
/// Design's non-negotiable ordering rule: this file MUST be green BEFORE the
/// `_getJson` transport extraction begins, and re-run byte-identical green
/// AFTER it (task 7.6) — that re-run is the extraction's actual proof.
///
/// `test/servicios/servicio_radio_test.dart` is intentionally NOT modified
/// by this work unit; its passing untouched is itself a signal that
/// transport was not disturbed.
void main() {
// Deliberately shuffled bitrate/clickcount/votes: by bitrate desc, `s_b`,
// `s_c` and `s_d` tie at 300; `s_d` wins the tie on clickcount; `s_c` beats
// `s_b` on votes. This exercises every level of `_compararCalidad` and is
// what makes the extraction safe — a sort that silently sinks into
// transport would pass every other assertion below but fail this one.
List<Map<String, dynamic>> fixtureDesordenada() => [
{
'stationuuid': 's_a',
'name': 'A',
'url_resolved': 'https://a.example/audio',
'bitrate': 100,
'clickcount': 10,
'votes': 1,
},
{
'stationuuid': 's_b',
'name': 'B',
'url_resolved': 'https://b.example/audio',
'bitrate': 300,
'clickcount': 5,
'votes': 50,
},
{
'stationuuid': 's_c',
'name': 'C',
'url_resolved': 'https://c.example/audio',
'bitrate': 300,
'clickcount': 5,
'votes': 999,
},
{
'stationuuid': 's_d',
'name': 'D',
'url_resolved': 'https://d.example/audio',
'bitrate': 300,
'clickcount': 80,
'votes': 1,
},
{
'stationuuid': 's_e',
'name': 'E',
'url_resolved': 'https://e.example/audio',
'bitrate': 50,
'clickcount': 999,
'votes': 999,
},
];
const ordenEsperado = ['s_d', 's_c', 's_b', 's_a', 's_e'];
/// Runs [accion] against a `ServicioRadio` whose single mock host always
/// answers with [fixtureDesordenada], and returns both the captured
/// request and the method's return value so callers can assert transport
/// concerns (path/params/headers) and result ordering together.
Future<(http.Request, List<Emisora>)> ejecutar(
Future<List<Emisora>> Function(ServicioRadio) accion,
) async {
late http.Request solicitud;
final servicio = ServicioRadio(
cliente: MockClient((request) async {
solicitud = request;
return http.Response(
jsonEncode(fixtureDesordenada()),
200,
headers: {'content-type': 'application/json'},
);
}),
servidores: const ['host.api.radio-browser.info'],
retryDelay: Duration.zero,
);
final resultado = await accion(servicio);
return (solicitud, resultado);
}
group('ServicioRadio — 7 métodos basados en _get', () {
test('obtenerPopulares: path, filtros de transporte y orden', () async {
final (solicitud, emisoras) = await ejecutar(
(s) => s.obtenerPopulares(limit: 7, offset: 3),
);
expect(solicitud.url.path, '/json/stations/search');
expect(solicitud.url.queryParameters['lastcheckok'], '1');
expect(solicitud.url.queryParameters['hidebroken'], 'true');
expect(solicitud.url.queryParameters['order'], 'bitrate');
expect(solicitud.url.queryParameters['reverse'], 'true');
expect(solicitud.url.queryParameters['limit'], '7');
expect(solicitud.url.queryParameters['offset'], '3');
expect(solicitud.headers['User-Agent'], isNotEmpty);
expect(emisoras.map((e) => e.uuid), equals(ordenEsperado));
});
test('obtenerTendencias: path con limit embebido, sin order/reverse, '
'filtros de transporte y orden', () async {
final (solicitud, emisoras) = await ejecutar(
(s) => s.obtenerTendencias(limit: 12),
);
expect(solicitud.url.path, '/json/stations/topclick/12');
expect(solicitud.url.queryParameters['lastcheckok'], '1');
expect(solicitud.url.queryParameters['hidebroken'], 'true');
// topclick is pre-sorted by the endpoint itself — no order/reverse
// is ever sent for this method.
expect(solicitud.url.queryParameters.containsKey('order'), isFalse);
expect(solicitud.url.queryParameters.containsKey('reverse'), isFalse);
expect(solicitud.headers['User-Agent'], isNotEmpty);
expect(emisoras.map((e) => e.uuid), equals(ordenEsperado));
});
test('buscarPorNombre: path, filtros de transporte y orden', () async {
final (solicitud, emisoras) = await ejecutar(
(s) => s.buscarPorNombre('radio horizonte', limit: 9, offset: 2),
);
expect(solicitud.url.path, '/json/stations/search');
expect(solicitud.url.queryParameters['name'], 'radio horizonte');
expect(solicitud.url.queryParameters['lastcheckok'], '1');
expect(solicitud.url.queryParameters['hidebroken'], 'true');
expect(solicitud.url.queryParameters['order'], 'bitrate');
expect(solicitud.url.queryParameters['reverse'], 'true');
expect(solicitud.url.queryParameters['limit'], '9');
expect(solicitud.url.queryParameters['offset'], '2');
expect(solicitud.headers['User-Agent'], isNotEmpty);
expect(emisoras.map((e) => e.uuid), equals(ordenEsperado));
});
test('buscarPorPais: path, filtros de transporte y orden', () async {
final (solicitud, emisoras) = await ejecutar(
(s) => s.buscarPorPais('ES', limit: 11, offset: 4),
);
expect(solicitud.url.path, '/json/stations/bycountrycodeexact/ES');
expect(solicitud.url.queryParameters['lastcheckok'], '1');
expect(solicitud.url.queryParameters['hidebroken'], 'true');
expect(solicitud.url.queryParameters['order'], 'bitrate');
expect(solicitud.url.queryParameters['reverse'], 'true');
expect(solicitud.url.queryParameters['limit'], '11');
expect(solicitud.url.queryParameters['offset'], '4');
expect(solicitud.headers['User-Agent'], isNotEmpty);
expect(emisoras.map((e) => e.uuid), equals(ordenEsperado));
});
test('buscarPorIdioma: path, filtros de transporte y orden', () async {
final (solicitud, emisoras) = await ejecutar(
(s) => s.buscarPorIdioma('spanish', limit: 6, offset: 1),
);
expect(solicitud.url.path, '/json/stations/bylanguageexact/spanish');
expect(solicitud.url.queryParameters['lastcheckok'], '1');
expect(solicitud.url.queryParameters['hidebroken'], 'true');
expect(solicitud.url.queryParameters['order'], 'bitrate');
expect(solicitud.url.queryParameters['reverse'], 'true');
expect(solicitud.url.queryParameters['limit'], '6');
expect(solicitud.url.queryParameters['offset'], '1');
expect(solicitud.headers['User-Agent'], isNotEmpty);
expect(emisoras.map((e) => e.uuid), equals(ordenEsperado));
});
test('buscarPorTag: path, filtros de transporte y orden', () async {
final (solicitud, emisoras) = await ejecutar(
(s) => s.buscarPorTag('jazz', limit: 8, offset: 0),
);
expect(solicitud.url.path, '/json/stations/bytagexact/jazz');
expect(solicitud.url.queryParameters['lastcheckok'], '1');
expect(solicitud.url.queryParameters['hidebroken'], 'true');
expect(solicitud.url.queryParameters['order'], 'bitrate');
expect(solicitud.url.queryParameters['reverse'], 'true');
expect(solicitud.url.queryParameters['limit'], '8');
expect(solicitud.url.queryParameters['offset'], '0');
expect(solicitud.headers['User-Agent'], isNotEmpty);
expect(emisoras.map((e) => e.uuid), equals(ordenEsperado));
});
test('buscar: combina name/countrycode/language/tag, filtros de transporte '
'y orden', () async {
final (solicitud, emisoras) = await ejecutar(
(s) => s.buscar(
nombre: 'rock',
pais: 'ES',
idioma: 'spanish',
tag: 'indie',
limit: 15,
offset: 5,
),
);
expect(solicitud.url.path, '/json/stations/search');
expect(solicitud.url.queryParameters['name'], 'rock');
expect(solicitud.url.queryParameters['countrycode'], 'ES');
expect(solicitud.url.queryParameters['language'], 'spanish');
expect(solicitud.url.queryParameters['tag'], 'indie');
expect(solicitud.url.queryParameters['lastcheckok'], '1');
expect(solicitud.url.queryParameters['hidebroken'], 'true');
expect(solicitud.url.queryParameters['order'], 'bitrate');
expect(solicitud.url.queryParameters['reverse'], 'true');
expect(solicitud.url.queryParameters['limit'], '15');
expect(solicitud.url.queryParameters['offset'], '5');
expect(solicitud.headers['User-Agent'], isNotEmpty);
expect(emisoras.map((e) => e.uuid), equals(ordenEsperado));
});
});
group('ServicioRadio — obtenerPaises (usa _getJson, no _get)', () {
test('consulta /json/countries sin lastcheckok ni order; conserva '
'hidebroken; parsea stationcount desde un string JSON', () async {
late http.Request solicitud;
final servicio = ServicioRadio(
cliente: MockClient((request) async {
solicitud = request;
return http.Response(
jsonEncode([
{'name': 'Spain', 'iso_3166_1': 'es', 'stationcount': '482'},
{'name': 'Argentina', 'iso_3166_1': 'ar', 'stationcount': '120'},
]),
200,
headers: {'content-type': 'application/json'},
);
}),
servidores: const ['host.api.radio-browser.info'],
retryDelay: Duration.zero,
);
final paises = await servicio.obtenerPaises();
expect(solicitud.url.path, '/json/countries');
// The station-only filter and the station-only sort must NOT reach
// this endpoint — that is the entire point of the `_getJson`
// extraction (spec scenario "Countries request omits the
// station-only filter").
expect(solicitud.url.queryParameters.containsKey('lastcheckok'), isFalse);
expect(solicitud.url.queryParameters.containsKey('order'), isFalse);
expect(solicitud.url.queryParameters.containsKey('reverse'), isFalse);
// Inherited from `_uri`, unchanged — desirable here too (Engram id
// 2500): the endpoint's own default is `false`.
expect(solicitud.url.queryParameters['hidebroken'], 'true');
expect(solicitud.headers['User-Agent'], isNotEmpty);
expect(paises.map((p) => p.codigoIso), ['ES', 'AR']);
// `stationcount` arrived as a JSON STRING ("482") — this proves the
// whole pipeline (not just `PaisRadio.fromApi` in isolation) parses
// it without a cast error.
expect(paises.map((p) => p.numeroEmisoras), [482, 120]);
});
});
group('ServicioRadio — registrarClick (8º, no usa _get)', () {
test(
'pega al path correcto con un User-Agent no vacío '
'(literal desactualizado, fuera de alcance: no se fija su valor)',
() async {
late http.Request solicitud;
final servicio = ServicioRadio(
cliente: MockClient((request) async {
solicitud = request;
return http.Response('', 200);
}),
servidores: const ['host.api.radio-browser.info'],
retryDelay: Duration.zero,
);
await servicio.registrarClick('uuid-click');
expect(solicitud.url.path, '/json/url/uuid-click');
expect(solicitud.headers['User-Agent'], isNotEmpty);
// Deliberately NOT asserting the exact User-Agent value: it hardcodes
// a stale 'PluriWave/0.1.0 (...)' literal (known, out-of-scope
// defect — see `_resolverUserAgent()`'s own doc comment). Pinning a
// known-wrong value would convert a bug into a contract.
},
);
});
}