1. Acceso a Ficheros

1.1. ¿De qué va este tema?

En este curso aprendemos a construir la primera persistencia de una aplicación: conservar datos en ficheros y poder intercambiarlos con otros sistemas.

  • Gestionar la persistencia en ficheros, creando, leyendo y escribiendo ficheros y directorios mediante la forma de acceso adecuada.

  • Representar y transformar datos, utilizando formatos de intercambio como CSV y JSON sin pérdida de información.

  • Diseñar un acceso robusto al almacenamiento, tratando errores y separando la persistencia de la lógica de dominio.

El tema tiene una dedicación estimada de 28 horas.

Punto de partida: programación orientada a objetos y tratamiento básico de excepciones. Prepara GitHub con Práctica 0-A. Primeros pasos con Git y GitHub (0-A) y el entorno con Práctica 0-C. Entorno de desarrollo con Codespaces (0-C); si ya los dominas, comprueba las operaciones sin repetir una entrega.

Caso práctico del módulo

Esta unidad forma parte del caso transversal de gestión de FCT.

Ejemplos para experimentar

Cada clase enlaza código ejecutable bajo ud01/ejemplos/. La guía de ejecución indica el comando, el cambio propuesto y qué comprobar. En ud01/para_jugar/ tienes el laboratorio completo de empresas. Experimenta desde tu copia privada en Codespaces o en local. Esta experimentación es formativa, no otra entrega. El entorno común de AD prepara las herramientas; Maven compila y ejecuta Java. Tú conservas el código fuente, no los archivos generados.

1.2. Clases

Los ejercicios de clase son formativos y no calificables. Primero comprende el concepto; después predice el resultado, ejecuta el ejemplo del repositorio, cambia una cosa y comprueba qué ocurre. Las lecturas y vídeos de apoyo sirven para aclarar los conceptos indicados; no hace falta recorrer íntegramente cada recurso. Java es la referencia de la aplicación y Python permite observar rápidamente operaciones y formatos. No necesitas repetir cada actividad en ambos lenguajes. Las ideas son las mismas; cambian las llamadas de cada biblioteca.

1.2.1. Rutas, ficheros y directorios

  1. El sistema de archivos (filesystem) es la parte del sistema operativo que organiza y almacena la información de forma persistente:

    1. Organiza los datos en una jerarquía de directorios (carpetas) y archivos

    2. Cada archivo tiene un nombre y una ubicación dentro de esa jerarquía

    3. El sistema operativo controla quién puede acceder a cada recurso

  2. Una ruta (path) indica dónde se encuentra un archivo o directorio:

    1. Ruta absoluta: parte de la raíz del sistema (p. ej. /home/alumno/datos)

    2. Ruta relativa: parte del directorio de trabajo actual (p. ej. datos)

    3. El separador de directorios depende del sistema (/ en Linux, \ en Windows)

  3. Distinguimos dos tipos de recursos:

    1. Archivo: unidad de almacenamiento con contenido (texto, imagen, etc.)

    2. Directorio: contenedor de archivos y de otros directorios

    3. Ambos tienen metadatos: nombre, tamaño, fechas de creación/modificación y permisos

  4. Los permisos controlan el acceso:

    1. Lectura, escritura y ejecución

    2. En sistemas POSIX se asignan al propietario, a un grupo y al resto; otros sistemas pueden usar listas de control de acceso

    3. En un directorio, ejecutar significa poder atravesarlo, no lanzar un programa

    4. Intentar acceder sin permiso provoca un error

  5. Operaciones básicas sobre el sistema de archivos:

    1. Crear archivos y directorios

    2. Listar el contenido de un directorio

    3. Copiar, mover y renombrar

    4. Eliminar archivos y directorios

    5. Comprobar existencia y tipo cuando sea necesario; el estado puede cambiar entre la comprobación y la operación, por lo que también hay que tratar errores

Para leer y ejecutar: sistema de archivos (Wikipedia), especialmente sus ejemplos de rutas Unix/Windows; Path y Files en Java y pathlib en Python. Compara Rutas.java con rutas.py: crea el árbol y repite la operación.

Vídeo de apoyo: rutas y operaciones del sistema

Corey Schafer, OS Module (Python, inglés). Observa directorio de trabajo, listado y creación. El vídeo usa os; contrasta esas operaciones con pathlib en nuestro ejemplo.

Actividad

En Rutas o rutas.py, predice dónde apunta fct/empresas.json. Ejecuta desde la raíz de tu repositorio y contrasta con el directorio de trabajo. Añade un ciclo al árbol y repite su creación. ¿Aparece dos veces? Clasifica también ../empresas y C:\fct\alumnos como rutas relativas o absolutas, indicando el sistema donde las interpretas.

Comprobación razonada

Desde /home/alumno, el ejemplo apunta a /home/alumno/fct/empresas.json. Crear otra vez un directorio existente con las opciones del ejemplo no lo duplica. ../empresas es relativa. La ruta C:\fct\alumnos es absoluta en Windows; su interpretación no se traslada directamente a Linux. Permisos y existencia se comprueban en el entorno donde se ejecuta.

Actividad

Localiza en el mismo ejemplo las operaciones de copia, movimiento y borrado. Cambia el nombre de la copia y predice el árbol final antes de ejecutar. ¿Copiar y mover conservan ambos el nombre original?

Comprobación razonada

Copiar conserva el origen; mover cambia su ubicación o nombre. Tras borrar la copia queda renombrado.txt, junto a los directorios. El ejemplo limpia su carpeta temporal al terminar.

1.2.2. Elegir cómo acceder a un fichero

  1. Según el contenido, un fichero puede ser:

    1. Texto: secuencia de caracteres legibles (un convenio, un listado)

    2. Binario: secuencia de bytes sin interpretación textual (un PDF, una imagen)

    3. Un mismo archivo puede interpretarse de varias formas; la elección depende de lo que queramos hacer con él

  2. La diferencia entre byte y carácter es clave:

    1. El bit es la unidad mínima; un byte agrupa 8 bits

    2. Un carácter (letra, número, símbolo) puede ocupar uno o varios bytes

    3. La codificación es la regla que asocia caracteres a bytes (ASCII, UTF-8, ISO-8859-1, …)

    4. Leer un texto con la codificación equivocada puede producir caracteres incorrectos o una excepción, según los bytes y el tratamiento de errores

  3. Un flujo (stream) es una secuencia ordenada de datos que se lee o escribe:

    1. Flujo de entrada: para leer (del archivo a la aplicación)

    2. Flujo de salida: para escribir (de la aplicación al archivo)

    3. Los flujos pueden trabajar con bytes o con caracteres

  4. Según cómo recorremos el archivo, el acceso puede ser:

    1. Secuencial: se lee o escribe en orden, de principio a fin

    2. Aleatorio: se salta directamente a una posición concreta

    3. Con registros de tamaño fijo, posición = número de registro × bytes por registro

    4. En texto UTF-8, contar caracteres no permite calcular directamente posiciones en bytes

  5. Criterios para elegir la forma de acceso:

    1. ¿El contenido es texto o binario?

    2. ¿Necesito leerlo entero o solo una parte?

    3. ¿Los registros tienen tamaño fijo o variable?

    4. ¿Qué codificación de caracteres debo usar?

    Lectura de apoyo: qué es una codificación (W3C). Basta con los apartados que relacionan caracteres y bytes.

Para leer y ejecutar: el ejemplo de la ñ en UTF-8 (Wikipedia). Comprueba las medidas con Acceso.java y acceso.py. En Java, String.length() cuenta unidades UTF-16; no equivale siempre al número de puntos de código. Cambia una letra por un emoji y observa la diferencia.

Un carácter no equivale a un byte

Texto

Puntos de código Unicode

Bytes en UTF-8

Unidades UTF-16 (String.length())

A

1

1

1

ñ

1

2

1

😀

1

4

2

En estos tres ejemplos cada símbolo corresponde a un punto de código. No siempre ocurre así: un símbolo percibido como una unidad puede combinar varios puntos de código. Para calcular posiciones en un fichero importan los bytes de su representación, no la longitud visual del texto.

Vídeo de apoyo: caracteres, Unicode y UTF-8

Computerphile, Characters, Symbols and the Unicode Miracle, con Tom Scott (inglés). Distingue el número que identifica un carácter de los bytes que se usan para representarlo.

Pregunta para observar: ¿por qué una letra no tiene necesariamente el mismo tamaño en todas las codificaciones? Después comprueba la tabla con los ejemplos Java o Python; no necesitas memorizar las reglas binarias de UTF-8.

Actividad

Ejecuta Acceso o acceso.py y sustituye una letra por un emoji. Predice caracteres y bytes. Localiza el salto al registro O03 y cambia la posición para leer O02. ¿Serviría ese cálculo para nombres de longitud variable?

Comprobación razonada

cañón tiene cinco puntos de código y siete bytes en UTF-8. La posición del cuarto registro (índice 3) de 16 bytes es 48 bytes. En el flujo de registros de cuatro bytes, O02 empieza en el byte 4. El acceso por posición necesita conocer la representación: no basta contar las letras de un registro variable.

1.2.3. Leer y escribir con flujos

  1. Para trabajar con un fichero hay que seguir un ciclo:

    1. Abrir el flujo (indicando si es para leer o escribir)

    2. Leer o escribir los datos

    3. Cerrar el flujo para liberar los recursos

  2. La lectura con flujos se hace de forma secuencial:

    1. Se lee hasta llegar al fin de archivo (EOF, end of file)

    2. Hay que distinguir un archivo vacío de uno truncado (cortado a medias)

    3. La lectura puede hacerse línea a línea o carácter a carácter

  3. La escritura tiene distintos modos:

    1. Crear un fichero nuevo, reemplazar el contenido existente o rechazar la operación si ya existe: son opciones distintas

    2. Anexar (append): se añade al final sin borrar lo anterior

    3. Elegir mal el modo puede perder datos ya guardados

  4. El cierre de recursos es obligatorio:

    1. Un flujo abierto ocupa recursos del sistema

    2. Si no se cierra, puede bloquear el archivo o agotar los recursos

    3. Se garantiza con una construcción de gestión de recursos, como with en Python o try-with-resources en Java

  5. Comprobación de ida y vuelta:

    1. Guardar un conjunto de datos y volver a leerlo debe dar el mismo resultado

    2. Es la forma más sencilla de verificar que la escritura fue correcta

    3. Hay que prestar atención a los caracteres no ASCII (acentos, ñ, …)

Para leer y ejecutar: lectura y escritura en Python y try-with-resources en Java. Compara Flujos.java y flujos.py; cambia anexado por reemplazo.

Vídeo de apoyo: leer, escribir y cerrar

Corey Schafer, File Objects (Python, inglés). Fíjate en los modos de apertura y en with. Predice qué datos desaparecen al usar escritura en lugar de anexado.

Actividad

Ejecuta Flujos o flujos.py. Cambia APPEND por TRUNCATE_EXISTING en Java, o "a" por "w" en Python. Predice qué nombres conservará el archivo. Localiza dónde se cierra la lectura.

Comprobación razonada

Con anexado aparecen los cuatro estudiantes; con reemplazo solo queda Estudiante D. El recurso se cierra al salir de su bloque. Leer un flujo vacío alcanza el fin inmediatamente; un documento truncado puede contener texto pero fallar al interpretarlo. Cerrar el flujo no valida su contenido.

1.2.4. Representar datos en CSV y JSON

  1. CSV (valores separados por comas) es un formato tabular plano:

    1. Cada registro es una fila; puede ocupar varias líneas físicas si un campo entrecomillado contiene saltos de línea

    2. Los campos se separan por un delimitador (coma, punto y coma, …)

    3. Los campos con delimitadores o saltos de línea se protegen con comillas; una comilla dentro de un campo se representa habitualmente duplicándola

    4. Es sencillo, pero no representa jerarquías (todo es una tabla plana)

  2. JSON (JavaScript Object Notation) es un formato jerárquico:

    1. Objetos: conjunto de pares clave-valor entre llaves { }

    2. Arrays: listas ordenadas de valores entre corchetes [ ]

    3. Tipos: texto, número, booleano, nulo, objeto y array

    4. Permite anidar estructuras (una empresa con su lista de tutores)

  3. Serializar y deserializar:

    1. Serializar: convertir datos en memoria a una representación almacenable (texto o binario); deserializar reconstruye los datos

    2. El parser reconoce la sintaxis; el binding vincula esos datos con objetos del lenguaje. No reconstruye automáticamente cualquier clase

    3. Parsear (leer la sintaxis) no es lo mismo que validar (comprobar que los datos tienen sentido para el negocio)

  4. Elección del formato:

    1. CSV: datos tabulares simples, compatibles con hojas de cálculo

    2. JSON: estructuras con relaciones y anidamiento

    3. Ambos son texto plano y legibles por personas

    Consulta los esquemas visuales de JSON: objeto, array y valor. Para CSV, fija siempre delimitador, comillas, codificación y presencia de cabecera; un split no sustituye a un parser.

Para leer y ejecutar: los ejemplos de CSV (Wikipedia) y los tipos de JSON (Wikipedia). Para las llamadas concretas, consulta csv de Python y Apache Commons CSV. Ejecuta Formatos.java o formatos.py y explica por qué el delimitador del nombre no produce otra columna.

Vídeos de apoyo: CSV y JSON

Corey Schafer (Python, inglés). En CSV observa cabecera y delimitador; en JSON distingue load/dump de loads/dumps. Selecciona el vídeo del formato que necesites reforzar.

Actividad

Ejecuta JsonObjetos. Añade un tutor a muestra() y comprueba que se recupera desde el fichero. Identifica los cuatro pasos: objeto, texto JSON, archivo y objeto recuperado. ¿Por qué pueden tener los mismos valores sin ser la misma instancia?

Comprobación razonada

Jackson serializa con writeValueAsString y reconstruye el tipo indicado con readValue(texto, Empresa.class). Los record del ejemplo comparan sus valores con equals; == compara identidad. El binding necesita conocer la estructura; no comprueba por sí solo las reglas FCT.

Escribir un CSV exige acordar columnas, delimitador y codificación. La biblioteca se ocupa de comillas y escapes; la aplicación decide qué valores colocar en cada columna. Un registro puede ocupar varias líneas físicas.

Actividad

Ejecuta CsvEscritura. Añade un registro con un nombre que contenga ;, comillas y un salto de línea. Compara el texto del fichero con los valores recuperados por el lector.

Comprobación razonada

CSVPrinter.printRecord escribe un registro y protege sus campos. El lector recupera los valores originales. Contar líneas o usar split no permite interpretar correctamente este caso.

1.2.5. Transformar datos y reconocer pérdidas

  1. Para convertir entre formatos se usa un modelo intermedio:

    1. Se lee el formato de origen y se construye un objeto en memoria

    2. Ese objeto se escribe en el formato de destino

    3. El objeto actúa como puente entre los dos formatos

  2. La conversión puede perder información:

    1. Al aplanar una jerarquía se cambia la estructura; los datos pueden conservarse mediante varias tablas CSV e identificadores relacionados

    2. Algunos tipos no tienen equivalente en el formato de destino

    3. Hay que declarar qué se pierde y decidir si es aceptable

  3. Una conversión reproducible:

    1. Dado el mismo origen, produce siempre el mismo destino

    2. Se puede verificar comparando los campos y valores conservados

    3. Cambiar la extensión de un archivo no es convertirlo

El mismo dato, varias representaciones. Esta empresa tiene dos tutores. Compara qué puedes reconstruir con cada representación:

{
  "id": "E01",
  "nombre": "Empresa A",
  "tutores": [
    {"id": "T01", "nombre": "Tutor A"},
    {"id": "T02", "nombre": "Tutor B"}
  ]
}

El array conserva los tutores dentro de la empresa.

empresas.csv:

id;nombre
E01;Empresa A

tutores.csv:

id;nombre;empresa_id;orden
T01;Tutor A;E01;0
T02;Tutor B;E01;1

empresa_id permite reconstruir la relación; orden conserva la posición en la lista. Hay que acordar cómo interpretar ambos archivos. Una empresa sin tutores aparece solo en empresas.csv.

id;nombre
E01;Empresa A

Es una proyección: conserva la empresa, pero omite sus tutores. No permite reconstruir el dato original completo. La pérdida procede de seleccionar menos información, no de una imposibilidad de relacionar CSV.

La comparación conserva los datos del modelo mostrado, no cualquier detalle textual de los documentos. Es un ejemplo conceptual: no añade otro entregable ni cambia el CSV de asignaciones definido en la práctica FCT.

Otro formato que encontraremos: XML también es texto estructurado, mediante etiquetas y atributos, por ejemplo <empresa id="E01">Empresa A</empresa>. Su lectura, escritura y tratamiento se desarrollarán en la última unidad.

Actividad

Ejecuta Conversion.java o conversion.py. Añade un tutor al origen y predice si cambia el CSV de resumen. Identifica el modelo intermedio y explica qué necesitarías exportar para recuperar también los tutores.

Comprobación razonada

El modelo intermedio es la empresa recuperada. El resumen solo selecciona ID y nombre: añadir tutores no cambia sus columnas. Para conservarlos podríamos usar otra tabla relacionada por empresa_id y guardar su orden. Cambiar una extensión no realiza ninguna de estas operaciones.

1.2.6. Validación y recuperación ante errores

  1. Los errores al trabajar con ficheros pueden ser de varios tipos:

    1. De acceso: el archivo no existe o no hay permisos

    2. De sintaxis: el contenido no respeta el formato esperado

    3. De datos: los valores no son válidos para el negocio

  2. Ante un error hay dos estrategias:

    1. Propagar el error: dejar que lo trate una capa superior

    2. Tratar el error: capturarlo y decidir cómo recuperarse

    3. Cada capa debe decidir qué errores le corresponden

  3. La liberación de recursos debe garantizarse siempre:

    1. Tanto si la operación tiene éxito como si falla

    2. El bloque finally o try-with-resources lo aseguran

    3. Un error a mitad de escritura puede dejar el archivo a medias

  4. La escritura segura evita perder datos:

    1. Validar los datos y serializarlos antes de escribir

    2. Escribir en un archivo temporal y cerrarlo antes de reemplazar el destino mediante una operación atómica cuando el sistema de archivos la soporte

    3. El temporal debe estar en el mismo sistema de archivos. Esto evita ver un fichero a medias, pero no equivale a transacciones entre varios ficheros

  5. Distinguir los tres resultados posibles:

    1. Éxito: la operación se completó

    2. Fracaso: la operación no se realizó

    3. Operación incompleta: se realizó a medias (el caso más peligroso)

En la práctica FCT, la validación comprueba el estado antes de serializarlo; no se relee el temporal para validarlo. El recorrido es este:

Recorrido del guardado correcto
  1. Validar el estado en memoria.

  2. Serializar los datos válidos.

  3. Escribir y cerrar un temporal junto al destino.

  4. Reemplazar el destino atómicamente.

  5. Notificar el guardado correcto.

Si ocurre el fallo controlado antes del reemplazo

Se limpia el temporal y se comunica el error. Se conserva el fichero anterior y no se emite una notificación de éxito. El destino no se sustituye por datos a medias.

La segunda tarjeta destaca el fallo controlado previo al reemplazo. Si la serialización falla, tampoco se modifica el destino. Si el sistema no soporta el movimiento atómico, la implementación propaga el error, sin sustituirlo silenciosamente por una escritura directa. No se prometen transacciones entre varios ficheros ni recuperación ante cualquier caída o corte de alimentación.

Para leer y ejecutar: excepciones en Python y las condiciones de Files.move en Java. Ejecuta Errores.java y errores.py; explica por qué el contenido anterior sigue disponible tras el fallo.

Vídeo de apoyo: tratar excepciones

Corey Schafer, Try/Except Blocks (Python, inglés). Localiza qué excepciones se capturan y para qué sirve finally. El ejemplo del repositorio añade la comprobación del estado del fichero, no solo un mensaje de error.

Actividad

Ejecuta Errores o errores.py. Predice qué contenido conserva el archivo tras el fallo controlado. Desactiva solo ese fallo y repite. Clasifica además fichero inexistente, JSON truncado y fecha final anterior a la inicial como errores de acceso, sintaxis o datos.

Comprobación razonada

Con fallo permanece anterior; con éxito se escribe nuevo. Ausencia es acceso; truncado, sintaxis; fechas incoherentes, datos. finally limpia el temporal; no deshace automáticamente bytes ya escritos.

1.2.7. Un componente de persistencia

  1. Un componente es una pieza de software reutilizable e independiente:

    1. Ofrece una funcionalidad concreta (en nuestro caso, guardar y recuperar datos)

    2. Se puede usar desde distintas partes de la aplicación

    3. Oculta los detalles de su implementación interna

  2. El contrato (interfaz) define qué hace el componente:

    1. Las operaciones que ofrece (guardar, listar, buscar, eliminar)

    2. Es independiente de cómo se implementan

    3. Permite sustituir una implementación por otra sin tocar el resto

  3. La implementación es la clase concreta que cumple el contrato:

    1. En esta unidad, guarda los datos en ficheros

    2. En unidades posteriores, los guardará en bases de datos

    3. El resto de la aplicación no necesita saberlo

  4. Las propiedades configuran el componente:

    1. Por ejemplo, la ruta donde se guardan los datos o el formato usado

    2. Se establecen al crear el componente o mediante métodos de configuración

  5. Los eventos permiten notificar cambios:

    1. El componente avisa cuando ocurre algo relevante (p. ej. datos guardados)

    2. Otras partes de la aplicación pueden reaccionar a ese aviso

    3. Un evento no es una excepción: informa, no interrumpe

    Esa es su finalidad, no una garantía del lenguaje: el código que recibe una notificación también podría lanzar una excepción. En la práctica FCT, el notificador debe terminar sin lanzarla. Como se ejecuta después de guardar, un fallo suyo no desharía el almacenamiento ya realizado.

  6. Herramientas de desarrollo del componente:

    1. Editor/IDE para escribir y depurar; compilador o intérprete para ejecutar

    2. Bibliotecas de formatos para parsear y serializar sin crear analizadores propios

    3. Pruebas para comprobar el contrato y herramienta de empaquetado para distribuirlo

    4. Control de versiones para conservar cambios; las herramientas concretas se preparan en el entorno de la práctica amplia

Para leer y ejecutar: interfaz en programación (Wikipedia). Compara Componente.java y componente.py: ambos usan una implementación en memoria para estudiar el contrato antes de persistir en disco.

En la práctica FCT se separan dos responsabilidades. ServicioFct ofrece las operaciones sobre empresas, estudiantes y asignaciones; el contrato AlmacenFct solo define guardar(Estado) y recuperar(). RepositorioJson implementa ese contrato. Por tanto, no tienes que añadir buscar o eliminar a AlmacenFct para reproducir el pequeño ejemplo de esta clase: el servicio resuelve esas operaciones usando el almacén.

Actividad

Ejecuta Componente o componente.py y busca un identificador ausente. Después abre AlmacenFct y ServicioFct. ¿Quién filtra estudiantes y quién guarda el estado? Localiza la ruta configurable y el aviso de éxito en el laboratorio.

Comprobación razonada

La búsqueda ausente devuelve Optional.empty() en Java o None en Python. Un fallo de acceso es otra situación. En FCT, el servicio filtra estudiantes; el almacén guarda y recupera estados. La ruta configura dónde persiste y la notificación solo se emite después de guardar correctamente.

1.2.8. Probar y documentar la persistencia

  1. Las pruebas verifican que el componente funciona:

    1. Casos normales: la operación habitual con datos válidos

    2. Casos límite: archivo vacío, un solo registro, muchos registros

    3. Casos de error: archivo inexistente, sin permisos, datos inválidos

    4. Las pruebas deben aislar sus datos (usar directorios temporales)

  2. Una prueba debe ser reproducible:

    1. Define el resultado esperado antes de ejecutarla

    2. Cualquier persona puede ejecutarla y obtener el mismo resultado

    3. Una prueba que no comprueba nada no sirve

  3. La documentación hace el componente utilizable:

    1. Describe el contrato (qué operaciones ofrece)

    2. Explica la configuración (qué propiedades hay que establecer)

    3. Documenta los errores que puede lanzar

    4. Incluye un ejemplo de uso mínimo

  4. El empaquetado permite distribuir el componente:

    1. Se distribuye un módulo o paquete (p. ej. un JAR) y se declaran sus dependencias; no todos los paquetes contienen esas dependencias dentro

    2. Otro proyecto puede incluirlo y usarlo sin ver su código interno

Sin datos no significa sin fichero. En el contrato de la práctica FCT, estas situaciones tienen resultados diferentes:

Qué debe comprobar la lectura

Situación

Resultado esperado

Fichero inexistente

Error de acceso; no se inventa un estado vacío.

Fichero de cero bytes

Error de lectura del documento JSON: no contiene un valor JSON válido.

JSON mal formado, por ejemplo {

Error de sintaxis; no se devuelve una colección vacía como éxito.

Estado vacío válido, guardado con Estado.vacio()

Recuperación correcta de un estado sin entidades.

Un JSON sintácticamente correcto tampoco garantiza un estado válido: debe cumplir la estructura esperada y las reglas del dominio. {}, por ejemplo, no sustituye al estado vacío definido por el contrato.

Para leer y ejecutar: prueba unitaria (Wikipedia) y JUnit, guía de usuario. Ejecuta las pruebas de formatos y las pruebas de flujos y reemplazo siguiendo la guía. Las primeras releen JSON y CSV; las segundas comprueban texto y escritura segura. Para unir las ideas, abre el laboratorio de empresas, con recorrido Java y alternativa Python.

Vídeo de apoyo: una prueba con expectativa

Corey Schafer, Unit Testing (Python, inglés). Observa cómo una expectativa incorrecta provoca un fallo. Después distingue una igualdad en memoria de nuestra relectura desde disco.

Actividad

En FormatosTest, cambia la expectativa de igualdad de valores JSON por identidad (assertSame). Ejecuta, interpreta el fallo y restaura la prueba. Ejecuta después el laboratorio. Anota un resultado normal y uno de error, con el comando para repetirlos. ¿Qué archivo demuestra que se leyó desde disco?

Comprobación razonada

La deserialización crea otra instancia, aunque sus valores coincidan. El laboratorio recupera empresas.json con un componente nuevo y conserva sus bytes ante el fallo controlado. La documentación debe permitir repetirlo: comando, ruta, resultado esperado y resultado observado.

Test de autoevaluación

Realiza el test interactivo de autoevaluación. Es repetible y no tiene calificación.

Actividad final integradora

Aplica lo aprendido en la práctica de persistencia en ficheros del caso FCT.