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 di 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 l'hai già fatto, configura gli emulatori Firebase .

Prima di eseguire l'emulatore

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

• L'emulatore caricherà inizialmente le regole specificate nel campo firestore.rules o 'storage.rules' del tuo file firebase.json . Se il file non esiste e non utilizzi il metodo loadFirestoreRules o 'loadStorageRules' come descritto di seguito, l'emulatore tratta tutti i progetti come se avessero regole aperte.
• Sebbene la maggior parte degli SDK Firebase funzioni 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 Firebase Auth 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 la produzione

• Non è necessario creare in modo esplicito un'istanza di database. L'emulatore creerà automaticamente qualsiasi istanza di 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, questo 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 correttamente come qualsiasi entità tu fornisca. Se passi null , si comporterà come un utente non autenticato ( auth != null falliranno, per esempio).

Interagire con l'emulatore del database in tempo reale

Un'istanza di Firebase Realtime Database di produzione è 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 versione 9 che con l'SDK versione 8. Le API della libreria sono significativamente diverse. Consigliamo la libreria di test v9, che è più snella e richiede meno configurazione 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 .

• Metodi di test comuni e funzioni di utilità nell'SDK v9
• Metodi di test specifici dell'emulatore nell'SDK v9

Usa il modulo @firebase/rules-unit-testing per interagire con l'emulatore che viene 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 il 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 modulari 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 ignorarle temporaneamente, RulesTestEnvironment.withSecurityRulesDisabled .
• Impostazione della suite di test e degli hook prima/dopo per test con chiamate per ripulire 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 .

Nota: di seguito viene fornito un riepilogo dell'API per la libreria di unit test delle regole. Puoi anche consultare la documentazione completa di riferimento dell'API .

Metodi comuni e funzioni di utilità

Vedi anche i metodi di test specifici dell'emulatore nell'SDK v9 .

initializeTestEnvironment() => RulesTestEnvironment

Questa funzione inizializza un ambiente di test per il test unitario delle regole. Chiamare prima questa funzione per la configurazione del test. L'esecuzione corretta richiede 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 impostazioni di configurazione dell'emulatore.

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

Nota: gli emulatori mantengono i dati tra le chiamate di test su una singola esecuzione dell'emulatore. Ciò potrebbe influire sui risultati. Per cancellare i dati tra ogni esecuzione del test, chiamare il metodo di dati dell'emulatore clear applicabile, ad esempio clearFirestoreData , tra i test.

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

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

Utilizza l'oggetto del contesto di test restituito nei tuoi 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 è connesso tramite Authentication. Le richieste create tramite il contesto restituito non avranno i token Firebase Auth collegati.

Utilizza l'oggetto del contesto di test restituito nei tuoi 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 impostazione del test 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 esclusione 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 i test, 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 l'operazione di wrapping di Promise fornita da un 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 l'operazione di wrapping di Promise fornita da un emulatore verrà rifiutata con una violazione delle regole di sicurezza.

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

Metodi specifici dell'emulatore

Vedi anche i metodi di test comuni e le funzioni di utilità nell'SDK v9 .

CloudFirestore

CloudFirestore

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 dell'SDK client (v9 modular o v9 compat).

Database in tempo reale

Database 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 dell'SDK client (v9 modular o v9 compat). 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 cloud

Archiviazione 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.

CloudFirestore

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

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

firebase.initializeTestApp({
  projectId: "my-test-project",
  auth: { uid: "alice", email: "[e-mail]" }
});

Nota: l'emulatore Cloud Firestore conserva i dati tra le chiamate di test su una singola esecuzione dell'emulatore. Ciò potrebbe influire sui risultati. Per cancellare i dati tra ogni esecuzione del test, chiama il metodo clearFirestoreData tra i test.

initializeAdminApp({ projectId: string }) => FirebaseApp

Questo metodo restituisce un'app di amministrazione Firebase inizializzata. Questa app ignora le regole di sicurezza durante l'esecuzione di letture e scritture. Usalo 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 amministrazione attualmente inizializzate. Usalo per ripulire le app tra o dopo i test.

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

Nota: se disponi di app inizializzate con listener attivi, JavaScript non si chiude. Assicurati di rimuovere gli ascoltatori attivi.

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

Questo metodo invia le regole a un database in esecuzione in locale. Prende un oggetto che specifica le regole come una stringa. Usa 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. Usa questo per affermare se una lettura o 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. Utilizzare questo per affermare se una lettura o scrittura di un 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 in locale. Utilizzare questo metodo per ripulire dopo i test.

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

Database in tempo reale

Database in tempo reale

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

Usalo per creare un'app autenticata come utente specifico da usare nei test.

Restituisce un'app firebase inizializzata corrispondente al nome del database e all'override della variabile auth specificati nelle opzioni.

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

initializeAdminApp({ databaseName: string }) => FirebaseApp

Usalo per creare un'app autenticata come amministratore per configurare 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 le regole a un database in esecuzione in locale. Prende un oggetto options 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 ripulire le app tra o dopo i test (tieni presente che le app inizializzate con listener attivi impediscono l'uscita da 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.

Usa questo per affermare che una lettura o scrittura di un database fallisce:

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.

Usa questo per affermare che una lettura o scrittura di un database ha esito positivo:

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

Archiviazione cloud

Archiviazione cloud

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

Usalo per creare un'app autenticata come utente specifico da usare nei test.

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

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

initializeAdminApp({ storageBucket: string }) => FirebaseApp

Usalo per creare un'app autenticata come amministratore per configurare 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

Usalo per impostare le regole del tuo bucket di archiviazione.

Invia le regole a bucket di archiviazione gestiti localmente. Prende un oggetto options 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 ripulire le app tra o dopo i test (tieni presente che le app inizializzate con listener attivi impediscono l'uscita da 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.

Usa questo per affermare che la lettura o la scrittura di un bucket di archiviazione ha esito negativo:

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.

Usa questo 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.

CloudFirestore

CloudFirestore

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

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

firebase.initializeTestApp({
  projectId: "my-test-project",
  auth: { uid: "alice", email: "[e-mail]" }
});

Nota: l'emulatore Cloud Firestore conserva i dati tra le chiamate di test su una singola esecuzione dell'emulatore. Ciò potrebbe influire sui risultati. Per cancellare i dati tra ogni esecuzione del test, chiama il metodo clearFirestoreData tra i test.

initializeAdminApp({ projectId: string }) => FirebaseApp

Questo metodo restituisce un'app di amministrazione Firebase inizializzata. Questa app ignora le regole di sicurezza durante l'esecuzione di letture e scritture. Usalo 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 amministrazione attualmente inizializzate. Usalo per ripulire le app tra o dopo i test.

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

Nota: se disponi di app inizializzate con listener attivi, JavaScript non si chiude. Assicurati di rimuovere gli ascoltatori attivi.

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

Questo metodo invia le regole a un database in esecuzione in locale. Prende un oggetto che specifica le regole come una stringa. Usa 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. Usa questo per affermare se una lettura o 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. Utilizzare questo per affermare se una lettura o scrittura di un 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 in locale. Utilizzare questo metodo per ripulire dopo i test.

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

Database in tempo reale

Database in tempo reale

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

Usalo per creare un'app autenticata come utente specifico da usare nei test.

Restituisce un'app firebase inizializzata corrispondente al nome del database e all'override della variabile auth specificati nelle opzioni.

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

initializeAdminApp({ databaseName: string }) => FirebaseApp

Usalo per creare un'app autenticata come amministratore per configurare 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 le regole a un database in esecuzione in locale. Prende un oggetto options 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 ripulire le app tra o dopo i test (tieni presente che le app inizializzate con listener attivi impediscono l'uscita da 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.

Usa questo per affermare che una lettura o scrittura di un database fallisce:

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.

Usa questo per affermare che una lettura o scrittura di un database ha esito positivo:

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

Archiviazione cloud

Archiviazione cloud

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

Usalo per creare un'app autenticata come utente specifico da usare nei test.

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

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

initializeAdminApp({ storageBucket: string }) => FirebaseApp

Usalo per creare un'app autenticata come amministratore per configurare 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

Usalo per impostare le regole del tuo bucket di archiviazione.

Invia le regole a bucket di archiviazione gestiti localmente. Prende un oggetto options 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 ripulire le app tra o dopo i test (tieni presente che le app inizializzate con listener attivi impediscono l'uscita da 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.

Usa questo per affermare che la lettura o la scrittura di un bucket di archiviazione ha esito negativo:

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.

Usa questo 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());