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. Usa gli emulatori Firebase per eseguire e automatizzare gli unit test in un ambiente locale. I metodi descritti in questo documento dovrebbero aiutarti durante la creazione e l'automazione degli 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, tieni 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 si utilizza il loadFirestoreRules o 'loadStorageRules' come descritto di seguito, l'emulatore considera tutti i progetti come se avessero regole aperte.
  • Sebbene la maggior parte degli SDK Firebase funzioni direttamente con gli emulatori, solo la @firebase/rules-unit-testing supporta l' auth fittizia nelle regole di sicurezza, rendendo molto più semplici gli unit test. 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 collegare l'applicazione direttamente agli emulatori in integrazione e test manuali.

Differenze tra gli emulatori di database e la produzione

  • Non è necessario creare esplicitamente 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 non hanno attualmente interazioni funzionanti con altri prodotti Firebase. In particolare, il normale flusso di autenticazione Firebase non funziona. Invece, puoi usare 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à fornita. Se si passa null , si comporterà come un utente non autenticato ( auth != null falliranno, ad esempio).

Interazione con l'emulatore di 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 in localhost:9000 . Per interagire con un'istanza di database specifica, dovrai utilizzare il parametro query ns per specificare il nome del database.

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

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

Firebase distribuisce una libreria di unit test delle regole di sicurezza con l'SDK JavaScript versione 9 e 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 ed evitare così in sicurezza l'uso accidentale delle risorse di produzione. Per la compatibilità con le versioni precedenti, continuiamo a rendere disponibile la libreria di test v8 .

Usa il @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.

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.

Importare 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 degli unit test comporta:

  • Creazione e configurazione di un RulesTestEnvironment con una chiamata a initializeTestEnvironment .
  • Configurazione dei dati di test senza attivare le regole, utilizzando un metodo pratico che consente di ignorarle temporaneamente, RulesTestEnvironment.withSecurityRulesDisabled .
  • Configurazione della suite di test e degli hook per test prima/dopo 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 usando RulesTestEnvironment.authenticatedContext e RulesTestEnvironment.unauthenticatedContext .

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 delle unità delle regole. Chiamare prima questa funzione per la configurazione di prova. L'esecuzione riuscita 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 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 o sostituzioni personalizzate per i payload del token di autenticazione.

Utilizzare l'oggetto contesto di test restituito nei test per accedere a qualsiasi istanza dell'emulatore configurata, comprese 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 Firebase Auth allegati.

Utilizzare l'oggetto contesto di test restituito nei test per accedere a qualsiasi istanza dell'emulatore configurata, comprese 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()

Eseguire 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 sarà risolta/rifiutata.

RulesTestEnvironment.cleanup()

Questo metodo distrugge 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, utilizzare il metodo Clear Data specifico dell'emulatore dell'applicazione.

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

Questa è una funzione di utilità del test case.

La funzione afferma che la promessa fornita che avvolge un'operazione di 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 test case.

La funzione afferma che la promessa fornita che avvolge un'operazione di 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à nell'SDK v9 .

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 ottiene un'istanza Firestore per questo contesto di test. L'istanza di 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 database in tempo reale che appartiene al projectId configurato per l'emulatore di database in tempo reale.

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

Ottieni un'istanza di database in tempo reale per questo contesto di test. L'istanza di 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 del database in tempo reale. Se specificato, restituisce un'istanza per una versione emulata dello spazio dei nomi con parametri estratti dall'URL.

Archiviazione su cloud

Archiviazione su cloud

RulesTestEnvironment.clearStorage() => Promise<void>

Questo metodo cancella oggetti e metadati nei bucket di archiviazione appartenenti al projectId configurato per l'emulatore di 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 di archiviazione Firebase per il test. Se specificato, restituisce un'istanza di archiviazione per una versione emulata del nome del bucket.

Esegui test di unità locali con l'SDK JavaScript v8

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

Cloud Firestore

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. Usalo 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. 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 di amministrazione attualmente inizializzate. Usalo per ripulire le app tra o dopo i test.

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

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 una stringa. Utilizzare 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 che ha esito positivo se l'input viene rifiutato. Utilizzare questo per asserire se una lettura o scrittura del database 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 rifiutata se l'input viene rifiutato. Usalo per affermare se una lettura o una scrittura del database hanno 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"
});
   

Database in tempo reale

Database in tempo reale

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

Usalo per creare un'app autenticata come utente specifico da utilizzare 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 impostare lo stato per i test.

Restituisce un'app Firebase amministrativa 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 localmente. Prende 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 amministrazione e test attualmente inizializzate.

Usalo per ripulire le app tra o dopo i test (tieni presente che le app inizializzate con listener 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.

Utilizzare questo per affermare che la lettura o la scrittura di un database ha esito positivo:

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

Archiviazione su cloud

Archiviazione su cloud

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

Usalo 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 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 impostare lo stato per i test.

Restituisce un'app Firebase amministrativa 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 un bucket di archiviazione gestito 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 amministrazione e test attualmente inizializzate.

Usalo per ripulire le app tra o dopo i test (tieni presente che le app inizializzate con listener 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 una lettura o 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.

Utilizzare questo per affermare che un bucket di archiviazione in lettura o scrittura ha esito positivo:

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

API della libreria RUT per JS SDK v8

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

Cloud Firestore

Cloud Firestore

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. Usalo 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. 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 di amministrazione attualmente inizializzate. Usalo per ripulire le app tra o dopo i test.

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

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 una stringa. Utilizzare 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 che ha esito positivo se l'input viene rifiutato. Utilizzare questo per asserire se una lettura o scrittura del database 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 rifiutata se l'input viene rifiutato. Usalo per affermare se una lettura o una scrittura del database hanno 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"
});
   

Database in tempo reale

Database in tempo reale

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

Usalo per creare un'app autenticata come utente specifico da utilizzare 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 impostare lo stato per i test.

Restituisce un'app Firebase amministrativa 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 localmente. Prende 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 amministrazione e test attualmente inizializzate.

Usalo per ripulire le app tra o dopo i test (tieni presente che le app inizializzate con listener 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.

Utilizzare questo per affermare che la lettura o la scrittura di un database ha esito positivo:

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

Archiviazione su cloud

Archiviazione su cloud

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

Usalo 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 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 impostare lo stato per i test.

Restituisce un'app Firebase amministrativa 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 un bucket di archiviazione gestito 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 amministrazione e test attualmente inizializzate.

Usalo per ripulire le app tra o dopo i test (tieni presente che le app inizializzate con listener 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 una lettura o 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.

Utilizzare questo per affermare che un bucket di archiviazione in lettura o scrittura ha esito positivo:

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