Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

Teste funções interativamente

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

O shell do Cloud Functions fornece um shell interativo para invocar funções com dados de teste. O shell oferece suporte a todos os tipos de gatilho.

Configurar credenciais de administrador (opcional)

Se você deseja que seus testes de funções interajam com as APIs do Google ou outras APIs do Firebase por meio do Firebase Admin SDK , pode ser necessário configurar credenciais de administrador.

  • Os gatilhos Cloud Firestore e Realtime Database já têm credenciais suficientes e não requerem configuração adicional.
  • Todas as outras APIs, incluindo APIs do Firebase, como Authentication e FCM, ou APIs do Google, como Cloud Translation ou Cloud Speech, exigem as etapas de configuração descritas nesta seção. Isso se aplica se você estiver usando o shell do Cloud Functions ou os firebase emulators:start .

Para configurar credenciais de administrador para funções emuladas:

  1. Abra o painel Contas de serviço do Console do Google Cloud.
  2. Certifique-se de que a conta de serviço padrão do App Engine esteja selecionada e use o menu de opções à direita para selecionar Criar chave .
  3. Quando solicitado, selecione JSON para o tipo de chave e clique em Criar .
  4. Defina suas credenciais padrão do Google para apontar para a chave baixada:

    Unix

    export GOOGLE_APPLICATION_CREDENTIALS="path/to/key.json"
    firebase functions:shell
    

    janelas

    set GOOGLE_APPLICATION_CREDENTIALS=path\to\key.json
    firebase functions:shell
    

Depois de concluir essas etapas, seus testes de funções podem acessar as APIs do Firebase e do Google usando o Admin SDK . Por exemplo, ao testar um acionador de autenticação, a função emulada pode chamar admin.auth().getUserByEmail(email) .

Exiba funções usando um shell do Cloud Functions

O shell do Cloud Functions emula todos os tipos de gatilhos de função com um shell interativo para invocar as funções com dados de teste. As opções variam de acordo com o tipo de função, mas o formato de uso básico é:

myFunctionName(data, options)

O parâmetro de data é obrigatório para os acionadores Realtime Database, Cloud Firestore e PubSub e opcional para todos os outros tipos de função. Além disso, o parâmetro de options opcionais é válido apenas para as funções Realtime Database e Cloud Firestore.

Opcionalmente, você pode carregar dados de teste de um arquivo local salvando o arquivo como uma variável e invocando uma função com ele:

var data = require('./path/to/testData.json');
myFunction(data);

Instalar e configurar o shell do Cloud Functions

Para usar esse recurso, firebase-tools deve ter no mínimo a versão 3.11.0 e firebase-functions SDK deve ter no mínimo a versão 0.6.2. Para atualizar ambos, execute os seguintes comandos no diretório functions/ do seu projeto:

npm install --save firebase-functions@latest
npm install -g firebase-tools

Se você estiver usando variáveis ​​de configuração de funções personalizadas, primeiro execute o comando para obter sua configuração personalizada (execute isso no diretório de functions ) em seu ambiente local:

firebase functions:config:get > .runtimeconfig.json
# If using Windows PowerShell, replace the above with:
# firebase functions:config:get | ac .runtimeconfig.json

Por fim, execute o shell com o seguinte comando:

firebase functions:shell

Chamar funções HTTPS

Para invocar funções HTTPS no shell, o uso é o mesmo que o módulo request NPM, mas substitua request pelo nome da função que você deseja emular. Por exemplo:

# invoke
myHttpsFunction()
myHttpsFunction.get()
myHttpsFunction.post()

# invoke at sub-path
myHttpsFunction('/path')
myHttpsFunction.get('/path')
myHttpsFunction.post('/path')

# send POST request with form data
myHttpsFunction.post('/path').form( {foo: 'bar' })

Chamar funções HTTPS Callable

Ao invocar funções HTTPS Callable localmente, você precisará fornecer dados de teste apropriados.

# invoke
myCallableFunction('test data')
myCallableFunction({'foo': 'bar'})

Opcionalmente, você pode passar um Firebase-Instance-ID-token como o segundo parâmetro. Isso deve ser uma string.

# invoke with FCM registration token
myCallableFunction('test data', {instanceIdToken: 'sample token'})

A emulação de context.auth está indisponível no momento.

Chamar funções do Realtime Database

Ao executar as funções do Realtime Database localmente, você precisará fornecer os dados de teste apropriados. Isso geralmente significa fornecer novos dados de teste para operações onCreate , dados antigos/removidos para operações onDelete e ambos para funções onUpdate ou onWrite :

# invoke onCreate function
myDatabaseFunction('new_data')

# invoke onDelete function
myDatabaseFunction('old_data')

# invoke onUpdate or onWrite function
myDatabaseFunction({before: 'old_data', after: 'new_data' })

Além das opções before/after , o shell fornece a opção params para usar na simulação de curingas em um caminho:

# mock wildcards in path, for example: if the path was input/{group}/{id}
myDatabaseFunction('data', {params: {group: 'a', id: 123}})

Por padrão, o shell executa as funções do Realtime Database com privilégios de administrador (conta de serviço). Use a opção auth para executar funções como um usuário final específico ou como um usuário não autenticado:

# to mock unauthenticated user
myDatabaseFunction('data', {authMode: 'USER'})
# to mock end user
myDatabaseFunction('data', {auth: {uid: 'abcd'}})

Chamar funções do Firestore

Ao executar as funções do Firestore localmente, você precisará fornecer os dados de teste apropriados. Isso geralmente significa fornecer novos dados de teste para operações onCreate , dados antigos/removidos para operações onDelete e ambos para funções onUpdate ou onWrite . Observe que os dados do Firestore precisam ser pares de valor-chave; consulte Tipos de dados suportados .

# invoke onCreate function
myFirestoreFunction({foo: ‘new’})

# invoke onDelete function
myFirestoreFunction({foo: ‘old’})

# invoke onUpdate or onWrite function
myFirestoreFunction({before: {foo: ‘old’}, after: {foo: ‘new’} })

Além dos campos before/after do objeto de data , você pode usar os campos params no objeto de options para simular curingas em um nome de documento:

# mock wildcards in document name, for example: if the name was input/{group}/{id}
myFirestoreFunction({foo: ‘new’}, {params: {group: 'a', id: 123}})

O shell sempre executa funções do Firestore com privilégios administrativos, o que significa que ele zomba de um evento de criação/atualização/exclusão como se fosse feito por um usuário administrativo.

Invocar funções do PubSub

Para funções PubSub, insira o payload da mensagem em uma instância do Buffer e adicione opcionalmente atributos de dados conforme mostrado:

// invokes a function with the JSON message { hello: 'world' } and attributes { foo: 'bar' }
myPubsubFunction({data: new Buffer('{"hello":"world"}'), attributes: {foo: 'bar'}})

Chamar funções do Analytics

Você pode invocar uma função do Analytics sem nenhum dado executando myAnalyticsFunction() no shell. Para executar a função com dados de teste, é recomendável definir uma variável para os campos de dados de eventos específicos que sua função precisa:

var data = {
  eventDim: [{
    // populates event.data.params
    params:{foo:'bar'},
    // populates event.data.name
    name: 'event_name',
    // populates event.data.logTime, specify in microseconds
    timestampMicros: Date.now() * 1000,
    // populates event.data.previousLogTime, specify in microseconds
    previousTimestampMicros: Date.now() * 1000,
    // populates event.data.reportingDate, specify in 'YYYYMMDD' format
    date: '20170930',
    // populates event.data.valueInUSD
    valueInUsd: 230
  }],
  userDim: userDim
};

myAnalyticsFunction(data);

Chamar funções de armazenamento e autenticação

Para as funções Storage e Auth, invoque a função local com os dados de teste que você gostaria de ver dentro da função. Seus dados de teste devem seguir os formatos de dados correspondentes:

Especifique apenas os campos dos quais seu código depende ou nenhum se desejar apenas executar a função.