Conectar o app e começar a prototipagem

Cloud Firestore Realtime Database

Antes de começar a usar o pacote do emulador local do Firebase, crie um projeto do Firebase, configure o ambiente de desenvolvimento e selecione e instale os SDKs do Firebase na plataforma de acordo com os tópicos Primeiros passos com o Firebase da sua plataforma: iOS, Android ou Web.

Desenvolver protótipos e testar

O pacote do emulador local contém vários emuladores de produtos, conforme descrito na Introdução ao pacote do emulador local do Firebase. É possível criar protótipos e testar com emuladores individuais, assim como combinações de emuladores, conforme achar adequado, que correspondam aos produtos do Firebase que você está usando na produção.

Neste tópico, para apresentar o fluxo de trabalho do pacote do emulador local, vamos supor que você esteja trabalhando em um app que usa uma combinação comum de produtos: Firebase Database e Cloud Functions, acionados por operações nesse banco de dados.

Depois que você inicializar localmente o projeto do Firebase, o ciclo de desenvolvimento usando o pacote do emulador local geralmente terá três etapas:

1. O protótipo funciona interativamente com os emuladores e a IU do Pacote do emulador.

2. Se você estiver usando um emulador do Database ou o emulador do Cloud Functions, execute uma etapa única para conectar o aplicativo aos emuladores.

3. Automatize os testes com os emuladores e scripts personalizados.

Inicializar localmente um projeto do Firebase

Instale a CLI ou atualize para a versão mais recente.

curl -sL firebase.tools | bash

Se você ainda não tiver feito isso, inicialize o diretório de trabalho atual como um projeto do Firebase, seguindo as instruções na tela para especificar que você está usando o Cloud Functions e também o Cloud Firestore ou o Realtime Database:

firebase init

O diretório do projeto agora conterá arquivos de configuração do Firebase, um arquivo de definição de regras de segurança do Firebase para o banco de dados, um diretório functions que contém o código do Cloud Functions e outros arquivos de suporte.

Desenvolver protótipos de maneira interativa

O pacote do emulador local foi projetado para permitir a criação de protótipos de novos recursos rapidamente, e a interface de usuário integrada do pacote é uma das ferramentas de prototipagem mais úteis. É como executar o Console do Firebase localmente.

Com a IU do pacote do emulador, é possível iterar o design de um banco de dados, testar diferentes fluxos de dados que envolvam o Cloud Functions, avaliar alterações de regras de segurança, verificar registros para confirmar o desempenho dos serviços de back-end e muito mais. Depois, se você quiser começar de novo, limpe o banco de dados e recomece com uma nova ideia de design.

Tudo está disponível quando você inicia o Pacote do emulador local com:

firebase emulators:start

Para prototipar nosso app hipotético, vamos configurar e testar uma função básica do Cloud que modifique entradas de texto em um banco de dados e também crie e preencha esse banco de dados na IU do Pacote do emulador para acioná-lo.

1. Crie uma função do Cloud acionada por gravações em banco de dados editando o arquivo functions/index.js no diretório do projeto. Substitua o conteúdo do arquivo atual pelo snippet a seguir. Essa função detecta alterações em documentos na coleção messages, converte o conteúdo do campo original de um documento em maiúsculas e armazena o resultado no campo uppercase dele.

  const functions = require('firebase-functions');

  exports.makeUppercase = functions.firestore.document('/messages/{documentId}')
      .onCreate((snap, context) => {
        const original = snap.data().original;
        console.log('Uppercasing', context.params.documentId, original);
        const uppercase = original.toUpperCase();
        return snap.ref.set({uppercase}, {merge: true});
      });
  

2. Inicie o pacote do emulador local com firebase emulators:start. Os emuladores do Cloud Functions e do Database são inicializados, configurados automaticamente para interoperar.
3. Veja a IU no navegador em http://localhost:4000. A porta 4.000 é o padrão para a IU, mas verifique as mensagens do terminal enviadas pela CLI do Firebase. Observe o status dos emuladores disponíveis. Nesse caso, os emuladores do Cloud Functions e do Cloud Firestore serão executados.
   Página principal da IU
4. Na IU, na guia Firestore, na subguia Dados, clique em Iniciar coleção e siga as instruções para criar uma Novo documento em uma coleção messages, com o nome do campo original e o valor test. Isso aciona nossa função do Cloud. Observe que um novo campo uppercase aparecerá logo em seguida, preenchido com a string "TEST".
   Criar uma coleção Observar atualizações por função
5. Na guia Firestore > Solicitações, verifique as solicitações feitas ao banco de dados emulado, incluindo todas as avaliações de regras de segurança do Firebase realizadas como parte do preenchimento dessas solicitações.
6. Verifique a guia Registros para confirmar se a função não encontrou erros durante a atualização do banco de dados.

É possível iterar facilmente entre o código da função do Cloud e as edições interativas do banco de dados até receber o fluxo de dados que você está procurando, sem tocar no código de acesso do banco de dados no app, recompilar e executar novamente os conjuntos de testes.

Conectar seu app aos emuladores

Quando tiver avançado com a criação de protótipos interativos e tiver definido um design, estará tudo pronto para adicionar o código de acesso ao banco de dados usando o SDK apropriado. Você continuará usando a guia Database e, para o Functions, a guia Registros na IU do Pacote do emulador para confirmar se o comportamento do app está correto.

Lembre-se de que o Pacote do emulador local é uma ferramenta de desenvolvimento local. As gravações nos bancos de dados de produção não acionarão funções que você está prototipando localmente.

Para que o app faça gravações no banco de dados, você precisa indicar as classes de teste ou a configuração no app para o emulador do Cloud Firestore.

        // 10.0.2.2 is the special IP address to connect to the 'localhost' of
        // the host computer from an Android emulator.
        FirebaseFirestore firestore = FirebaseFirestore.getInstance();
        firestore.useEmulator("10.0.2.2", 8080);

        FirebaseFirestoreSettings settings = new FirebaseFirestoreSettings.Builder()
                .setPersistenceEnabled(false)
                .build();
        firestore.setFirestoreSettings(settings);
EmulatorSuite.java

let settings = Firestore.firestore().settings
settings.host = "localhost:8080"
settings.isPersistenceEnabled = false
settings.isSSLEnabled = false
Firestore.firestore().settings = settings
ViewController.swift

import { getFirestore, connectFirestoreEmulator } from "firebase/firestore";

// firebaseApps previously initialized using initializeApp()
const db = getFirestore();
connectFirestoreEmulator(db, 'localhost', 8080);
fs_emulator_connect.js

// Firebase previously initialized using firebase.initializeApp().
var db = firebase.firestore();
if (location.hostname === "localhost") {
  db.useEmulator("localhost", 8080);
}
emulator-suite.js

// Initialize your Web app as described in the Get started for Web
// Firebase previously initialized using firebase.initializeApp().
var db = firebase.firestore();
if (location.hostname === "localhost") {
  db.useEmulator("localhost", 8080);
}
emulator-suite.js

Automatizar seus testes com scripts personalizados

Agora vamos para a última etapa geral do fluxo de trabalho. Depois de prototipar o recurso no app e ele parecer promissor em todas as plataformas, você poderá recorrer à implementação e aos testes finais. Para testes de unidade e fluxos de trabalho de CI, é possível iniciar emuladores, executar testes de script e encerrar emuladores em uma única chamada com o comando exec:

firebase emulators:exec "./testdir/test.sh"

Ver emuladores individuais em mais detalhes

Agora que você já conhece o fluxo de trabalho básico do cliente, é possível continuar com os detalhes sobre os emuladores individuais no pacote, incluindo como usá-los para o desenvolvimento de apps do servidor:

• Adicionar o emulador do Authentication aos fluxos de trabalho de prototipagem
• Saiba mais sobre os recursos do emulador do Realtime Database
• Saiba mais sobre os recursos do emulador do Cloud Storage
• Saiba mais sobre os recursos do emulador do Cloud Firestore
• Conectar seu app ao emulador do Cloud Functions

A seguir

Leia os tópicos relacionados a emuladores específicos indicados acima. Depois, siga estas instruções:

• Para ver um conjunto selecionado de vídeos e exemplos detalhados de instruções, siga a playlist de treinamento dos emuladores do Firebase.
• Investigue casos de uso avançados que envolvam testes de regras de segurança e o SDK de teste do Firebase: testar regras de segurança (Cloud Firestore) , testar regras de segurança (Realtime Database) e testar regras de segurança (Cloud Storage).