Crea unit test

Firebase Local Emulator Suite semplifica la convalida completa delle funzionalità e del comportamento della tua app. È anche un ottimo strumento per verificare le configurazioni delle regole di sicurezza Firebase. Utilizza gli emulatori Firebase per eseguire e automatizzare gli unit test in un ambiente locale. I metodi descritti in questo documento dovrebbero aiutarti mentre crei e automatizzi gli unit test per la tua app che convalidano le tue regole.

Se non lo hai già fatto, configura gli emulatori Firebase .

Prima di eseguire l'emulatore

Prima di iniziare a utilizzare l'emulatore, tenere presente quanto segue:

  • L'emulatore caricherà inizialmente le regole specificate nel campo firestore.rules o "storage.rules" del file firebase.json . Se il file non esiste e non utilizzi il metodo loadFirestoreRules o 'loadStorageRules' come descritto di seguito, l'emulatore considera tutti i progetti come aventi regole aperte.
  • Sebbene la maggior parte degli SDK Firebase funzionino direttamente con gli emulatori, solo la libreria @firebase/rules-unit-testing supporta auth simulata nelle regole di sicurezza, rendendo i test unitari molto più semplici. Inoltre, la libreria supporta alcune funzionalità specifiche dell'emulatore come la cancellazione di tutti i dati, come elencato di seguito.
  • Gli emulatori accetteranno anche i token di autenticazione Firebase di produzione forniti tramite gli SDK client e valuteranno le regole di conseguenza, il che consente di connettere l'applicazione direttamente agli emulatori nell'integrazione e nei test manuali.

Differenze tra gli emulatori di database e quelli di produzione

  • Non è necessario creare esplicitamente un'istanza del database. L'emulatore creerà automaticamente qualsiasi istanza del database a cui si accede.
  • Ogni nuovo database viene avviato con regole chiuse, quindi gli utenti non amministratori non saranno in grado di leggere o scrivere.
  • Ogni database emulato applica i limiti e le quote del piano Spark (in particolare, ciò limita ogni istanza a 100 connessioni simultanee).
  • Qualsiasi database accetterà la stringa "owner" come token di autenticazione dell'amministratore.
  • Gli emulatori attualmente non hanno interazioni funzionanti con altri prodotti Firebase. In particolare, il normale flusso di autenticazione Firebase non funziona. Invece, puoi utilizzare il metodo initializeTestApp() nella libreria rules-unit-testing , che accetta un campo auth . L'oggetto Firebase creato utilizzando questo metodo si comporta come se fosse stato autenticato con successo come qualsiasi entità fornita. Se passi null , si comporterà come un utente non autenticato ( le regole auth != null falliranno, ad esempio).

Interazione con l'emulatore Realtime Database

Un'istanza di produzione Firebase Realtime Database è accessibile in un sottodominio di firebaseio.com e puoi accedere all'API REST in questo modo:

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

L'emulatore viene eseguito localmente ed è disponibile su localhost:9000 . Per interagire con un'istanza di database specifica, dovrai utilizzare il parametro di query ns per specificare il nome del database.

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

Esegui unit test locali con l'SDK JavaScript versione 9

Firebase distribuisce una libreria di unit test delle regole di sicurezza sia con l'SDK JavaScript della versione 9 che con l'SDK della versione 8. Le API della libreria sono significativamente diverse. Consigliamo la libreria di test v9, che è più snella e richiede meno configurazioni per connettersi agli emulatori e quindi evitare in modo sicuro l'uso accidentale delle risorse di produzione. Per compatibilità con le versioni precedenti, continuiamo a rendere disponibile la libreria di test v8 .

Utilizza il modulo @firebase/rules-unit-testing per interagire con l'emulatore eseguito localmente. Se ricevi timeout o errori ECONNREFUSED , ricontrolla che l'emulatore sia effettivamente in esecuzione.

Ti consigliamo vivamente di utilizzare una versione recente di Node.js in modo da poter utilizzare la notazione async/await . Quasi tutto il comportamento che potresti voler testare coinvolge funzioni asincrone e il modulo di test è progettato per funzionare con codice basato su Promise.

La libreria v9 Rules Unit Testing è sempre a conoscenza degli emulatori e non tocca mai le tue risorse di produzione.

Importi la libreria utilizzando le istruzioni di importazione modulare v9. Per esempio:

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.

Una volta importati, l'implementazione dei test unitari comporta:

  • Creazione e configurazione di RulesTestEnvironment con una chiamata a initializeTestEnvironment .
  • Impostazione dei dati di test senza attivare le regole, utilizzando un metodo pratico che consente di ignorarli temporaneamente, RulesTestEnvironment.withSecurityRulesDisabled .
  • Impostazione della suite di test e hook prima/dopo per-test con chiamate per pulire i dati e l'ambiente di test, come RulesTestEnvironment.cleanup() o RulesTestEnvironment.clearFirestore() .
  • Implementazione di casi di test che imitano gli stati di autenticazione utilizzando RulesTestEnvironment.authenticatedContext e RulesTestEnvironment.unauthenticatedContext .

Metodi comuni e funzioni di utilità

Consulta anche i metodi di test specifici dell'emulatore utilizzando l'API modulare .

initializeTestEnvironment() => RulesTestEnvironment

Questa funzione inizializza un ambiente di test per lo unit test delle regole. Chiamare prima questa funzione per l'impostazione del test. Per un'esecuzione corretta è necessario che gli emulatori siano in esecuzione.

La funzione accetta un oggetto facoltativo che definisce un TestEnvironmentConfig , che può essere costituito da un ID progetto e dalle impostazioni di configurazione dell'emulatore.

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

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

Questo metodo crea un RulesTestContext , che si comporta come un utente di autenticazione autenticato. Le richieste create tramite il contesto restituito avranno un token di autenticazione fittizio allegato. Facoltativamente, passare un oggetto che definisce attestazioni personalizzate o sostituzioni per i payload del token di autenticazione.

Utilizza l'oggetto del contesto di test restituito nei test per accedere a qualsiasi istanza dell'emulatore configurata, incluse quelle configurate con 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

Questo metodo crea un RulesTestContext , che si comporta come un client che non ha effettuato l'accesso tramite l'autenticazione. Le richieste create tramite il contesto restituito non avranno token di autenticazione Firebase allegati.

Utilizza l'oggetto del contesto di test restituito nei test per accedere a qualsiasi istanza dell'emulatore configurata, incluse quelle configurate con 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()

Esegui una funzione di configurazione di prova con un contesto che si comporta come se le regole di sicurezza fossero disabilitate.

Questo metodo accetta una funzione di callback, che accetta il contesto di bypass delle regole di sicurezza e restituisce una promessa. Il contesto verrà distrutto una volta che la promessa si risolve/rifiuta.

RulesTestEnvironment.cleanup()

Questo metodo distrugge tutti RulesTestContexts creati nell'ambiente di test e ripulisce le risorse sottostanti, consentendo un'uscita pulita.

Questo metodo non modifica in alcun modo lo stato degli emulatori. Per reimpostare i dati tra un test e l'altro, utilizzare il metodo di cancellazione dei dati specifico dell'emulatore dell'applicazione.

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

Questa è una funzione di utilità del caso di test.

La funzione asserisce che la Promise fornita che racchiude un'operazione dell'emulatore verrà risolta senza violazioni delle regole di sicurezza.

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

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

Questa è una funzione di utilità del caso di test.

La funzione asserisce che la Promise fornita che racchiude un'operazione dell'emulatore verrà rifiutata con una violazione delle regole di sicurezza.

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

Metodi specifici dell'emulatore

Consulta anche i metodi di test comuni e le funzioni di utilità utilizzando l'API modulare .

Cloud Fire Store

Cloud Fire Store

RulesTestEnvironment.clearFirestore() => Promise<void>

Questo metodo cancella i dati nel database Firestore che appartengono al projectId configurato per l'emulatore Firestore.

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

Questo metodo ottiene un'istanza Firestore per questo contesto di test. L'istanza Firebase JS Client SDK restituita può essere utilizzata con le API SDK client (modulare v9 o compatibile v9).

Banca dati in tempo reale

Banca dati in tempo reale

RulesTestEnvironment.clearDatabase() => Promise<void>

Questo metodo cancella i dati nel Realtime Database che appartengono al projectId configurato per l'emulatore Realtime Database.

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

Ottieni un'istanza di Realtime Database per questo contesto di test. L'istanza Firebase JS Client SDK restituita può essere utilizzata con le API SDK client (modulari o con spazio dei nomi, versione 9 o successiva). Il metodo accetta un URL dell'istanza di Realtime Database. Se specificato, restituisce un'istanza per una versione emulata dello spazio dei nomi con parametri estratti dall'URL.

Archiviazione nel cloud

Archiviazione nel cloud

RulesTestEnvironment.clearStorage() => Promise<void>

Questo metodo cancella oggetti e metadati nei bucket di archiviazione appartenenti al projectId configurato per l'emulatore Cloud Storage.

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

Questo metodo restituisce un'istanza di archiviazione configurata per connettersi all'emulatore. Il metodo accetta un URL gs:// per il bucket di archiviazione Firebase per il test. Se specificato, restituisce un'istanza di archiviazione per una versione emulata del nome del bucket.

Esegui unit test locali con l'SDK JavaScript v8

Seleziona un prodotto per visualizzare i metodi utilizzati da Firebase Test SDK per interfacciarsi con l'emulatore.

Cloud Fire Store

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

Questo metodo restituisce un'app Firebase inizializzata corrispondente all'ID progetto e alla variabile di autenticazione specificati nelle opzioni. Utilizzalo per creare un'app autenticata come utente specifico da utilizzare nei test.

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

initializeAdminApp({ projectId: string }) => FirebaseApp

Questo metodo restituisce un'app Firebase di amministrazione inizializzata. Questa app ignora le regole di sicurezza durante l'esecuzione di letture e scritture. Utilizzalo per creare un'app autenticata come amministratore per impostare lo stato per i test.

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

apps() => [FirebaseApp] Questo metodo restituisce tutte le app di test e di amministrazione attualmente inizializzate. Usalo per pulire le app tra o dopo i test.

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

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

Questo metodo invia regole a un database in esecuzione localmente. Richiede un oggetto che specifica le regole come una stringa. Utilizza questo metodo per impostare le regole del tuo database.

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

assertFails(pr: Promise) => Promise

Questo metodo restituisce una promessa che viene rifiutata se l'input ha esito positivo o che ha esito positivo se l'input viene rifiutato. Utilizzare questo per affermare se la lettura o la scrittura di un database fallisce.

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

assertSucceeds(pr: Promise) => Promise

Questo metodo restituisce una promessa che ha esito positivo se l'input ha esito positivo e viene rifiutata se l'input viene rifiutato. Utilizzarlo per verificare se la lettura o la scrittura del database ha esito positivo.

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

clearFirestoreData({ projectId: string }) => Promise

Questo metodo cancella tutti i dati associati a un particolare progetto nell'istanza Firestore in esecuzione localmente. Utilizzare questo metodo per pulire dopo i test.

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

Banca dati in tempo reale

Banca dati in tempo reale

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

Utilizzalo per creare un'app autenticata come utente specifico da utilizzare nei test.

Restituisce un'app Firebase inizializzata corrispondente al nome del database e alla sostituzione della variabile di autenticazione specificata nelle opzioni.

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

initializeAdminApp({ databaseName: string }) => FirebaseApp

Utilizzalo per creare un'app autenticata come amministratore per impostare lo stato per i test.

Restituisce un'app Firebase di amministrazione inizializzata corrispondente al nome del database specificato nelle opzioni. Questa app ignora le regole di sicurezza durante la lettura e la scrittura nel database.

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

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

Usalo per impostare le regole del tuo database.

Invia regole a un database in esecuzione localmente. Accetta un oggetto opzioni che specifica il tuo "databaseName" e le tue "regole" come stringhe.

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

apps() => [FirebaseApp]

Restituisce tutte le app di test e di amministrazione attualmente inizializzate.

Usalo per pulire le app tra o dopo i test (nota che le app inizializzate con ascoltatori attivi impediscono l'uscita di JavaScript):

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

assertFails(pr: Promise) => Promise

Restituisce una promessa che viene rifiutata se l'input ha esito positivo e ha esito positivo se l'input viene rifiutato.

Utilizzare questo per affermare che la lettura o la scrittura di un database non riesce:

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

assertSucceeds(pr: Promise) => Promise

Restituisce una promessa che ha esito positivo se l'input ha esito positivo e viene rifiutata se l'input viene rifiutato.

Utilizzalo per affermare che la lettura o la scrittura del database ha esito positivo:

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

Archiviazione nel cloud

Archiviazione nel cloud

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

Utilizzalo per creare un'app autenticata come utente specifico da utilizzare nei test.

Restituisce un'app Firebase inizializzata corrispondente al nome del bucket di archiviazione e all'override della variabile di autenticazione specificati nelle opzioni.

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

initializeAdminApp({ storageBucket: string }) => FirebaseApp

Utilizzalo per creare un'app autenticata come amministratore per impostare lo stato per i test.

Restituisce un'app Firebase di amministrazione inizializzata corrispondente al nome del bucket di archiviazione specificato nelle opzioni. Questa app ignora le regole di sicurezza durante la lettura e la scrittura nel bucket.

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

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

Utilizzalo per impostare le regole del bucket di archiviazione.

Invia regole a bucket di archiviazione gestiti localmente. Accetta un oggetto opzioni che specifica il tuo "storageBucket" e le tue "regole" come stringhe.

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

apps() => [FirebaseApp]

Restituisce tutte le app di test e di amministrazione attualmente inizializzate.

Usalo per pulire le app tra o dopo i test (nota che le app inizializzate con ascoltatori attivi impediscono l'uscita di JavaScript):

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

assertFails(pr: Promise) => Promise

Restituisce una promessa che viene rifiutata se l'input ha esito positivo e ha esito positivo se l'input viene rifiutato.

Utilizzalo per affermare che la lettura o la scrittura di un bucket di archiviazione non riesce:

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

assertSucceeds(pr: Promise) => Promise

Restituisce una promessa che ha esito positivo se l'input ha esito positivo e viene rifiutata se l'input viene rifiutato.

Utilizzalo per affermare che la lettura o la scrittura di un bucket di archiviazione ha esito positivo:

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

API della libreria RUT per JS SDK v8

Seleziona un prodotto per visualizzare i metodi utilizzati da Firebase Test SDK per interfacciarsi con l'emulatore.

Cloud Fire Store

Cloud Fire Store

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

Questo metodo restituisce un'app Firebase inizializzata corrispondente all'ID progetto e alla variabile di autenticazione specificati nelle opzioni. Utilizzalo per creare un'app autenticata come utente specifico da utilizzare nei test.

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

initializeAdminApp({ projectId: string }) => FirebaseApp

Questo metodo restituisce un'app Firebase di amministrazione inizializzata. Questa app ignora le regole di sicurezza durante l'esecuzione di letture e scritture. Utilizzalo per creare un'app autenticata come amministratore per impostare lo stato per i test.

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

apps() => [FirebaseApp] Questo metodo restituisce tutte le app di test e di amministrazione attualmente inizializzate. Usalo per pulire le app tra o dopo i test.

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

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

Questo metodo invia regole a un database in esecuzione localmente. Richiede un oggetto che specifica le regole come una stringa. Utilizza questo metodo per impostare le regole del tuo database.

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

assertFails(pr: Promise) => Promise

Questo metodo restituisce una promessa che viene rifiutata se l'input ha esito positivo o che ha esito positivo se l'input viene rifiutato. Utilizzare questo per affermare se la lettura o la scrittura di un database fallisce.

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

assertSucceeds(pr: Promise) => Promise

Questo metodo restituisce una promessa che ha esito positivo se l'input ha esito positivo e viene rifiutata se l'input viene rifiutato. Utilizzarlo per verificare se la lettura o la scrittura del database ha esito positivo.

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

clearFirestoreData({ projectId: string }) => Promise

Questo metodo cancella tutti i dati associati a un particolare progetto nell'istanza Firestore in esecuzione localmente. Utilizzare questo metodo per pulire dopo i test.

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

Banca dati in tempo reale

Banca dati in tempo reale

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

Utilizzalo per creare un'app autenticata come utente specifico da utilizzare nei test.

Restituisce un'app Firebase inizializzata corrispondente al nome del database e alla sostituzione della variabile di autenticazione specificata nelle opzioni.

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

initializeAdminApp({ databaseName: string }) => FirebaseApp

Utilizzalo per creare un'app autenticata come amministratore per impostare lo stato per i test.

Restituisce un'app Firebase di amministrazione inizializzata corrispondente al nome del database specificato nelle opzioni. Questa app ignora le regole di sicurezza durante la lettura e la scrittura nel database.

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

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

Usalo per impostare le regole del tuo database.

Invia regole a un database in esecuzione localmente. Accetta un oggetto opzioni che specifica il tuo "databaseName" e le tue "regole" come stringhe.

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

apps() => [FirebaseApp]

Restituisce tutte le app di test e di amministrazione attualmente inizializzate.

Usalo per pulire le app tra o dopo i test (nota che le app inizializzate con ascoltatori attivi impediscono l'uscita di JavaScript):

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

assertFails(pr: Promise) => Promise

Restituisce una promessa che viene rifiutata se l'input ha esito positivo e ha esito positivo se l'input viene rifiutato.

Utilizzare questo per affermare che la lettura o la scrittura di un database non riesce:

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

assertSucceeds(pr: Promise) => Promise

Restituisce una promessa che ha esito positivo se l'input ha esito positivo e viene rifiutata se l'input viene rifiutato.

Utilizzalo per affermare che la lettura o la scrittura del database ha esito positivo:

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

Archiviazione nel cloud

Archiviazione nel cloud

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

Utilizzalo per creare un'app autenticata come utente specifico da utilizzare nei test.

Restituisce un'app Firebase inizializzata corrispondente al nome del bucket di archiviazione e all'override della variabile di autenticazione specificati nelle opzioni.

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

initializeAdminApp({ storageBucket: string }) => FirebaseApp

Utilizzalo per creare un'app autenticata come amministratore per impostare lo stato per i test.

Restituisce un'app Firebase di amministrazione inizializzata corrispondente al nome del bucket di archiviazione specificato nelle opzioni. Questa app ignora le regole di sicurezza durante la lettura e la scrittura nel bucket.

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

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

Utilizzalo per impostare le regole del bucket di archiviazione.

Invia regole a bucket di archiviazione gestiti localmente. Accetta un oggetto opzioni che specifica il tuo "storageBucket" e le tue "regole" come stringhe.

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

apps() => [FirebaseApp]

Restituisce tutte le app di test e di amministrazione attualmente inizializzate.

Usalo per pulire le app tra o dopo i test (nota che le app inizializzate con ascoltatori attivi impediscono l'uscita di JavaScript):

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

assertFails(pr: Promise) => Promise

Restituisce una promessa che viene rifiutata se l'input ha esito positivo e ha esito positivo se l'input viene rifiutato.

Utilizzalo per affermare che la lettura o la scrittura di un bucket di archiviazione non riesce:

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

assertSucceeds(pr: Promise) => Promise

Restituisce una promessa che ha esito positivo se l'input ha esito positivo e viene rifiutata se l'input viene rifiutato.

Utilizzalo per affermare che la lettura o la scrittura di un bucket di archiviazione ha esito positivo:

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