Objcetif de la solution de test automatisé

La mise en place de tests automatisés vise à améliorer l'efficacité des tests de régrestion et à augmenter la couverture de test pour les mini-programs WeChat. L'approche par scripts permet de réduire les efforts manuels et d'éviter les erreurs de régression.

Choix de la technologie

Le framework Minium a été sélectionné pour cette solution. Ce choix repose sur des caractéristiques du projet : les exigences changent peu, le cycle de projet est long, et les scripts de test peuvent être réutilisés à chaque itération. Ces facteurs justifient l'utilisation de scripts automatisés plutôt que d'autres approches sans code.

Objectifs par phases

La solution est divisée en trois étapes :

1. Exécution des tests de flux principaux : valider la solution technique pour des fonctionnalités stables.
2. Intégration d'un système de Mock : permettre des tests avec des données contrôlées pour la cohérence et la tolérance aux pannes.
3. Configuration des cas de test : permettre l'exécution de tests sans code via des fichiers de configuration.

Architecture de la solution

L'architecture comprend trois couches principales :

1. Couche de services de base

Inclut le routage, les utilitaires, le service Mock, et des fonctionnalités courantes comme la connexion et la géolocalisation.

2. Cas fonctionnels par page

Cette couche expose les opérations de base et les vérifications pour chaque page, telles que les interactions sur une page de recherche. Par exemple, pour la page de recherche, des méthodes sont fournies pour focaliser le champ, saisir du texte, et vérifier l'affichage des mots-clés.

# Focaliser le champ de recherche
def focus_search_input(self):
    log_process('Focalisation du champ de recherche')
    input_field = self.get_element('input', max_timeout=10)
    input_field.tap()
    self.wait_for(2)
    self.capture('champ_recherche_focalise')

# Effectuer une recherche
def enter_search_text(self, text):
    log_process('Texte de recherche :', text)
    input_field = self.get_element('input', max_timeout=10)
    input_field.input(text)
    self.wait_for(1)
    self.capture('texte_saisi_recherche')

# Vérifier l'affichage des mots populaires
def verify_hot_words_display(self):
    log_process('Vérification du nombre de mots populaires affichés')
    self.wait_for(10)
    search_bar = self.get_search_bar()
    suggestions = search_bar.data.themeSuggest
    current_idx = int(search_bar.data.currentIndex)
    if len(suggestions) > 0:
        theme_elem = search_bar.get_elements('.search-xxx', max_timeout=3)[current_idx]
        hot_word_elems = theme_elem.get_elements('.xxx-search-words-hot-text')
        self.mini.assertEqual(len(hot_word_elems), len(suggestions[current_idx]))

3. Tests de flux

Cette couche contient les cas de test concrets qui orchestrent des actions à travers plusieurs pages. Un exemple est un test de recherche qui navigue à travers différentes pages et vérifie les résultats.

# Aller à la page d'adresse
self.home.navigate_to_address()
self.home.wait_ready()

# Sélectionner une ville
self.address.open_city_selection()
self.address.wait_ready()
self.address.choose_city('Shanghai')
self.address.focus_input()
self.address.type_input('Oriental Pearl Tower')
self.address.confirm_address()

# Charger les données
self.home.load_content()
# Cliquer pour accéder à la page de recherche
self.home.click_search_button()

# Faire défiler les résultats de recherche
self.page.wait_for(10)
self.search.enter_search_text('water')
self.search.click_search_word(0)
self.page.wait_for(5)
self.search.scroll_results(1000)
# Vérifier une fonctionnalité spécifique
self.search.check_instant_delivery_available()

Simulation de données (Mock)

Le service Mock est essentiel pour garantir que les données utilisées lors des tests correspondent aux attentes. Minium permet de simuler des appels comme wx.request et wx.getStorageSync en injectant du code via evaluate().

Deux approches de Mock sont utilisées : le remplacement d'URL pour pointer vers des adresses de données simulées, et le remplacement direct des données de réponse. De plus, un mécanisme d'enregistrement de données permet de capturer les réponses des interfaces en temps réel pour les réutiliser dans des tests locaux, simplifiant la création de jeux de données.

# Injection de code pour intercepter les requêtes et simuler des réponses
def inject_mock_request(mini: minium.MiniTest, mock_data: dict):
    mini.app.evaluate(
        """function () {
            if (!wx.$$request_original) {
                wx.$$request_original = true
                const original_request = wx.request
                const simulated_data = %(mock_data)s
                
                wx.generate_mock_response = function(payload) {
                    return {
                        statusCode: 200,
                        data: {
                            code: 0,
                            data: payload,
                            timestamp: Date.now() - 2,
                        }
                    }
                }
                
                const proxy_config = %(proxy)s
                wx.request = function(options) {
                    let modified_options = {...options}
                    proxy_config(modified_options, new URL(modified_options.url))
                    const mock_entry = get_mock_entry(modified_options.url)
                    // Traitement des callbacks...
                }
            }
        }""" % {
            'mock_data': json_to_string(mock_data),
            'proxy': http_proxy_function
        },
        sync=True
    )

Cette solution, intégrée à des outils comme Jenkins, permet d'exécuter des tests de manière périodique, de générer des rapports et d'améliorer l'efficacité globale du processus de test.