Construire des tests unitaires

La suite d'émulateurs locaux Firebase facilite la validation complète des fonctionnalités et du comportement de votre application. C'est également un excellent outil pour vérifier les configurations de vos règles de sécurité Firebase. Utilisez les émulateurs Firebase pour exécuter et automatiser des tests unitaires dans un environnement local. Les méthodes décrites dans ce document devraient vous aider lorsque vous créez et automatisez des tests unitaires pour votre application qui valident vos règles.

Si vous ne l'avez pas déjà fait, configurez les émulateurs Firebase .

Avant d'exécuter l'émulateur

Avant de commencer à utiliser l'émulateur, gardez à l'esprit les points suivants :

  • L'émulateur chargera initialement les règles spécifiées dans le champ firestore.rules ou 'storage.rules' de votre fichier firebase.json . Si le fichier n'existe pas et que vous n'utilisez pas la méthode loadFirestoreRules ou « loadStorageRules » comme décrit ci-dessous, l'émulateur traite tous les projets comme ayant des règles ouvertes.
  • Alors que la plupart des SDK Firebase fonctionnent directement avec les émulateurs, seule la bibliothèque @firebase/rules-unit-testing prend en charge auth simulée dans les règles de sécurité, ce qui rend les tests unitaires beaucoup plus faciles. De plus, la bibliothèque prend en charge quelques fonctionnalités spécifiques à l'émulateur, telles que la suppression de toutes les données, comme indiqué ci-dessous.
  • Les émulateurs accepteront également les jetons Firebase Auth de production fournis via les SDK clients et évalueront les règles en conséquence, ce qui permet de connecter votre application directement aux émulateurs lors des tests d'intégration et manuels.

Différences entre les émulateurs de base de données et la production

  • Vous n'êtes pas obligé de créer explicitement une instance de base de données. L'émulateur créera automatiquement toute instance de base de données accessible.
  • Chaque nouvelle base de données est démarrée avec des règles fermées, de sorte que les utilisateurs non administrateurs ne pourront ni lire ni écrire.
  • Chaque base de données émulée applique les limites et les quotas du plan Spark (cela limite notamment chaque instance à 100 connexions simultanées).
  • Toute base de données acceptera la chaîne "owner" comme jeton d'authentification d'administrateur.
  • Les émulateurs n'ont actuellement pas d'interactions fonctionnelles avec d'autres produits Firebase. Notamment, le flux d'authentification Firebase normal ne fonctionne pas. Au lieu de cela, vous pouvez utiliser la méthode initializeTestApp() dans la bibliothèque rules-unit-testing , qui prend un champ auth . L'objet Firebase créé à l'aide de cette méthode se comporte comme s'il s'était authentifié avec succès en tant qu'entité que vous fournissez. Si vous transmettez null , il se comportera comme un utilisateur non authentifié ( les règles auth != null échoueront, par exemple).

Interagir avec l'émulateur de base de données en temps réel

Une instance de production Firebase Realtime Database est accessible dans un sous-domaine de firebaseio.com et vous pouvez accéder à l'API REST comme ceci :

https://<database_name>.firebaseio.com/path/to/my/data.json

L'émulateur s'exécute localement et est disponible sur localhost:9000 . Pour interagir avec une instance de base de données spécifique, vous devrez utiliser le paramètre de requête ns pour spécifier le nom de la base de données.

http://localhost:9000/path/to/my/data.json?ns=<database_name>

Exécutez des tests unitaires locaux avec le SDK JavaScript version 9

Firebase distribue une bibliothèque de tests unitaires de règles de sécurité avec à la fois son SDK JavaScript version 9 et son SDK version 8. Les API de la bibliothèque sont très différentes. Nous recommandons la bibliothèque de tests v9, qui est plus rationalisée et nécessite moins de configuration pour se connecter aux émulateurs et ainsi éviter en toute sécurité une utilisation accidentelle des ressources de production. Pour des raisons de compatibilité ascendante, nous continuons à rendre disponible la bibliothèque de tests v8 .

Utilisez le module @firebase/rules-unit-testing pour interagir avec l'émulateur qui s'exécute localement. Si vous obtenez des délais d'attente ou des erreurs ECONNREFUSED , vérifiez que l'émulateur est réellement en cours d'exécution.

Nous vous recommandons fortement d'utiliser une version récente de Node.js afin de pouvoir utiliser la notation async/await . Presque tous les comportements que vous souhaiterez peut-être tester impliquent des fonctions asynchrones et le module de test est conçu pour fonctionner avec du code basé sur Promise.

La bibliothèque de tests unitaires de règles v9 est toujours au courant des émulateurs et ne touche jamais à vos ressources de production.

Vous importez la bibliothèque à l'aide des instructions d'importation modulaires v9. Par exemple:

import {
  assertFails,
  assertSucceeds,
  initializeTestEnvironment,
  RulesTestEnvironment,
} from "@firebase/rules-unit-testing"

// Use `const { … } = require("@firebase/rules-unit-testing")` if imports are not supported
// Or we suggest `const testing = require("@firebase/rules-unit-testing")` if necessary.

Une fois importés, la mise en œuvre des tests unitaires implique :

  • Création et configuration d'un RulesTestEnvironment avec un appel à initializeTestEnvironment .
  • Configuration des données de test sans déclencher de règles, à l'aide d'une méthode pratique qui vous permet de les contourner temporairement, RulesTestEnvironment.withSecurityRulesDisabled .
  • Configuration d'une suite de tests et de hooks avant/après par test avec des appels pour nettoyer les données de test et l'environnement, comme RulesTestEnvironment.cleanup() ou RulesTestEnvironment.clearFirestore() .
  • Implémentation de cas de test qui imitent les états d'authentification à l'aide de RulesTestEnvironment.authenticatedContext et RulesTestEnvironment.unauthenticatedContext .

Méthodes courantes et fonctions utilitaires

Consultez également les méthodes de test spécifiques à l'émulateur utilisant l'API modulaire .

initializeTestEnvironment() => RulesTestEnvironment

Cette fonction initialise un environnement de test pour les tests unitaires de règles. Appelez d’abord cette fonction pour la configuration du test. Une exécution réussie nécessite que les émulateurs soient en cours d'exécution.

La fonction accepte un objet facultatif définissant un TestEnvironmentConfig , qui peut consister en un ID de projet et des paramètres de configuration de l'émulateur.

let testEnv = await initializeTestEnvironment({
  projectId: "demo-project-1234",
  firestore: {
    rules: fs.readFileSync("firestore.rules", "utf8"),
  },
});

RulesTestEnvironment.authenticatedContext({ user_id: string, tokenOptions?: TokenOptions }) => RulesTestContext

Cette méthode crée un RulesTestContext , qui se comporte comme un utilisateur d'authentification authentifié. Les requêtes créées via le contexte renvoyé seront accompagnées d'un jeton d'authentification fictif. Vous pouvez éventuellement transmettre un objet définissant des revendications personnalisées ou des remplacements pour les charges utiles du jeton d'authentification.

Utilisez l'objet de contexte de test renvoyé dans vos tests pour accéder à toutes les instances d'émulateur configurées, y compris celles configurées avec initializeTestEnvironment .

// Assuming a Firestore app and the Firestore emulator for this example
import { setDoc } from "firebase/firestore";

const alice = testEnv.authenticatedContext("alice", { … });
// Use the Firestore instance associated with this context
await assertSucceeds(setDoc(alice.firestore(), '/users/alice'), { ... });

RulesTestEnvironment.unauthenticatedContext() => RulesTestContext

Cette méthode crée un RulesTestContext , qui se comporte comme un client non connecté via l'authentification. Les requêtes créées via le contexte renvoyé ne seront pas associées à des jetons d'authentification Firebase.

Utilisez l'objet de contexte de test renvoyé dans vos tests pour accéder à toutes les instances d'émulateur configurées, y compris celles configurées avec initializeTestEnvironment .

// Assuming a Cloud Storage app and the Storage emulator for this example
import { getStorage, ref, deleteObject } from "firebase/storage";

const alice = testEnv.unauthenticatedContext();

// Use the Cloud Storage instance associated with this context
const desertRef = ref(alice.storage(), 'images/desert.jpg');
await assertSucceeds(deleteObject(desertRef));

RulesTestEnvironment.withSecurityRulesDisabled()

Exécutez une fonction de configuration de test avec un contexte qui se comporte comme si les règles de sécurité étaient désactivées.

Cette méthode prend une fonction de rappel, qui prend le contexte de contournement des règles de sécurité et renvoie une promesse. Le contexte sera détruit une fois la promesse résolue/rejetée.

RulesTestEnvironment.cleanup()

Cette méthode détruit tous RulesTestContexts créés dans l'environnement de test et nettoie les ressources sous-jacentes, permettant une sortie propre.

Cette méthode ne change en rien l’état des émulateurs. Pour réinitialiser les données entre les tests, utilisez la méthode d'effacement des données spécifique à l'émulateur d'application.

assertSucceeds(pr: Promise<any>)) => Promise<any>

Il s'agit d'une fonction utilitaire de scénario de test.

La fonction affirme que la promesse fournie encapsulant une opération d'émulateur sera résolue sans violation des règles de sécurité.

await assertSucceeds(setDoc(alice.firestore(), '/users/alice'), { ... });

assertFails(pr: Promise<any>)) => Promise<any>

Il s'agit d'une fonction utilitaire de scénario de test.

La fonction affirme que la promesse fournie encapsulant une opération d'émulateur sera rejetée en cas de violation des règles de sécurité.

await assertFails(setDoc(alice.firestore(), '/users/bob'), { ... });

Méthodes spécifiques à l'émulateur

Consultez également les méthodes de test courantes et les fonctions utilitaires utilisant l'API modulaire .

Cloud Firestore

Cloud Firestore

RulesTestEnvironment.clearFirestore() => Promise<void>

Cette méthode efface les données de la base de données Firestore qui appartiennent au projectId configuré pour l'émulateur Firestore.

RulesTestContext.firestore(settings?: Firestore.FirestoreSettings) => Firestore;

Cette méthode obtient une instance Firestore pour ce contexte de test. L'instance du SDK client Firebase JS renvoyée peut être utilisée avec les API du SDK client (v9 modulaire ou compatible v9).

Base de données en temps réel

Base de données en temps réel

RulesTestEnvironment.clearDatabase() => Promise<void>

Cette méthode efface les données de la base de données en temps réel qui appartiennent au projectId configuré pour l'émulateur de base de données en temps réel.

RulesTestContext.database(databaseURL?: Firestore.FirestoreSettings) => Firestore;

Obtenez une instance de base de données en temps réel pour ce contexte de test. L'instance du SDK client Firebase JS renvoyée peut être utilisée avec les API du SDK client (modulaires ou avec espace de noms, version 9 ou ultérieure). La méthode accepte une URL de l'instance de base de données en temps réel. Si spécifié, renvoie une instance pour une version émulée de l'espace de noms avec des paramètres extraits de l'URL.

Stockage en ligne

Stockage en ligne

RulesTestEnvironment.clearStorage() => Promise<void>

Cette méthode efface les objets et les métadonnées dans les buckets de stockage appartenant au projectId configuré pour l'émulateur Cloud Storage.

RulesTestContext.storage(bucketUrl?: string) => Firebase Storage;

Cette méthode renvoie une instance de stockage configurée pour se connecter à l'émulateur. La méthode accepte une URL gs:// vers le compartiment de stockage Firebase à des fins de test. Si spécifié, renvoie une instance de stockage pour une version émulée du nom du compartiment.

Exécutez des tests unitaires locaux avec le SDK JavaScript v8

Sélectionnez un produit pour voir les méthodes utilisées par le SDK de test Firebase pour s'interfacer avec l'émulateur.

Cloud Firestore

initializeTestApp({ projectId: string, auth: Object }) => FirebaseApp

Cette méthode renvoie une application Firebase initialisée correspondant à l'ID du projet et à la variable d'authentification spécifiées dans les options. Utilisez-le pour créer une application authentifiée en tant qu'utilisateur spécifique à utiliser dans les tests.

firebase.initializeTestApp({
  projectId: "my-test-project",
  auth: { uid: "alice", email: "alice@example.com" }
});

initializeAdminApp({ projectId: string }) => FirebaseApp

Cette méthode renvoie une application Firebase d'administration initialisée. Cette application contourne les règles de sécurité lors des lectures et des écritures. Utilisez-le pour créer une application authentifiée en tant qu'administrateur afin de définir l'état des tests.

firebase.initializeAdminApp({ projectId: "my-test-project" });
    

apps() => [FirebaseApp] Cette méthode renvoie toutes les applications de test et d'administration actuellement initialisées. Utilisez-le pour nettoyer les applications entre ou après les tests.

Promise.all(firebase.apps().map(app => app.delete()))

loadFirestoreRules({ projectId: string, rules: Object }) => Promise

Cette méthode envoie des règles à une base de données exécutée localement. Il prend un objet qui spécifie les règles sous forme de chaîne. Utilisez cette méthode pour définir les règles de votre base de données.

firebase.loadFirestoreRules({
  projectId: "my-test-project",
  rules: fs.readFileSync("/path/to/firestore.rules", "utf8")
});
    

assertFails(pr: Promise) => Promise

Cette méthode renvoie une promesse qui est rejetée si l'entrée réussit ou qui réussit si l'entrée est rejetée. Utilisez-le pour affirmer si la lecture ou l'écriture d'une base de données échoue.

firebase.assertFails(app.firestore().collection("private").doc("super-secret-document").get());
    

assertSucceeds(pr: Promise) => Promise

Cette méthode renvoie une promesse qui réussit si l'entrée réussit et est rejetée si l'entrée est rejetée. Utilisez ceci pour affirmer si une lecture ou une écriture de base de données réussit.

firebase.assertSucceeds(app.firestore().collection("public").doc("test-document").get());
    

clearFirestoreData({ projectId: string }) => Promise

Cette méthode efface toutes les données associées à un projet particulier dans l'instance Firestore exécutée localement. Utilisez cette méthode pour nettoyer après les tests.

firebase.clearFirestoreData({
  projectId: "my-test-project"
});
   

Base de données en temps réel

Base de données en temps réel

initializeTestApp({ databaseName: string, auth: Object }) => FirebaseApp

Utilisez-le pour créer une application authentifiée en tant qu'utilisateur spécifique à utiliser dans les tests.

Renvoie une application Firebase initialisée correspondant au nom de la base de données et au remplacement de la variable d'authentification spécifiés dans les options.

firebase.initializeTestApp({
  databaseName: "my-database",
  auth: { uid: "alice" }
});

initializeAdminApp({ databaseName: string }) => FirebaseApp

Utilisez-le pour créer une application authentifiée en tant qu'administrateur afin de configurer l'état des tests.

Renvoie une application Firebase d'administration initialisée correspondant au nom de la base de données spécifié dans les options. Cette application contourne les règles de sécurité lors de la lecture et de l'écriture dans la base de données.

firebase.initializeAdminApp({ databaseName: "my-database" });

loadDatabaseRules({ databaseName: string, rules: Object }) => Promise

Utilisez-le pour définir les règles de votre base de données.

Envoie des règles à une base de données exécutée localement. Prend un objet d'options qui spécifie votre "databaseName" et vos "règles" sous forme de chaînes.

firebase
      .loadDatabaseRules({
        databaseName: "my-database",
        rules: "{'rules': {'.read': false, '.write': false}}"
      });

apps() => [FirebaseApp]

Renvoie toutes les applications de test et d'administration actuellement initialisées.

Utilisez-le pour nettoyer les applications entre ou après les tests (notez que les applications initialisées avec des écouteurs actifs empêchent JavaScript de se fermer) :

 Promise.all(firebase.apps().map(app => app.delete()))

assertFails(pr: Promise) => Promise

Renvoie une promesse qui est rejetée si l'entrée réussit et réussit si l'entrée est rejetée.

Utilisez ceci pour affirmer qu'une lecture ou une écriture de base de données échoue :

firebase.assertFails(app.database().ref("secret").once("value"));

assertSucceeds(pr: Promise) => Promise

Renvoie une promesse qui réussit si l'entrée réussit et est rejetée si l'entrée est rejetée.

Utilisez ceci pour affirmer qu'une lecture ou une écriture de base de données réussit :

firebase.assertSucceeds(app.database().ref("public").once("value"));

Stockage en ligne

Stockage en ligne

initializeTestApp({ storageBucket: string, auth: Object }) => FirebaseApp

Utilisez-le pour créer une application authentifiée en tant qu'utilisateur spécifique à utiliser dans les tests.

Renvoie une application Firebase initialisée correspondant au nom du compartiment de stockage et au remplacement de la variable d'authentification spécifiés dans les options.

firebase.initializeTestApp({
  storageBucket: "my-bucket",
  auth: { uid: "alice" }
});

initializeAdminApp({ storageBucket: string }) => FirebaseApp

Utilisez-le pour créer une application authentifiée en tant qu'administrateur afin de configurer l'état des tests.

Renvoie une application Firebase d'administration initialisée correspondant au nom du bucket de stockage spécifié dans les options. Cette application contourne les règles de sécurité lors de la lecture et de l'écriture dans le compartiment.

firebase.initializeAdminApp({ storageBucket: "my-bucket" });

loadStorageRules({ storageBucket: string, rules: Object }) => Promise

Utilisez-le pour définir les règles de votre compartiment de stockage.

Envoie des règles à des compartiments de stockage gérés localement. Prend un objet d'options qui spécifie votre "storageBucket" et vos "règles" sous forme de chaînes.

firebase
      .loadStorageRules({
        storageBucket: "my-bucket",
        rules: fs.readFileSync("/path/to/storage.rules", "utf8")
      });

apps() => [FirebaseApp]

Renvoie toutes les applications de test et d'administration actuellement initialisées.

Utilisez-le pour nettoyer les applications entre ou après les tests (notez que les applications initialisées avec des écouteurs actifs empêchent JavaScript de se fermer) :

 Promise.all(firebase.apps().map(app => app.delete()))

assertFails(pr: Promise) => Promise

Renvoie une promesse qui est rejetée si l'entrée réussit et réussit si l'entrée est rejetée.

Utilisez ceci pour affirmer qu'une lecture ou une écriture d'un bucket de stockage échoue :

firebase.assertFails(app.storage().ref("letters/private.doc").getMetadata());

assertSucceeds(pr: Promise) => Promise

Renvoie une promesse qui réussit si l'entrée réussit et est rejetée si l'entrée est rejetée.

Utilisez ceci pour affirmer qu'une lecture ou une écriture d'un bucket de stockage réussit :

firebase.assertFails(app.storage().ref("images/cat.png").getMetadata());

API de la bibliothèque RUT pour JS SDK v8

Sélectionnez un produit pour voir les méthodes utilisées par le SDK de test Firebase pour s'interfacer avec l'émulateur.

Cloud Firestore

Cloud Firestore

initializeTestApp({ projectId: string, auth: Object }) => FirebaseApp

Cette méthode renvoie une application Firebase initialisée correspondant à l'ID du projet et à la variable d'authentification spécifiées dans les options. Utilisez-le pour créer une application authentifiée en tant qu'utilisateur spécifique à utiliser dans les tests.

firebase.initializeTestApp({
  projectId: "my-test-project",
  auth: { uid: "alice", email: "alice@example.com" }
});

initializeAdminApp({ projectId: string }) => FirebaseApp

Cette méthode renvoie une application Firebase d'administration initialisée. Cette application contourne les règles de sécurité lors des lectures et des écritures. Utilisez-le pour créer une application authentifiée en tant qu'administrateur afin de définir l'état des tests.

firebase.initializeAdminApp({ projectId: "my-test-project" });
    

apps() => [FirebaseApp] Cette méthode renvoie toutes les applications de test et d'administration actuellement initialisées. Utilisez-le pour nettoyer les applications entre ou après les tests.

Promise.all(firebase.apps().map(app => app.delete()))

loadFirestoreRules({ projectId: string, rules: Object }) => Promise

Cette méthode envoie des règles à une base de données exécutée localement. Il prend un objet qui spécifie les règles sous forme de chaîne. Utilisez cette méthode pour définir les règles de votre base de données.

firebase.loadFirestoreRules({
  projectId: "my-test-project",
  rules: fs.readFileSync("/path/to/firestore.rules", "utf8")
});
    

assertFails(pr: Promise) => Promise

Cette méthode renvoie une promesse qui est rejetée si l'entrée réussit ou qui réussit si l'entrée est rejetée. Utilisez-le pour affirmer si la lecture ou l'écriture d'une base de données échoue.

firebase.assertFails(app.firestore().collection("private").doc("super-secret-document").get());
    

assertSucceeds(pr: Promise) => Promise

Cette méthode renvoie une promesse qui réussit si l'entrée réussit et est rejetée si l'entrée est rejetée. Utilisez-le pour affirmer si la lecture ou l'écriture d'une base de données réussit.

firebase.assertSucceeds(app.firestore().collection("public").doc("test-document").get());
    

clearFirestoreData({ projectId: string }) => Promise

Cette méthode efface toutes les données associées à un projet particulier dans l'instance Firestore exécutée localement. Utilisez cette méthode pour nettoyer après les tests.

firebase.clearFirestoreData({
  projectId: "my-test-project"
});
   

Base de données en temps réel

Base de données en temps réel

initializeTestApp({ databaseName: string, auth: Object }) => FirebaseApp

Utilisez-le pour créer une application authentifiée en tant qu'utilisateur spécifique à utiliser dans les tests.

Renvoie une application Firebase initialisée correspondant au nom de la base de données et au remplacement de la variable d'authentification spécifiés dans les options.

firebase.initializeTestApp({
  databaseName: "my-database",
  auth: { uid: "alice" }
});

initializeAdminApp({ databaseName: string }) => FirebaseApp

Utilisez-le pour créer une application authentifiée en tant qu'administrateur afin de configurer l'état des tests.

Renvoie une application Firebase d'administration initialisée correspondant au nom de la base de données spécifié dans les options. Cette application contourne les règles de sécurité lors de la lecture et de l'écriture dans la base de données.

firebase.initializeAdminApp({ databaseName: "my-database" });

loadDatabaseRules({ databaseName: string, rules: Object }) => Promise

Utilisez-le pour définir les règles de votre base de données.

Envoie des règles à une base de données exécutée localement. Prend un objet d'options qui spécifie votre "databaseName" et vos "règles" sous forme de chaînes.

firebase
      .loadDatabaseRules({
        databaseName: "my-database",
        rules: "{'rules': {'.read': false, '.write': false}}"
      });

apps() => [FirebaseApp]

Renvoie toutes les applications de test et d'administration actuellement initialisées.

Utilisez-le pour nettoyer les applications entre ou après les tests (notez que les applications initialisées avec des écouteurs actifs empêchent JavaScript de se fermer) :

 Promise.all(firebase.apps().map(app => app.delete()))

assertFails(pr: Promise) => Promise

Renvoie une promesse qui est rejetée si l'entrée réussit et réussit si l'entrée est rejetée.

Utilisez ceci pour affirmer qu'une lecture ou une écriture de base de données échoue :

firebase.assertFails(app.database().ref("secret").once("value"));

assertSucceeds(pr: Promise) => Promise

Renvoie une promesse qui réussit si l'entrée réussit et est rejetée si l'entrée est rejetée.

Utilisez ceci pour affirmer qu'une lecture ou une écriture de base de données réussit :

firebase.assertSucceeds(app.database().ref("public").once("value"));

Stockage en ligne

Stockage en ligne

initializeTestApp({ storageBucket: string, auth: Object }) => FirebaseApp

Utilisez-le pour créer une application authentifiée en tant qu'utilisateur spécifique à utiliser dans les tests.

Renvoie une application Firebase initialisée correspondant au nom du compartiment de stockage et au remplacement de la variable d'authentification spécifiés dans les options.

firebase.initializeTestApp({
  storageBucket: "my-bucket",
  auth: { uid: "alice" }
});

initializeAdminApp({ storageBucket: string }) => FirebaseApp

Utilisez-le pour créer une application authentifiée en tant qu'administrateur afin de configurer l'état des tests.

Renvoie une application Firebase d'administration initialisée correspondant au nom du bucket de stockage spécifié dans les options. Cette application contourne les règles de sécurité lors de la lecture et de l'écriture dans le compartiment.

firebase.initializeAdminApp({ storageBucket: "my-bucket" });

loadStorageRules({ storageBucket: string, rules: Object }) => Promise

Utilisez-le pour définir les règles de votre compartiment de stockage.

Envoie des règles à des compartiments de stockage gérés localement. Prend un objet d'options qui spécifie votre "storageBucket" et vos "règles" sous forme de chaînes.

firebase
      .loadStorageRules({
        storageBucket: "my-bucket",
        rules: fs.readFileSync("/path/to/storage.rules", "utf8")
      });

apps() => [FirebaseApp]

Renvoie toutes les applications de test et d'administration actuellement initialisées.

Utilisez-le pour nettoyer les applications entre ou après les tests (notez que les applications initialisées avec des écouteurs actifs empêchent JavaScript de se fermer) :

 Promise.all(firebase.apps().map(app => app.delete()))

assertFails(pr: Promise) => Promise

Renvoie une promesse qui est rejetée si l'entrée réussit et réussit si l'entrée est rejetée.

Utilisez ceci pour affirmer qu'une lecture ou une écriture d'un bucket de stockage échoue :

firebase.assertFails(app.storage().ref("letters/private.doc").getMetadata());

assertSucceeds(pr: Promise) => Promise

Renvoie une promesse qui réussit si l'entrée réussit et est rejetée si l'entrée est rejetée.

Utilisez ceci pour affirmer qu'une lecture ou une écriture d'un bucket de stockage réussit :

firebase.assertFails(app.storage().ref("images/cat.png").getMetadata());