Protocolos de Persistencia (Mock Data)

La implementación de servicios y protocolos es fundamental para estructurar correctamente una aplicación en Swift. Al establecer una arquitectura sólida desde el principio, garantizamos que nuestro código sea mantenible, escalable y fácil de probar. En este artículo, exploraremos cómo implementar servicios y protocolos en un proyecto de Swift, siguiendo buenas prácticas de programación.

¿Cómo estructurar los servicios en un proyecto Swift?

Para mantener un proyecto organizado, es esencial crear una estructura de carpetas que refleje la arquitectura de nuestra aplicación. El primer paso es crear una carpeta específica para nuestros servicios:

1. Crear una carpeta llamada "services" en la raíz del proyecto.
2. Dentro de esta carpeta, organizaremos los diferentes protocolos y servicios.

Esta organización nos permite acceder fácilmente a nuestros archivos y mantener una estructura clara del proyecto. La separación de responsabilidades es clave para mantener un código limpio y fácil de mantener.

¿Qué son los protocolos y por qué son importantes?

Los protocolos en Swift definen un conjunto de métodos, propiedades y otros requisitos que una clase, estructura o enumeración debe implementar. Funcionan como un contrato que garantiza que las clases que los adoptan cumplan con ciertos comportamientos.

Vamos a crear dos protocolos fundamentales:

1. Database Service Protocol: Define las operaciones básicas para interactuar con una base de datos.

protocol DatabaseServiceProtocol {
    func fetchRecords(filter: RecordFilter) -> [Record]
    func saveRecord(_ record: Record) -> Bool
    func updateRecord(_ record: Record) -> Bool
    func deleteRecord(_ record: Record) -> Bool
    func getTotals() -> (income: Double, expense: Double)
}

2. To Record Protocol: Permite convertir instancias de bases de datos en objetos de tipo Record que pueden ser utilizados por nuestras vistas.

protocol ToRecordProtocol {
    func toRecord() -> Record
}

La importancia de estos protocolos radica en que nos permiten separar la implementación de la interfaz, lo que facilita la creación de diferentes implementaciones (como bases de datos reales o datos de prueba) sin afectar el resto del código.

¿Cómo implementar un servicio de base de datos simulada?

Para probar nuestra aplicación sin necesidad de una base de datos real, podemos crear un servicio que utilice datos simulados (mock data). Esto es especialmente útil para:

• Realizar pruebas unitarias
• Utilizar previews en SwiftUI
• Verificar que nuestra arquitectura funciona correctamente

Creación de un Mock Database Service

1. Crear una subcarpeta dentro de "services" llamada "MockDatabaseService"
2. Crear un archivo Swift con el mismo nombre
3. Implementar la clase que adopte nuestro protocolo

class MockDatabaseService: DatabaseServiceProtocol {
    private var mockRecords = MockRecordsHelper.mockRecords()
    
    func fetchRecords(filter: RecordFilter) -> [Record] {
        return ApplyFilter.applyFilter(to: mockRecords, filter: filter)
    }
    
    func saveRecord(_ record: Record) -> Bool {
        return false
    }
    
    func updateRecord(_ record: Record) -> Bool {
        return false
    }
    
    func deleteRecord(_ record: Record) -> Bool {
        return false
    }
    
    func getTotals() -> (income: Double, expense: Double) {
        return (0, 0)
    }
}

En este ejemplo, utilizamos una función auxiliar mockRecords() que genera datos aleatorios para nuestras pruebas. La función fetchRecords implementa un filtrado de estos datos según los criterios proporcionados, mientras que las demás funciones simplemente devuelven valores predeterminados.

Ventajas de utilizar datos simulados

• Desarrollo independiente: Podemos desarrollar la interfaz de usuario sin depender de una base de datos real.
• Pruebas rápidas: No necesitamos configurar una base de datos para probar nuestra aplicación.
• Consistencia: Los datos simulados pueden ser consistentes entre ejecuciones, lo que facilita la depuración.

La implementación de servicios simulados nos permite avanzar en el desarrollo mientras se completan otras partes del sistema, como la implementación real de la base de datos.

¿Cómo verificar que nuestra implementación es correcta?

Para asegurarnos de que nuestra implementación funciona correctamente, podemos compilar el proyecto utilizando el comando Command+B en Xcode. Si no hay errores de compilación, significa que nuestra estructura básica está correctamente implementada.

Es importante recordar que esta es solo la estructura básica. A medida que avancemos en el desarrollo, implementaremos servicios reales que se conecten a bases de datos y proporcionen funcionalidad completa a nuestra aplicación.

La arquitectura basada en protocolos nos proporciona la flexibilidad necesaria para cambiar implementaciones sin afectar al resto del código, lo que resulta en una aplicación más robusta y fácil de mantener. ¿Has implementado arquitecturas similares en tus proyectos? Comparte tu experiencia en los comentarios.