Pruebas de desarrollo para IOS

¿Te gustaría aprender Apps Móviles con IOS?

Tenemos los cursos que necesitas.¡Haz clic aquí!

Configurando nuestro proyecto

Primero, debe crear un proyecto de vista única con objetivos de Pruebas unitarias y Pruebas de IU :

La mayoría de las aplicaciones de App Store se comunican con la nube, obtienen datos y se los muestran al usuario. Para trabajar sobre una base sólida sobre la cual construir características, debe simular los dos lados que se comunicarán con su sistema. El primer lado es la interacción del usuario, que se puede hacer usando pruebas de IU que desencadenan eventos de usuario como si fueran de un usuario real. En cuanto a la nube, puede usar un marco como Swifter para simular las solicitudes del servidor.

Envoltura Swifter

Swifter es una herramienta que lo ayudará a bloquear las solicitudes de aplicaciones y devolver la respuesta deseada para facilitar las pruebas y evitar la fragilidad de las pruebas.

Vamos a hacer una clase de envoltura sobre Swifter para facilitar las solicitudes de conexión de red.

Crearemos una clase llamada HTTPDynamicStubs , que proporcionará un método público. Solo necesita agregar la URL que desea incluir y el enlace al archivo JSON (más sobre esto más adelante) para que se devuelva cuando su aplicación solicite esta API y el HTTPMethod.

Antes de cada caso de prueba, todo lo que necesita hacer es crear una instancia HTTPDynamicStubsy llamar a un método de configuración, que iniciará el servidor y cambiará la URL base a localhost. Para quitar los trozos, tearDownel HTTPDynamicStubsdespués de cada prueba.

anular func setUp () {
        continueAfterFailure = false
        dynamicStubs.setUp ()
        app.launchEnvironment = ["BASEURL": "http: // localhost: 8080"]
        continueAfterFailure = false
        super.setUp ()
    }

    anular func tearDown () {
        super.tearDown ()
        dynamicStubs.tearDown ()
    }

Dentro de cada caso de prueba, puede bloquear solicitudes y devolver el JSON que necesita.

func testMoviesList () {
        dynamicStubs.setupStub (url: "/ Movies", nombre de archivo: "listOfMovies", método: .GET)
        app.launch ()
    }

Historia del usuario

Como dije antes, TDD sólido comienza escribiendo buenas historias de usuario con criterios claros de aceptación. Representaremos cada historia de usuario con una prueba de interfaz de usuario de extremo a extremo.

Nota: No puede escribir pruebas de extremo a extremo para todo. Si lo hace, terminará con pruebas muy lentas que ni siquiera podrá ejecutar cada vez.

Para recapitular, aquí está nuestra historia de usuario:

Como usuario, quiero poder ver una vista de lista para poder elegir mi próxima película.

Si desea seguir este tutorial, preparé un archivo JSON que contiene una lista de películas que nos ayudarán a probar esta historia de usuario.

[
    {
        "name": "Avengers: Infinity War",
        "rating": "8.5",
        "desc": "Los Vengadores y sus aliados deben estar dispuestos a sacrificar todo en un intento de derrotar al poderoso Thanos antes de que su bombardeo de devastación y ruina ponga fin al universo".
        
    },
    {
        "name": "Bohemian Rhapsody",
        "rating": "8.4",
        "desc": "Una crónica de los años previos a la legendaria aparición de Queen en el concierto Live Aid (1985)",
        
    },
    {
        "nombre": "Aquaman",
        "rating": "8.3",
        "desc": "Arthur Curry se entera de que él es el heredero del reino submarino de Atlantis, y debe dar un paso adelante para liderar a su gente y ser un héroe para el mundo".
        
    },
    {
        "name": "Ha nacido una estrella",
        "rating": "8.2",
        "desc": "Un músico ayuda a un joven cantante a encontrar fama, incluso cuando la edad y el alcoholismo envían su propia carrera hacia una espiral descendente",
        
    },
]

Escribir nuestra prueba de punta a punta

Según nuestra historia de usuario, un usuario deberá abrir la aplicación y ver la lista de películas. Según nuestros criterios de aceptación, cada película tendrá un nombre y calificación. Por lo tanto, necesito escribir una prueba que inicie la aplicación y me asegure de que haya una tableViewpelícula llena, con el nombre y la calificación de cada película.

func testShowingMovieNameAndImageName () {
        dynamicStubs.setupStub (url: "/ Movies", nombre de archivo: "listOfMovies", método: .GET)
        app.launch ()

        let tablesQuery = app.tables
        
        // Afirmar en la primera película
        XCTAssertTrue (tablesQuery.cells.staticTexts ["Avengers: Infinity War"]. Existe, "Error: no se mostró el primer nombre de la película")
        XCTAssertTrue (tablesQuery.cells.staticTexts ["8.5"]. Existe, "Error: no se mostró la calificación de la primera película")

        // Afirma en la segunda película
        XCTAssertTrue (tablesQuery.cells.staticTexts ["Bohemian Rhapsody"]. Existe, "Error: no se muestra el segundo nombre de la película")
        XCTAssertTrue (tablesQuery.cells.staticTexts ["8.4"]. Existe, "Error: no se mostró la calificación de la segunda película")

        // Afirmar en la tercera película
        XCTAssertTrue (tablesQuery.cells.staticTexts ["Aquaman"]. Existe, "Error: no se muestra el nombre de la tercera película")
        XCTAssertTrue (tablesQuery.cells.staticTexts ["8.3"]. Existe, "Error: no se mostró la calificación de la tercera película")

        // Afirma en la cuarta película
        XCTAssertTrue (tablesQuery.cells.staticTexts ["A Star Is Born"]. Existe, "Error: no se muestra el nombre de la cuarta película")
        XCTAssertTrue (tablesQuery.cells.staticTexts ["8.2"]. Existe, "Error: no se mostró la cuarta calificación de la película".)
    }

Línea 1: Aplique la solicitud de red para películas y devuelva el archivo JSON simulado.

Líneas 3, 4, 5: Afirma el nombre y la calificación de cada película dentro UITableView.

Después de escribir la prueba de extremo a extremo, debe hacer que la prueba falle. Lea los mensajes de afirmación y pregúntese si realmente comprende los problemas de leer los mensajes. Si no, reescribe mensajes más significativos. Esto lo ayudará a identificar problemas más adelante cuando cambie algún código y esta prueba falle.

Criterios de aceptación

Ahora es el momento de escribir la prueba de integración para nuestros criterios de aceptación. En resumen, aquí están nuestros criterios de aceptación:

La aplicación debe mostrar el nombre y la calificación de cada película.

Al escribir pruebas de integración, imagine los componentes de su sistema que serán responsables de implementar esta parte de la función y cómo se comunicarán entre sí.

Las pruebas de integración excluyen el componente UI y solo prueban la funcionalidad después de la capa UI (se supone que es rápida). Si va a utilizar un patrón arquitectónico MVP en su aplicación, sus pruebas de integración se asegurarán de que la capa de presentación se comunicará correctamente con la capa del modelo.

Por lo tanto, activaremos una acción desde la capa de presentación, bloquearemos la solicitud de red y confirmaremos la devolución de llamada para asegurarnos de que la colaboración funcione entre la presentación, el modelo y las capas de red.

Escribir nuestra prueba de integración

Con MVP, View será responsable de mostrar los datos y escuchar las interacciones del usuario, mientras que Model será responsable de definir la lógica de negocios y buscar, actualizar e insertar los datos. El presentador se asegurará de desacoplar la interacción entre el Modelo y la Vista, y actuará como la capa de comunicación entre ellos.

Ahora necesito imaginar cuántos objetos tendré, la responsabilidad de cada objeto y cómo interactuarán entre sí.

Así que creo que lo necesitaré MovieListPresenter, que será responsable de pedirle MovieListModelque busque las películas. MovieListModellos buscará a través de la capa de red, recibirá el JSON, analizará el JSON y los devolverá al presentador.

func testShowingMovieNameAndImageName () {
        let networkLayer = NetworkLayerMock (mockedData: [["name": "Avengers: Infinity War", "rating": "8.5"], ["name": "Bohemian Rhapsody", "rating": "8.4"]])
        let moviesListModel = MoviesListModel (networkLayer: networkLayer)
        let moviesListPresenter = MoviesListPresenter (moviesListModel: moviesListModel)
        let viewControllerMock = ViewControllerMock ()
        moviesListPresenter.delegate = viewControllerMock
        moviesListPresenter.fetchMovies ()
        
        XCTAssertTrue (viewControllerMock.didFetchMovies, "Éxito en la obtención de películas")
        XCTAssertTrue (moviesListPresenter.movieName (index: 0) == "Avengers: Infinity War", "El primer nombre de la película no es el esperado")
        XCTAssertTrue (moviesListPresenter.movieRating (index: 0) == "8.5", "La calificación de la primera película no es la esperada")
        XCTAssertTrue (moviesListPresenter.movieName (index: 1) == "Bohemian Rhapsody", "El segundo nombre de la película no es el esperado")
        XCTAssertTrue (moviesListPresenter.movieRating (index: 1) == "8.4", "La calificación de la segunda película no es la esperada")
    }

Esta prueba de integración le pedirá MoviesListPresenterbuscar películas. Se supone que recibe una devolución de llamada cuando recibe una respuesta con éxito o la solicitud falla. Por lo tanto, esta prueba debe simular la capa de red y simular que una solicitud real proviene de la nube.

Pasos:

Necesito crear una capa de red simulada, que devolverá respuestas específicas para poder afirmar los datos devueltos por Presenter.
Necesito crear MoviesListModel, que será responsable de llamar a la capa de red, recibir una respuesta y analizar los datos.
Presenter usará Model para buscar películas y volver a formatear las películas que se mostrarán en los componentes de la interfaz de usuario.

Nota: Aquí no debería poder recibir objetos de MoviesListPresenter. Solo se supone que devuelve tipos de datos primitivos para aislar totalmente el Modelo de la Vista.

Capa de red

Por el bien de este proyecto de ejemplo, no vamos a implementar una capa de red completa. Construiremos el bloque de código más simple para ejecutar una GETsolicitud y devolver una respuesta.

open func executeGETRequest (api: String, completeBlock: @escaping (Data?) -> Void) {
        let environment = ProcessInfo.processInfo.environment
        var baseUrl: String = ""

        if let _ = environment ["isUITest"] {
            // Ejecutando una prueba de IU
            baseUrl = ProcessInfo.processInfo.environment ["BASEURL"]!
        } más {
            baseUrl = "https://api.example.com"
        }

        guard let gitUrl = URL (string: baseUrl + api) else {return}
        let session = URLSession (configuración: URLSessionConfiguration.default)
        let dataTask = session.dataTask (con: gitUrl) {(datos, respuesta, error) en
            guarda let data = data else {return}
            hacer {
                si deja returnData = String (datos: datos, codificación: .utf8) {
                    print (returnData)
                } más {
                    print ("vacío")
                }
            }
            
            si let err = error {
                print ("Err", err)
            }
            
            completeBlock (datos)
        }
        dataTask.resume ()
    }

Para este tutorial, no vamos a escribir pruebas para esta clase, pero es factible usar una biblioteca de terceros como OHTTPStubs .

Escritura de pruebas unitarias y escritura de código para hacerlos pasar

Después de terminar el diseño y escribir la prueba de integración, revisaremos cada objeto y escribiremos pruebas unitarias para cada clase, y luego escribiremos el código para que estas pruebas pasen.

MoviesListModel

MoviesListModelusará la capa de red para buscar y analizar datos. Para realizar la prueba MovieListModel, necesitamos resguardar las solicitudes de red. Por lo tanto, necesitamos implementar un objeto simulado para la capa de red que tome la respuesta deseada como parámetro en la inicialización y la devuelva dentro de una devolución de llamada.

clase NetworkLayerMock: Red {

    privado let mockedData: [[String: String]]
    
    init (mockedData: [[String: String]]) {
        self.mockedData = mockedData
    }

    anular func executeGETRequest (api: String, completeBlock: @escaping (Data?) -> Void) {
        let data = toJSONString (mockedData: self.mockedData)
        completeBlock (datos)
    }
    
    func toJSONString (mockedData: [[String: String]]?) -> Datos? {
        si let arr = mockedData {
            dejar dat = probar? JSONSerialization.data (con JSONObject: arr, opciones: .prettyPrinted)
            regresar dat
        }
        volver nulo
    }
}

Espero recuperar películas MoviesListModely devolver las películas en la devolución de llamada. Entonces la prueba debería ser así:

func testFetchingMoviesFromNetworkLayer () {
        let networkLayer = NetworkLayerMock (mockedData: [["name": "name1", "rating": "12"], ["name": "name2", "rating": "123"]])
        let movieslistModel = MoviesListModel (networkLayer: networkLayer)
        let moviesListModelDelegateMock = MoviesListModelDelegateMock ()
        movieslistModel.delegate = moviesListModelDelegateMock
        movielistModel.fetchMovies ()
        
        XCTAssertTrue (moviesListModelDelegateMock.movies.count == 2, "Error al devolver el recuento esperado de películas")

        let firstMovie = moviesListModelDelegateMock.movies [0]
        let secondMovie = moviesListModelDelegateMock.movies [1]
        
        // Afirmando valores de películas
        XCTAssertTrue (firstMovie.name == "name1", "no se pudo analizar el primer nombre de la película")
        XCTAssertTrue (secondMovie.name == "name2", "no se pudo analizar el segundo nombre de la película")
        
        XCTAssertTrue (firstMovie.rating == "12", "no se pudo analizar la calificación de la primera película")
        XCTAssertTrue (secondMovie.rating == "123", "no se pudo analizar la clasificación de la segunda película")
    }

MoviesListModelDelegateMock es una clase auxiliar que me ayudará a afirmar los valores de la película.

clase MoviesListModelDelegateMock: NSObject, MoviesListModelDelegate {
    películas públicas var: [Película] = []
    func didFetchMovies (éxito: Bool, películas: [Película]) {
        self.movies = películas;
    }
}

Finalmente, vamos a escribir el código real. Implementemos MoviesListModelpara hacer pasar sus pruebas.

func fetchMovies () {
    self.networkLayer.executeGETRequest (api: "/ Movies", completeBlock: {(data) en
        si let moviesData = data {
            let movies = self.parseMovies (data: moviesData)
            si deja delegar = self.delegate {
                delegate.didFetchMovies (éxito: verdadero, películas: películas)
                regreso
            }
        }

        si deja delegar = self.delegate {
            delegate.didFetchMovies (éxito: falso, películas: [])
            regreso
        }
    })
}
func parseMovies (datos: datos) -> [Película] {
    hacer {
        Var películas: [Película] = []
        if let jsonArray = intente JSONSerialization.jsonObject (con: datos, opciones: .allowFragments) como? [[Cadena: Cadena]] {
            para objeto en jsonArray {
                let movie = Movie ()
                movie.name = object ["nombre"]
                movie.rating = object ["rating"]
                movies.append (película)
            }
            películas de regreso
        } más {
            regreso []
        }
    } catch let error como NSError {
        imprimir (error)
    }
    regreso []
}

Llamaremos a la capa de red, analizaremos el objeto devuelto y luego lo devolveremos a través del delegado.

Corramos de MovieListModelTestsnuevo.

¡Felicitaciones, tu primera prueba pasó!

Nota: De acuerdo con el Principio de responsabilidad única , MovieListModelestá haciendo dos trabajos: obtener datos de la red y analizarlos. Por lo tanto, debemos separar la funcionalidad de análisis en otra clase.

MovieParser

Una vez más, primero crearemos pruebas MovieParsery las veremos fallar, luego implementaremos el analizador. Después de terminar el refactor, deberá ejecutar MovieListModelTestsnuevamente para asegurarse de que todo funcione bien.

MoviesListPresenter

Comenzaremos escribiendo pruebas dentro MoviesListPresenterTests. Primero, tendremos que crear MoviesListModelMockpara resguardar las películas para que solo podamos probarlas fácilmente MoviesListPresenter.

clase MoviesListModelMock: MoviesListModel {
    var privada burlada Películas: [Película] = []

    conveniencia init (mockedMovies: [Película]) {
        self.init (networkLayer: Network ())
        self.mockedMovies = mockedMovies
    }

    anular func fetchMovies () {
        si deja delegar = self.delegate {
            delegate.didFetchMovies (éxito: falso, películas: self.mockedMovies)
            regreso
        }
    }
}

A continuación, pasaremos las películas simuladas a MoviesListModely lo pasaremos como un parámetro a MoviesListPresenter. Luego, afirme los métodos del presentador.

func testLoadingMovies () {
    let movie1 = Movie ()
    movie1.name = "name1"
    movie1.rating = "99"

    let movie2 = Movie ()
    movie2.name = "name2"
    movie1.rating = "100"

    let moviesListModelMock = MoviesListModelMock (mockedMovies: [película1, película2])
    let moviesListPresenter = MoviesListPresenter (moviesListModel: moviesListModelMock)
    moviesListPresenter.fetchMovies ()

    XCTAssertTrue (moviesListPresenter.movieName (index: 0) == "name1", "no se pudo obtener el primer nombre de película")
    XCTAssertTrue (moviesListPresenter.movieName (index: 1) == "name2", "no se pudo recuperar el segundo nombre de la película")
}

Ahora, necesitamos implementar la MoviesListPresenterclase para hacer las pruebas verdes.

Escribir código para hacer que nuestra prueba de integración pase

Ahora que hemos escrito pruebas unitarias fallidas y las hemos aprobado, podemos escribir nuestro código para que la prueba de integración pase.

Necesitamos hacer un inicializador que tome MoviesListModelcomo parámetro para permitir que Presenter lo use y haga que Presenter sea su delegado.

init (moviesListModel: MoviesListModel) {
    self.moviesListModel = moviesListModel
    super.init ()
    self.moviesListModel.delegate = self
}

El presentador buscará películas del modelo.

 func public fetchMovies () {
    self.moviesListModel.fetchMovies ()
}

ViewControllernecesita mostrar datos dentro UIComponentsy el presentador no debe exponer el modelo a la interfaz de usuario. Por lo tanto, debemos crear una capa de abstracción para ocultar Model de nuestra interfaz de usuario.

public func moviesCount () -> Int {
    return self.movies.count
}
func movieName (index: Int) -> String {
    let movie = self.movies [índice]
    si deja movieName = movie.name {
        return movieName
    }

    regreso ""
}
func movieRating (index: Int) -> String {
    let movie = self.movies [índice]
    si deja que movieRating = movie.rating {
        película de regreso
    }

    regreso ""
}

Entonces podemos ejecutar todas nuestras pruebas unitarias y la prueba de integración. Todo debería pasar. ✅

Lo último que debemos hacer es pasar la prueba de punta a punta.

Escribir código para hacer nuestro pase de prueba de punta a punta

Después de implementar la interfaz de usuario, deberá crear una instancia desde MoviesListPresenteradentro MoviesListViewControllere implementar su delegado.

anular func viewDidLoad () {
    super.viewDidLoad ()
    self.moviesListPresenter = self.moviesPresenter ()
    self.moviesListPresenter? .delegate = self
    self.moviesListPresenter? .fetchMovies ()
    /// Realice cualquier configuración adicional después de cargar la vista.
}
func moviesPresenter () -> MoviesListPresenter {
    let networkLayer = Red ()
    let moviesModel = MoviesListModel (networkLayer: networkLayer)
    let moviesListPresenter = MoviesListPresenter (moviesListModel: moviesModel)

    volver películasListaPresentador
}

Luego, ejecute su prueba de punta a punta. Todo debería pasar.

Entonces cerramos…

Si tiene múltiples criterios de aceptación, deberá escribir más pruebas de integración para cada una de ellas para completar su historia de usuario.

En este tutorial, aprendió a implementar una historia de usuario completa con pruebas sólidas sin la necesidad de integración de back-end. Para asegurarse de que está integrado correctamente con la nube, necesitará una copia de la prueba de extremo a extremo para ejecutar realmente en una cuenta de prueba.

Ahora, gracias a TDD, después de desarrollar más funciones en este proyecto, si falla una de las pruebas anteriores, tendrá una pista rápida sobre qué parte del código tiene un problema.

Te esperamos en los próximos artículos en donde hablaremos mas acerca de estos temas que hoy en día son de importancia e interés en el mundo de la tecnología.

¿Te gustaría aprender Apps Móviles con IOS?

Tenemos los cursos que necesitas.¡Haz clic aquí!

L	M	X	J	V	S	D
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30

Automatización de Tareas con Python: Scripts y Herramientas

Guía Completa para Automatizar Respuestas en WhatsApp con una Plataforma Multiagente

Automatización de Envíos con API Rest: Desde la Cotización Hasta la Entrega

Administración de Sistemas Linux: Comandos Esenciales y Trucos

Configurando nuestro proyecto

About Author

NGuerrero