DevOps / CI/CD

2026 : HarmonyOS NEXT, liste de contrôle de validation avant mise en production d’une migration React Native

La décision la plus sûre consiste à ne pas considérer la compilation ou l’ouverture d’un écran comme une migration validée : commencez par un parcours métier représentatif, puis exigez des preuves à chaque étape avant d’élargir le périmètre. Cette méthode convient aux équipes qui peuvent définir les appareils cibles, vérifier les dépendances et suspendre la publication lorsque le fonctionnement réel n’est pas démontré.

Pour les responsables techniques, l’enjeu est de fixer le périmètre du pilote et ses conditions d’arrêt.
Pour les ingénieurs qui relient React Native à ArkTS, il s’agit de distinguer les dépendances réellement adaptées de celles qui restent à vérifier.
Pour les responsables des tests, la priorité est de conserver des preuves issues des appareils cibles et des parcours métier.

Dernière mise à jour : 29 septembre 2026. Les points relatifs à ArkTS et aux tests d’interface ont été vérifiés à partir de la documentation officielle de développement ArkTS et du guide officiel du cadre de tests UI. Ces références décrivent des capacités de développement et de test ; elles ne constituent pas une confirmation du calendrier commercial de HarmonyOS NEXT ni une garantie de compatibilité d’une branche React Native.

Cadrer le pilote avant d’ouvrir le chantier de migration

Un pilote utile met à l’épreuve un flux réel, et non un écran isolé choisi parce qu’il est facile à convertir. Choisissez un parcours qui traverse les principaux risques du produit : ouverture de session, lecture et écriture de données, navigation, demande d’autorisation et traitement d’une erreur. Si le produit comporte une expérience audio, vidéo ou de création visuelle, incluez aussi un usage représentatif de cette activité lorsque ses interfaces ou son cycle de vie sont concernés.

Le périmètre doit nommer les appareils visés et la version du système utilisée pour chaque validation. Consignez ces informations dans le plan de test, avec la branche React Native, les versions des dépendances, les outils de construction et les paramètres d’exécution. Ne transformez pas une prévision de disponibilité commerciale en prérequis acquis : l’équipe doit s’appuyer sur les appareils auxquels elle a effectivement accès et sur les exigences vérifiées au moment du projet.

Que faut-il contrôler avant de lancer la migration d’un projet React Native vers HarmonyOS NEXT ? Commencez par relever les écrans du parcours pilote, les services utilisés, les modules natifs, les permissions et les cas d’échec. Pour chaque élément, indiquez son propriétaire, la manière de le tester et la preuve attendue. Une capture d’écran seule ne prouve pas qu’une opération d’écriture a abouti, qu’une session persiste après reprise ou qu’une permission est gérée correctement.

Définissez ensuite trois issues possibles, sans les confondre :

  • Poursuivre si le parcours sélectionné est reproductible et si ses dépendances disposent d’une adaptation vérifiable ou d’un remplacement accepté.
  • Suspendre si un module essentiel n’a pas de preuve d’adaptation, si une opération métier reste bloquée ou si l’équipe ne peut pas tester sur l’appareil cible.
  • Revenir à l’état précédent si le pilote révèle une régression qui ne peut pas être corrigée sans remettre en cause le calendrier, la sécurité ou l’intégrité des données.

Ces seuils sont des règles de gouvernance proposées au projet, et non des exigences imposées par la plateforme. La différence doit apparaître dans le document d’acceptation : une contrainte technique vérifiée ne se présente pas comme une obligation officielle si la documentation ne l’énonce pas.

Première étape : qualifier les dépendances et obtenir une construction reproductible

Un projet qui compile peut encore échouer à l’exécution. Une bibliothèque peut s’appuyer sur un module natif indisponible, appeler une interface dont le comportement diffère ou dépendre d’un script conçu pour un autre environnement. Le travail d’inventaire doit donc couvrir le code applicatif et les éléments qui l’entourent : modules natifs, bibliothèques tierces, scripts de construction, configuration de signature et dépendances nécessaires au démarrage.

Pour les équipes qui cherchent à vérifier la compatibilité de React Native avec OpenHarmony, la première preuve à exiger n’est pas une mention générale de compatibilité : c’est un résultat associé à la branche et aux versions réellement utilisées. La documentation de développement de la branche communautaire et ses notes de version permettent de repérer les instructions et limites propres à cette branche. Elles ne valident pas automatiquement toutes les dépendances d’un produit.

Pour chaque bibliothèque, inscrivez l’un des états suivants dans le registre :

  • Vérifiée : l’équipe a construit et exercé la fonction sur la branche et l’environnement consignés.
  • À vérifier : une documentation ou un exemple indique une piste, mais le comportement du projet n’a pas encore été reproduit.
  • À remplacer : aucune adaptation acceptable n’est démontrée, ou le résultat ne couvre pas les fonctions nécessaires au parcours.
  • Hors périmètre : la dépendance est présente, mais son usage n’est pas appelé dans le périmètre de validation ; cette exclusion doit être explicitement acceptée.

Pour les bibliothèques tierces, confrontez l’inventaire au répertoire communautaire consacré aux bibliothèques adaptées. Une entrée dans ce répertoire est une piste de vérification, pas un résultat de test pour la version intégrée au produit. Ajoutez au dossier la référence consultée, la version choisie, la commande exécutée, le résultat de compilation et les éventuelles modifications locales.

Comment traiter une dépendance après la conversion vers ArkTS ? Ne la marquez pas « compatible » au seul motif que le projet traduit ses fichiers ou démarre. Reproduisez l’usage réel, contrôlez les échanges avec le code natif et conservez les journaux qui permettent de relier un échec à une version précise. Si la dépendance est centrale et reste sans preuve, suspendez l’extension du pilote ; si elle peut être remplacée, documentez l’alternative et refaites les tests du parcours concerné.

Une adaptation décrite par une branche ou un exemple ne garantit ni la compatibilité de votre combinaison de versions, ni l’équivalence fonctionnelle avec l’application existante. L’acceptation doit porter sur la combinaison réellement construite.

La compilation doit elle-même pouvoir être reproduite par un autre membre de l’équipe à partir des consignes et fichiers consignés. Vérifiez aussi la signature et la génération du paquet : les instructions officielles sur l’outil de signature des paquets et les problèmes courants liés aux paquets applicatifs fournissent des références pour diagnostiquer ces étapes. Archivez les journaux, la configuration non secrète et l’identifiant de version de l’artefact ; protégez séparément les secrets de signature.

Valider le premier parcours métier, pas seulement ses écrans

L’essai fonctionnel doit comparer le comportement de référence avec celui de la version migrée. Faites avancer le test dans l’ordre réel de l’utilisateur : authentification, chargement des données, modification, confirmation, changement de page et sortie du parcours. Pour chaque action, consignez le résultat attendu, le résultat observé, l’appareil et le contexte réseau. Si une étape échoue, notez une procédure de reproduction qui ne dépende pas de l’interprétation d’une capture isolée.

Les fonctions qui semblent visuellement identiques peuvent différer dans leur comportement. Une demande de permission peut s’afficher sans que le refus soit correctement géré ; une page peut présenter une donnée sans confirmer que son écriture a abouti ; une navigation peut fonctionner dans le scénario nominal mais perdre son état après une erreur. Prévoyez donc des cas d’échec pertinents pour le service, notamment une session invalide, une réponse de service manquante et un accès refusé lorsque ces situations existent dans l’application.

Le passage de React Native à ArkTS implique également de vérifier les responsabilités entre le code JavaScript, les composants natifs et l’interface. Dans l’architecture React Native, le fil JavaScript et le fil d’interface ont des rôles distincts ; les échanges et le travail confié à chacun influencent la réactivité. Une implémentation côté ArkTS s’inscrit dans le modèle d’interface et les contraintes d’exécution documentés pour la plateforme, elle ne reproduit donc pas mécaniquement le comportement d’un ancien pont. L’équipe doit relever ce qui est repris, ce qui est réimplémenté côté ArkTS ou hôte, et ce qui demeure hors périmètre, en s’appuyant sur la présentation officielle du développement ArkTS.

Les résultats attendus doivent être observables : état de connexion, valeur persistée, écran obtenu, réponse à une permission ou journal d’erreur. Si la vérification exige une donnée interne, précisez qui peut y accéder et comment la preuve sera conservée sans exposer d’informations sensibles. Les défauts doivent être reliés à un parcours et à une condition d’apparition, et non simplement classés comme « problème d’interface ».

Deuxième étape : établir la couverture sur appareils réels

Une validation faite dans un environnement de développement peut aider à repérer des défauts, mais elle ne démontre pas à elle seule le comportement sur les appareils pris en charge par le projet. Reprenez le périmètre cible défini pendant le cadrage et associez à chaque appareil disponible les résultats obtenus, les versions système observées et les fonctionnalités exercées. Si une combinaison prévue n’est pas accessible, indiquez-la comme non vérifiée au lieu de généraliser un résultat observé ailleurs.

La validation d’une application ArkTS doit couvrir les transitions du cycle de vie pertinentes pour le produit. Vérifiez notamment le retour au premier plan après une interruption, la reprise d’un écran, la perte puis le rétablissement du réseau et une session prolongée correspondant à un usage plausible. Pour les applications audio ou vidéo, contrôlez les comportements de lecture et de reprise qui font partie du service ; pour les usages de création, vérifiez que les actions essentielles ne disparaissent pas après un changement de page ou une interruption.

La performance ne se valide pas à l’impression. Comparez les parcours dans des conditions d’essai consignées : même appareil, mêmes données, même séquence d’actions et état initial comparable. Conservez une trace exploitable, les étapes de reproduction et le contexte de mesure. Si l’équipe ne dispose pas encore de mesure, écrivez « mesure à réaliser » et décrivez le protocole prévu ; n’inventez ni fréquence d’images, ni seuil de fluidité, ni gain attendu. Le seuil d’acceptation doit être défini par le projet en fonction de son usage et de sa référence, et non présenté comme une exigence de plateforme sans source à l’appui.

Pour vérifier ce que peuvent apporter les tests automatisés, consultez le guide officiel du cadre de tests d’interface. Une automatisation peut répéter des interactions d’interface et apporter des preuves sur les actions qu’elle sait piloter ; elle ne remplace pas la validation du sens métier, des données persistées, des interruptions réelles ou des différences entre appareils. Le guide officiel de l’outil de test de stabilité peut compléter la démarche, sans faire office de recette métier.

Rassembler les preuves du candidat de publication

Avant de présenter une version à l’approbation, vérifiez que les résultats sont traçables et qu’un autre membre de l’équipe peut comprendre ce qui a été testé. Un dossier de validation exploitable contient le périmètre approuvé, les versions et dépendances, la configuration de construction, les résultats des tests automatisés et manuels, les défauts connus et l’artefact effectivement évalué.

La validation avant publication de HarmonyOS NEXT n’est pas complète si le rapport indique seulement « tests réussis ». Chaque réussite doit renvoyer à une procédure, à un résultat observable et au contexte dans lequel le test a été exécuté. Chaque échec accepté doit renvoyer à un responsable, à une justification, à un risque produit et à une décision explicite. Le statut « non testé » doit rester distinct de « réussi » et de « sans objet ».

Utilisez la liste suivante comme point de contrôle. Cochez un élément uniquement lorsque la preuve correspondante est archivée :

  • [ ] Le parcours pilote et ses exclusions sont approuvés par les responsables concernés.
  • [ ] Les appareils cibles et versions système testés figurent dans le dossier.
  • [ ] La branche React Native, les dépendances et les adaptations locales sont identifiées.
  • [ ] Chaque dépendance essentielle est vérifiée, remplacée ou déclarée bloquante.
  • [ ] Une construction reproductible et un paquet signé sont disponibles pour la recette.
  • [ ] Les scénarios de succès, de permission et d’échec ont des résultats comparables à la référence.
  • [ ] Les parcours ont été exercés sur les appareils réellement prévus, ou leur absence de validation est signalée.
  • [ ] Les constats de stabilité et de performance reposent sur des traces ou restent explicitement en attente.
  • [ ] Les défauts connus, les responsables et les décisions de traitement sont consignés.
  • [ ] Les consignes de retour arrière et les personnes autorisées à déclencher la suspension sont documentées.

Les tests d’interface automatisés et la recette manuelle doivent apparaître comme deux sources de preuve distinctes. Les premiers aident à répéter des actions définies ; la seconde vérifie que ces actions répondent aux objectifs du produit et restent acceptables sur les appareils concernés. Cette séparation évite de transformer la réussite d’un scénario automatisé en approbation globale.

Arrêter ou publier : fixer les conditions de décision

La publication doit être suspendue lorsqu’une dépendance indispensable n’a pas de solution validée, qu’un parcours central est bloqué ou que les appareils définis comme nécessaires n’ont pas pu être vérifiés. Il en va de même si l’artefact testé ne peut pas être relié à la configuration qui sera livrée, ou si un défaut connu peut compromettre les données, l’accès au service ou une fonction essentielle.

À l’inverse, une équipe peut accepter de poursuivre avec un défaut limité si son impact est compris, si un contournement réaliste existe et si une personne responsable a accepté le risque par écrit. Cette règle n’autorise pas à masquer les lacunes : elle rend visible la différence entre un risque accepté et une vérification non réalisée. Les seuils de performance, les niveaux d’acceptation et les catégories de gravité sont à définir par le projet ; ils ne doivent pas être présentés comme des seuils officiels sans source correspondante.

Le plan de retour arrière doit nommer le décideur, l’artefact de référence, la procédure de remise en service et les contrôles à effectuer après cette opération. Vérifiez également quelles données ont pu être créées ou transformées par la version migrée : revenir à un paquet antérieur sans examiner la compatibilité des données peut déplacer le risque plutôt que le résoudre. Consignez la décision de suspendre, de corriger ou de publier, avec les preuves consultées et les écarts acceptés.

Si le pilote ne passe pas, arrêtez l’extension aux autres parcours et évitez de lancer des travaux de conversion en série. Maintenez seulement les investigations nécessaires pour qualifier le défaut, tester un remplacement ou préparer le retour à l’état antérieur.

Le point essentiel est de distinguer le résultat d’un outil de conversion de l’acceptation du produit. Une conversion peut fournir une base de travail ; elle ne prouve ni que les dépendances sont adaptées, ni que les opérations métier sont équivalentes, ni que l’application se comporte correctement sur les appareils visés. Pour une décision fiable, chaque étape doit se conclure par une preuve consultable et une issue explicite : poursuivre, corriger ou suspendre.

Lorsque les appareils, les postes de construction ou les ressources de régression manquent, l’environnement actuel peut imposer des files d’attente, rendre les essais difficiles à reproduire et limiter les validations parallèles. Un Mac local reste pertinent si l’équipe doit disposer en permanence de ses propres outils ou de connexions matérielles ; il ne remplace cependant pas un appareil HarmonyOS NEXT réel pour confirmer la compatibilité de l’application. Si le besoin est temporaire et porte surtout sur la capacité de construction ou de collaboration, la location d’un Mac auprès de KuzCloud peut compléter le dispositif sans transformer l’achat d’une machine en condition préalable. L’équipe peut consulter la console KuzCloud pour évaluer si un environnement distant s’intègre à son plan, puis vérifier les modalités dans l’aide KuzCloud. Le choix doit rester conditionné par les outils effectivement requis, la politique d’accès au code et la disponibilité des appareils de test.

Préparez vos validations React Native avec un Mac dédié

Avec KuzCloud, prenez en main un Mac mini M4 physique pour exécuter vos builds et vos tests React Native dans un environnement macOS dédié.

Accédez à votre machine par SSH ou VNC et installez librement les outils nécessaires à vos workflows de développement et de CI/CD.