Test delle unità di creazione

Le Firebase Local Emulator Suite semplificano la convalida completa di: caratteristiche e comportamento. È inoltre un ottimo strumento per verificare le configurazioni di Firebase Security Rules. Utilizza Firebase Emulators eseguire e automatizzare i test delle unità in un ambiente locale. I metodi descritti in questo documento dovrebbe aiutarti a creare e automatizzare i test delle unità per la tua app che convalidano Rules.

Se non lo hai già fatto, configura Firebase Emulators.

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" campo del tuo 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 contenenti regole aperte.
• Mentre la maggior parte degli SDK Firebase funzionano direttamente con gli emulatori, solo la libreria @firebase/rules-unit-testing supporta simulazione di auth in Regole di sicurezza, semplificando i test delle unità. Inoltre, la libreria supporta alcune funzionalità specifiche dell'emulatore, come l'eliminazione di tutti i dati, come elencato di seguito.
• Gli emulatori accetteranno anche i token di autenticazione Firebase di produzione forniti tramite SDK client e valutano di conseguenza le regole, il che consente la connessione la tua applicazione direttamente agli emulatori nei test di integrazione e manuali.

Differenze tra emulatori di database e produzione

• Non è necessario creare esplicitamente un'istanza di database. L'emulatore crea automaticamente qualsiasi istanza di database a cui si accede.
• Ogni nuovo database viene avviato con regole chiuse, pertanto gli utenti non amministratori non potranno leggere né scrivere.
• Ogni database emulato applica il piano Spark limiti e quote (soprattutto, questo limita ogni istanza a 100 connessioni).
• Qualsiasi database accetterà la stringa "owner" come token di autenticazione amministratore.
• Al momento gli emulatori non hanno interazioni di lavoro con altri Firebase prodotti di big data e machine learning. In particolare, il normale flusso di Firebase Authentication non funziona. Puoi utilizzare invece il metodo initializeTestApp() nella rules-unit-testing che richiede un campo auth. L'oggetto Firebase creato utilizzando si comporta come se fosse stato autenticato correttamente come l'entità che fornisci. Se passi null, il valore si comporterà come un utente non autenticato (ad esempio, le regole auth != null non andranno a buon fine).

Interazione con l'emulatore Realtime Database

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

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

L'emulatore viene eseguito in locale ed è disponibile all'indirizzo localhost:9000. Per interagire con un'istanza di database specifica, dovrai usare il parametro di query ns per specificare il nome del database.

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

Esegui i test delle unità locali con l'SDK JavaScript versione 9

Firebase distribuisce una libreria di test delle unità di Regole di sicurezza sia con la relativa versione SDK JavaScript 9 e versione 8 dell'SDK. Le API della libreria sono significativamente diverso. Consigliamo la libreria di test v9, che è più semplice e richiede meno configurazione per connettersi agli emulatori e quindi evita all'uso delle risorse di produzione. Per la compatibilità con le versioni precedenti, continuiamo a mettere a disposizione la libreria di test v8.

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

Usa il modulo @firebase/rules-unit-testing per interagire con l'emulatore eseguito in locale. Se si verificano timeout o errori ECONNREFUSED, verifica che l'emulatore sia effettivamente in esecuzione.

Ti consigliamo vivamente di utilizzare una versione recente di Node.js in modo da poter utilizzare Notazione async/await. Quasi tutti i comportamenti che conviene testare coinvolge funzioni asincrone e il modulo di test è progettato per funzionare Codice basato sulla promessa.

La libreria di test delle unità delle regole v9 è sempre a conoscenza degli emulatori e non le risorse di produzione.

Importa la libreria utilizzando le istruzioni di importazione modulari della versione 9. Ad esempio:

import {
  assertFails,
  assertSucceeds,
  initializeTestEnvironment
} 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.

Dopo l'importazione, l'implementazione dei test delle unità comporta:

• Creazione e configurazione di un RulesTestEnvironment con una chiamata a initializeTestEnvironment.
• Configurazione dei dati di test senza attivare Rules, per praticità che ti consente di ignorarli temporaneamente, RulesTestEnvironment.withSecurityRulesDisabled.
• Configurare la suite di test e gli hook per test prima/dopo con chiamate a ripulisci i dati e l'ambiente di test, ad esempio RulesTestEnvironment.cleanup() o RulesTestEnvironment.clearFirestore().
• Implementazione di casi di test che simulano gli stati di autenticazione utilizzando RulesTestEnvironment.authenticatedContext e RulesTestEnvironment.unauthenticatedContext.

di Gemini Advanced.

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

Metodi comuni e funzioni di utilità

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

initializeTestEnvironment() => RulesTestEnvironment

Questa funzione inizializza un ambiente di test per il test delle unità di regole. Chiama per la configurazione di test. Per una corretta esecuzione è necessario che gli emulatori in esecuzione.

La funzione accetta un oggetto facoltativo che definisce un valore TestEnvironmentConfig, che può essere composto 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"),
  },
});

Nota: gli emulatori memorizzano i dati tra le chiamate di test in una singola esecuzione dell'emulatore. Ciò potrebbe influire sui risultati. Per cancellare i dati tra ogni esecuzione di test, chiama il metodo dei dati dell'emulatore di cancellazione applicabile, ad esempio clearFirestoreData tra un test e l'altro.

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 una simulazione Token Authentication collegato. Se vuoi, passa un oggetto che definisce rivendicazioni personalizzate per i payload di token Authentication.

Utilizza l'oggetto di contesto del test restituito nei tuoi test per accedere a qualsiasi emulatore istanze configurate, 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 eseguito l'accesso tramite Authentication. Le richieste create tramite il contesto restituito collegati dei token di autenticazione Firebase.

Utilizza l'oggetto di contesto del test restituito nei tuoi test per accedere a qualsiasi emulatore istanze configurate, 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 del test con un contesto che si comporta come se le Regole di sicurezza fossero disabilitate.

Questo metodo prende una funzione di callback, che accetta le regole di sicurezza contesto e restituisce una promessa. Il contesto verrà distrutto una volta che la promessa viene risolta/rifiutata.

RulesTestEnvironment.cleanup()

Questo metodo elimina tutti i 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, usa il metodo dei dati in chiaro specifico dell'emulatore di applicazioni.

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

Questa è una funzione di utilità dello scenario di test.

La funzione asserisce che la Promise fornita che aggrega 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à dello scenario di test.

La funzione asserisce che la Promise fornita che aggrega un'operazione dell'emulatore verranno rifiutate con una violazione delle Regole di sicurezza.

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

Metodi specifici dell'emulatore

Consulta anche metodi di test e funzioni di utilità comuni che utilizzano l'API modulare.

Cloud Firestore

Cloud Firestore

RulesTestEnvironment.clearFirestore() => Promise<void>

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

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

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

Realtime Database

Realtime Database

RulesTestEnvironment.clearDatabase() => Promise<void>

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

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

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

Cloud Storage

Cloud Storage

RulesTestEnvironment.clearStorage() => Promise<void>

Questo metodo cancella gli oggetti e i 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 la connessione all'emulatore. Il metodo accetta un URL gs:// per il bucket Firebase Storage per i test. Se specificato, restituisce un'istanza Storage per una versione emulata del nome del bucket.

Esecuzione dei test delle unità locali con l'SDK JavaScript v8

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

Cloud Firestore

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

Questo metodo restituisce un'app Firebase inizializzata corrispondente al progetto ID e variabile auth specificati nelle opzioni. Usa questo pulsante per creare un'app autenticato come utente specifico da usare nei test.

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

Nota: l'emulatore Cloud Firestore mantiene i dati tra le invocazioni dei test in un'unica esecuzione dell'emulatore. Questo ciò potrebbe influire sui risultati. Per cancellare i dati tra ogni esecuzione di test, chiama il metodo clearFirestoreData tra i test.

initializeAdminApp({ projectId: string }) => FirebaseApp

Questo metodo restituisce un'app Firebase di amministrazione inizializzata. Questa app aggira 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. Usa questa opzione per eseguire la pulizia delle app tra o dopo i test.

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

Nota: se hai app inizializzate con ascoltatori attivi, JavaScript non esce. Assicurati di rimuovere i listener attivi.

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

Questo metodo invia le regole a un database in esecuzione localmente. Prende un oggetto che specifica le regole come stringa. Utilizza questo metodo per impostare le regole del 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 ha esito positivo se l'input viene rifiutato. Usa questo per asserire che un database esegue operazioni di lettura o la scrittura non riesce.

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 rifiutato se l'input viene rifiutato. Usa questo per asserire che un database esegue operazioni di lettura o scrittura riuscita.

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 nella che esegue un'istanza Firestore in locale. Utilizza questo metodo per eseguire la pulizia dopo i test.

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

Realtime Database

Realtime Database

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

Utilizza questo campo per creare un'app autenticata come utente specifico da usare nei test.

Restituisce un'app Firebase inizializzata corrispondente al nome e all'autenticazione del database dell'override specificato nelle opzioni.

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

initializeAdminApp({ databaseName: string }) => FirebaseApp

Utilizza questo campo per creare un'app autenticata come amministratore al fine di configurare lo stato per i test.

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

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

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

Utilizzalo per impostare le regole del database.

Invia le regole a un database eseguito localmente. 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 amministrazione attualmente inizializzate.

Usa questa opzione per eseguire la pulizia delle 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, mentre viene restituito se la l'input viene rifiutato.

Utilizza questo per asserire che la lettura o la scrittura del 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.

Utilizza questo per asserire che la lettura o la scrittura del database va a buon fine:

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

Cloud Storage

Cloud Storage

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

Utilizza questo campo 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 l'override della variabile "auth" è specificato nelle opzioni.

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

initializeAdminApp({ storageBucket: string }) => FirebaseApp

Utilizza questo campo per creare un'app autenticata come amministratore al fine di configurare lo stato per i test.

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

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

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

Utilizzalo per impostare le regole del bucket di archiviazione.

Invia le regole ai bucket di archiviazione gestiti localmente. Prende un oggetto options che specifica "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 amministrazione attualmente inizializzate.

Usa questa opzione per eseguire la pulizia delle 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 rifiutata se l'input va a buon fine e accolta se l'input viene rifiutato.

Utilizza questo per asserire che la lettura o la scrittura di un bucket di archiviazione non va a buon fine:

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.

Utilizza questo per asserire che la lettura o la scrittura di un bucket di archiviazione è riuscita:

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 dall'SDK Firebase Test per l'interfaccia con l'emulatore.

Cloud Firestore

Cloud Firestore

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

Questo metodo restituisce un'app Firebase inizializzata corrispondente al progetto ID e variabile auth specificati nelle opzioni. Usa questo pulsante per creare un'app autenticato come utente specifico da usare nei test.

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

Nota: l'emulatore Cloud Firestore mantiene i dati tra le invocazioni dei test in un'unica esecuzione dell'emulatore. Questo ciò potrebbe influire sui risultati. Per cancellare i dati tra ogni esecuzione di test, chiama il metodo clearFirestoreData tra i test.

initializeAdminApp({ projectId: string }) => FirebaseApp

Questo metodo restituisce un'app Firebase di amministrazione inizializzata. Questa app aggira 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. Usa questa opzione per eseguire la pulizia delle app tra o dopo i test.

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

Nota: se hai app inizializzate con ascoltatori attivi, JavaScript non esce. Assicurati di rimuovere i listener attivi.

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

Questo metodo invia le regole a un database in esecuzione localmente. Prende un oggetto che specifica le regole come stringa. Utilizza questo metodo per impostare le regole del 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 ha esito positivo se l'input viene rifiutato. Usa questo per asserire che un database esegue operazioni di lettura o la scrittura non riesce.

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 rifiutato se l'input viene rifiutato. Usa questo per asserire che un database esegue operazioni di lettura o scrittura riuscita.

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 nella che esegue un'istanza Firestore in locale. Utilizza questo metodo per eseguire la pulizia dopo i test.

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

Realtime Database

Realtime Database

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

Utilizza questo campo per creare un'app autenticata come utente specifico da usare nei test.

Restituisce un'app Firebase inizializzata corrispondente al nome e all'autenticazione del database dell'override specificato nelle opzioni.

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

initializeAdminApp({ databaseName: string }) => FirebaseApp

Utilizza questo campo per creare un'app autenticata come amministratore al fine di configurare lo stato per i test.

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

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

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

Utilizzalo per impostare le regole del database.

Invia le regole a un database eseguito localmente. 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 amministrazione attualmente inizializzate.

Usa questa opzione per eseguire la pulizia delle 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, mentre viene restituito se la l'input viene rifiutato.

Utilizza questo per asserire che la lettura o la scrittura del 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.

Utilizza questo per asserire che la lettura o la scrittura del database va a buon fine:

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

Cloud Storage

Cloud Storage

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

Utilizza questo campo 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 l'override della variabile "auth" è specificato nelle opzioni.

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

initializeAdminApp({ storageBucket: string }) => FirebaseApp

Utilizza questo campo per creare un'app autenticata come amministratore al fine di configurare lo stato per i test.

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

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

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

Utilizzalo per impostare le regole del bucket di archiviazione.

Invia le regole ai bucket di archiviazione gestiti localmente. Prende un oggetto options che specifica "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 amministrazione attualmente inizializzate.

Usa questa opzione per eseguire la pulizia delle 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 rifiutata se l'input va a buon fine e accolta se l'input viene rifiutato.

Utilizza questo per asserire che la lettura o la scrittura di un bucket di archiviazione non va a buon fine:

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.

Utilizza questo metodo per verificare che la lettura o la scrittura di un bucket di archiviazione sia andata a buon fine:

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