Integración continua, implementación continua y pruebas

En esta guía, se abordan recomendaciones para probar y, luego, implementar funciones de Cloud Functions. También se analizan los tipos de pruebas que debes usar y se proporcionan algunas instrucciones para ejemplos de situaciones de prueba. Además, se incluye información sobre cómo ejecutar automáticamente las pruebas y cómo volver a implementar las funciones de manera opcional con una plataforma de integración y de implementación continuas (IC/IC), como Cloud Build.

Antes de comenzar

Antes de comenzar con esta guía, configura tu entorno.

Marcos de trabajo

Node.js

Los ejemplos de esta guía usan Mocha como un marco de trabajo para pruebas a fin de ejecutar pruebas, y Sinon como un simulador de marcos de trabajo para simular dependencias externas.

Una dependencia externa es una dependencia en la que se basa tu función, que no forma parte del código de esta. Algunos ejemplos comunes de dependencias externas son otros servicios de Google Cloud Platform y las bibliotecas instaladas con administradores de paquetes, como npm.

Python

Los ejemplos de esta guía usan Pytest como un marco de trabajo para pruebas a fin de ejecutar pruebas, y unittest como un simulador de marcos de trabajo para simular dependencias externas.

Una dependencia externa es una dependencia en la que se basa tu función, que no forma parte del código de esta. Algunos ejemplos comunes de dependencias externas son otros servicios de Google Cloud Platform y las bibliotecas instaladas con administradores de paquetes, como pip.

Go

Los ejemplos de esta guía usan el paquete estándar testing de biblioteca para ejecutar las pruebas. Sin embargo, las pruebas del sistema tienen dependencias externas.

Una dependencia externa es una dependencia en la que se basa tu función, que no forma parte del código de esta. Algunos ejemplos comunes de dependencias externas son otros servicios de Google Cloud Platform y otros paquetes que hayas descargado.

Tipos de pruebas

Existen tres tipos de pruebas que puedes usar cuando trabajas con Cloud Functions, cada una de las cuales prueba un aspecto diferente de tu código. Se enumeran a continuación, en orden ascendente en términos de su rigurosidad:

  • Pruebas de unidad
  • Pruebas de integración
  • Pruebas del sistema

En general, las pruebas más rigurosas tardan más tiempo en completarse. En este documento, se analizan estos tipos de pruebas en detalle, así como la forma de encontrar un balance entre rapidez y rigurosidad.

Pruebas de unidad

Las pruebas de unidad son pruebas de poco alcance para partes pequeñas y específicas de tu código. Estas pruebas son buenas para verificar rápidamente las suposiciones que se hicieron durante el proceso de desarrollo, como el manejo de casos extremos y la validación de entradas.

Por su diseño, las pruebas de unidad no prueban la integración en dependencias externas, como las propias funciones de Cloud Functions o algunos otros componentes de Google Cloud Platform. Puedes usar tu marco de trabajo de simulación para crear versiones simuladas de dependencias externas.

Para las funciones de HTTP, las pruebas deben simular la unión de marcos de trabajo de HTTP. Confirma el comportamiento de la función mediante la combinación de marcos de trabajo de prueba y de simulación, y compara los resultados de tu función con los valores esperados.

Las pruebas de unidad no pueden detectar cambios en dependencias externas. Si estas dependencias cambian, tanto el código probado como tus simulaciones deben actualizarse.

Pruebas de integración

Las pruebas de integración validan la interacción entre partes de tu código y, por lo general, tardan un tiempo prudencial en completarse. Por ejemplo, en Cloud Functions, las pruebas de integración pueden usarse para probar el uso que hace una función de otros servicios de GCP, como Cloud Datastore o Cloud AutoML Vision.

La diferencia principal entre las pruebas de unidades y las de integración en relación con Cloud Functions es que las últimas implican menos simulación que las primeras. Las pruebas de integración deben activar y responder a los eventos de Cloud, como las solicitudes HTTP, los mensajes de Cloud Pub/Sub o los cambios de objeto de Storage.

Puedes ejecutar estas pruebas de manera local con un corrector de compatibilidad. Valida el comportamiento de la función mediante la confirmación del resultado esperado, de acuerdo con las entradas específicas.

Pruebas del sistema

Las pruebas del sistema son más complejas, ya que validan el comportamiento de tu función de Cloud Functions a través de varios componentes de GCP en un entorno de pruebas aislado.

Implementa tu función de Cloud Functions en un entorno de pruebas y evalúa su funcionalidad mediante la activación de eventos relevantes. Para validar tu función, lee los registros o revisa el comportamiento deseado.

Debes aislar tus entornos de desarrollo, pruebas y producción. Una forma de lograrlo es usar un proyecto de GCP individual para cada paso.

También debes asignar nombres únicos a nivel global de recursos de prueba de sistema para evitar que pruebas simultáneas interfieran entre sí. Puedes hacerlo mediante la creación y eliminación de manera programática de los recursos requeridos antes y después de la ejecución de la prueba.

Ejemplos de situaciones de prueba

Las situaciones que se presentan a continuación abarcan las diferentes formas de activar Cloud Functions. La estructura de las pruebas de una función depende en gran medida de los recursos de GCP que esta usa. A su vez, el uso de los recursos de una función depende de cómo se activa esa función.

Funciones activadas por HTTP

A diferencia de los demás tipos de funciones, las pruebas del sistema y de integración para las funciones activadas por HTTP son similares en estructura, pero la mayoría de las pruebas de unidades de funciones de HTTP tienen una estructura diferente.

Esta coincidencia entre las pruebas de sistema y de integración se muestra en el siguiente ejemplo de una función activada por HTTP:

Node.js

const escapeHtml = require('escape-html');

/**
 * HTTP Cloud Function.
 *
 * @param {Object} req Cloud Function request context.
 *                     More info: https://expressjs.com/en/api.html#req
 * @param {Object} res Cloud Function response context.
 *                     More info: https://expressjs.com/en/api.html#res
 */
exports.helloHttp = (req, res) => {
  res.send(`Hello ${escapeHtml(req.query.name || req.body.name || 'World')}!`);
};

Python

from flask import escape

def hello_http(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): The request object.
        <http://flask.pocoo.org/docs/1.0/api/#flask.Request>
    Returns:
        The response text, or any set of values that can be turned into a
        Response object using `make_response`
        <http://flask.pocoo.org/docs/1.0/api/#flask.Flask.make_response>.
    """
    request_json = request.get_json(silent=True)
    request_args = request.args

    if request_json and 'name' in request_json:
        name = request_json['name']
    elif request_args and 'name' in request_args:
        name = request_args['name']
    else:
        name = 'World'
    return 'Hello {}!'.format(escape(name))

Go


// Package helloworld provides a set of Cloud Functions samples.
package helloworld

import (
	"encoding/json"
	"fmt"
	"html"
	"net/http"
)

// HelloHTTP is an HTTP Cloud Function with a request parameter.
func HelloHTTP(w http.ResponseWriter, r *http.Request) {
	var d struct {
		Name string `json:"name"`
	}
	if err := json.NewDecoder(r.Body).Decode(&d); err != nil {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	if d.Name == "" {
		fmt.Fprint(w, "Hello, World!")
		return
	}
	fmt.Fprintf(w, "Hello, %s!", html.EscapeString(d.Name))
}

Pruebas de unidad

Estas pruebas actúan como pruebas de unidad para la función activada por HTTP anterior.

Node.js

Express se simula con Sinon.
const assert = require('assert');
const sinon = require('sinon');
const uuid = require('uuid');

const {helloHttp} = require('..');

it('helloHttp: should print a name', () => {
  // Mock ExpressJS 'req' and 'res' parameters
  const name = uuid.v4();
  const req = {
    body: {
      name: name,
    },
  };
  const res = {send: sinon.stub()};

  // Call tested function
  helloHttp(req, res);

  // Verify behavior of tested function
  assert.ok(res.send.calledOnce);
  assert.deepStrictEqual(res.send.firstCall.args, [`Hello ${name}!`]);
});

it('helloHttp: should print hello world', () => {
  // Mock ExpressJS 'req' and 'res' parameters
  const req = {
    body: {},
  };
  const res = {send: sinon.stub()};

  // Call tested function
  helloHttp(req, res);

  // Verify behavior of tested function
  assert.ok(res.send.calledOnce);
  assert.deepStrictEqual(res.send.firstCall.args, ['Hello World!']);
});

Python

Flask se simula con unittest.
from unittest.mock import Mock

import main

def test_print_name():
    name = 'test'
    data = {'name': name}
    req = Mock(get_json=Mock(return_value=data), args=data)

    # Call tested function
    assert main.hello_http(req) == 'Hello {}!'.format(name)

def test_print_hello_world():
    data = {}
    req = Mock(get_json=Mock(return_value=data), args=data)

    # Call tested function
    assert main.hello_http(req) == 'Hello World!'

Go


package helloworld

import (
	"io/ioutil"
	"net/http/httptest"
	"strings"
	"testing"
)

func TestHelloHTTP(t *testing.T) {
	tests := []struct {
		body string
		want string
	}{
		{body: `{"name": ""}`, want: "Hello, World!"},
		{body: `{"name": "Gopher"}`, want: "Hello, Gopher!"},
	}

	for _, test := range tests {
		req := httptest.NewRequest("GET", "/", strings.NewReader(test.body))
		req.Header.Add("Content-Type", "application/json")

		rr := httptest.NewRecorder()
		HelloHTTP(rr, req)

		out, err := ioutil.ReadAll(rr.Result().Body)
		if err != nil {
			t.Fatalf("ReadAll: %v", err)
		}
		if got := string(out); got != test.want {
			t.Errorf("HelloHTTP(%q) = %q, want %q", test.body, got, test.want)
		}
	}
}

Usa el siguiente comando para ejecutar las pruebas de unidad:

Node.js

mocha test/sample.unit.http.test.js --exit

Python

pytest sample_http_test.py

Go

go test -v ./hello_http_test.go

Pruebas de integración

Estas pruebas actúan como pruebas de integración para la función anterior:

Node.js

const assert = require('assert');
const Supertest = require('supertest');
const supertest = Supertest(process.env.BASE_URL);

it('helloHttp: should print a name', async () => {
  await supertest
    .post('/helloHttp')
    .send({name: 'John'})
    .expect(200)
    .expect(response => {
      assert.strictEqual(response.text, 'Hello John!');
    });
});

it('helloHttp: should print hello world', async () => {
  await supertest
    .get('/helloHttp')
    .expect(200)
    .expect(response => {
      assert.strictEqual(response.text, 'Hello World!');
    });
});

Para ejecutar las pruebas de integración para las funciones de HTTP, usa el siguiente comando:

Node.js

export BASE_URL=http://localhost:8010/YOUR_GCP_PROJECT_ID/YOUR_GCF_REGION
mocha test/sample.integration.http.test.js --exit

donde:

  • YOUR_GCP_PROJECT_ID es el ID del proyecto de GCP.
  • YOUR_GCF_REGION es la región de tus funciones de Cloud Functions.
  • BASE_URL es una variable de entorno que especifica la URL en la que se puede alcanzar la función. Las variables de entorno te permiten especificar valores disponibles solo en tu entorno de pruebas local. Esto te permite evitar codificar estos valores en tu código.

Pruebas del sistema

Estas pruebas actúan como pruebas de sistema para la función anterior:

Node.js

Ten en cuenta que las pruebas del sistema son idénticas a las pruebas de integración de la función.
const assert = require('assert');
const Supertest = require('supertest');
const supertest = Supertest(process.env.BASE_URL);

it('helloHttp: should print a name', async () => {
  await supertest
    .post('/helloHttp')
    .send({name: 'John'})
    .expect(200)
    .expect(response => {
      assert.strictEqual(response.text, 'Hello John!');
    });
});

it('helloHttp: should print hello world', async () => {
  await supertest
    .get('/helloHttp')
    .expect(200)
    .expect(response => {
      assert.strictEqual(response.text, 'Hello World!');
    });
});

Python

import os
import uuid

import requests

def test_no_args():
    BASE_URL = os.getenv('BASE_URL')
    assert BASE_URL is not None

    res = requests.get('{}/hello_http'.format(BASE_URL))
    assert res.text == 'Hello, World!'

def test_args():
    BASE_URL = os.getenv('BASE_URL')
    assert BASE_URL is not None

    name = str(uuid.uuid4())
    res = requests.post(
      '{}/hello_http'.format(BASE_URL),
      json={'name': name}
    )
    assert res.text == 'Hello, {}!'.format(name)

Go


package helloworld

import (
	"io/ioutil"
	"net/http"
	"net/url"
	"os"
	"strings"
	"testing"
	"time"
)

func TestHelloHTTPSystem(t *testing.T) {
	client := http.Client{
		Timeout: 10 * time.Second,
	}
	urlString := os.Getenv("BASE_URL") + "/HelloHTTP"
	testURL, err := url.Parse(urlString)
	if err != nil {
		t.Fatalf("url.Parse(%q): %v", urlString, err)
	}

	tests := []struct {
		body string
		want string
	}{
		{body: `{"name": ""}`, want: "Hello, World!"},
		{body: `{"name": "Gopher"}`, want: "Hello, Gopher!"},
	}

	for _, test := range tests {
		req := &http.Request{
			Method: http.MethodPost,
			Body:   ioutil.NopCloser(strings.NewReader(test.body)),
			URL:    testURL,
		}
		resp, err := client.Do(req)
		if err != nil {
			t.Fatalf("HelloHTTP http.Get: %v", err)
		}
		body, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			t.Fatalf("HelloHTTP ioutil.ReadAll: %v", err)
		}
		if got := string(body); got != test.want {
			t.Errorf("HelloHTTP(%q) = %q, want %q", test.body, got, test.want)
		}
	}
}

A fin de ejecutar pruebas del sistema para funciones de HTTP, implementa tus funciones con el siguiente comando:

Node.js 8

gcloud functions deploy helloHttp --runtime nodejs8 

Node.js 10 (Beta)

gcloud functions deploy helloHttp --runtime nodejs10 

Node.js 6 (obsoleto)

gcloud functions deploy helloHttp --runtime nodejs6 

Python

gcloud functions deploy hello_http --runtime python37 

Go

gcloud functions deploy HelloHTTP --runtime go111 

Usa los siguientes comandos para probar la función de HTTP implementada:

Node.js

Ten en cuenta que la diferencia principal entre las pruebas del sistema y las de integración para funciones de HTTP de Cloud Functions es la URL en la que se puede alcanzar la función.

export BASE_URL=https://YOUR_GCF_REGION-YOUR_GCP_PROJECT_ID.cloudfunctions.net/
mocha test/sample.system.http.test.js --exit

Python

export BASE_URL=https://YOUR_GCF_REGION-YOUR_GCP_PROJECT_ID.cloudfunctions.net/
pytest sample_http_test_system.py

Go

export BASE_URL=https://YOUR_GCF_REGION-YOUR_GCP_PROJECT_ID.cloudfunctions.net/
go test -v ./hello_http_system_test.go

donde:

  • YOUR_GCF_REGION es la región de tus funciones de Cloud Functions.
  • YOUR_GCP_PROJECT_ID es el ID del proyecto de GCP.

Funciones activadas por Pub/Sub

Las pruebas de las funciones activadas por Pub/Sub se estructuran de forma diferente según el lugar donde resida la función que se prueba.

Este es un ejemplo de una función activada por Pub/Sub:

Node.js 8/10

/**
 * Background Cloud Function to be triggered by Pub/Sub.
 * This function is exported by index.js, and executed when
 * the trigger topic receives a message.
 *
 * @param {object} pubSubEvent The event payload.
 * @param {object} context The event metadata.
 */
exports.helloPubSub = (pubSubEvent, context) => {
  const name = pubSubEvent.data
    ? Buffer.from(pubSubEvent.data, 'base64').toString()
    : 'World';

  console.log(`Hello, ${name}!`);
};

Node.js 6 (obsoleto)

/**
 * Background Cloud Function to be triggered by Pub/Sub.
 * This function is exported by index.js, and executed when
 * the trigger topic receives a message.
 *
 * @param {object} event The Cloud Functions event.
 * @param {function} callback The callback function.
 */
exports.helloPubSub = (event, callback) => {
  const pubsubMessage = event.data;
  const name = pubsubMessage.data
    ? Buffer.from(pubsubMessage.data, 'base64').toString()
    : 'World';

  console.log(`Hello, ${name}!`);

  callback();
};

Python

def hello_pubsub(event, context):
    """Background Cloud Function to be triggered by Pub/Sub.
    Args:
         event (dict):  The dictionary with data specific to this type of
         event. The `data` field contains the PubsubMessage message. The
         `attributes` field will contain custom attributes if there are any.
         context (google.cloud.functions.Context): The Cloud Functions event
         metadata. The `event_id` field contains the Pub/Sub message ID. The
         `timestamp` field contains the publish time.
    """
    import base64

    print("""This Function was triggered by messageId {} published at {}
    """.format(context.event_id, context.timestamp))

    if 'data' in event:
        name = base64.b64decode(event['data']).decode('utf-8')
    else:
        name = 'World'
    print('Hello {}!'.format(name))

Go


// Package helloworld provides a set of Cloud Functions samples.
package helloworld

import (
	"context"
	"log"
)

// PubSubMessage is the payload of a Pub/Sub event.
type PubSubMessage struct {
	Data []byte `json:"data"`
}

// HelloPubSub consumes a Pub/Sub message.
func HelloPubSub(ctx context.Context, m PubSubMessage) error {
	name := string(m.Data)
	if name == "" {
		name = "World"
	}
	log.Printf("Hello, %s!", name)
	return nil
}

Pruebas de unidad

Estas pruebas actúan como pruebas de unidades para la función activada por Pub/Sub anterior:

Node.js 8/10

const assert = require('assert');
const uuid = require('uuid');
const utils = require('@google-cloud/nodejs-repo-tools');

const {helloPubSub} = require('..');

beforeEach(utils.stubConsole);
afterEach(utils.restoreConsole);

it('helloPubSub: should print a name', async () => {
  // Initialize mocks
  const name = uuid.v4();
  const event = {
    data: Buffer.from(name).toString('base64'),
  };

  // Call tested function and verify its behavior
  await helloPubSub(event);
  assert.strictEqual(console.log.calledWith(`Hello, ${name}!`), true);
});

it('helloPubSub: should print hello world', async () => {
  // Initialize mocks
  const event = {};

  // Call tested function and verify its behavior
  await helloPubSub(event);
  assert.strictEqual(console.log.calledWith('Hello, World!'), true);
});

Node.js 6 (obsoleto)

const assert = require('assert');
const uuid = require('uuid');
const utils = require('@google-cloud/nodejs-repo-tools');

const helloPubSub = require('..').helloPubSub;

beforeEach(utils.stubConsole);
afterEach(utils.restoreConsole);

it('helloPubSub: should print a name', done => {
  // Initialize mocks
  const name = uuid.v4();
  const event = {
    data: {
      data: Buffer.from(name).toString('base64'),
    },
  };

  // Call tested function and verify its behavior
  helloPubSub(event, () => {
    assert.ok(console.log.calledWith(`Hello, ${name}!`));
    done();
  });
});

it('helloPubSub: should print hello world', done => {
  // Initialize mocks
  const event = {
    data: {},
  };

  // Call tested function and verify its behavior
  helloPubSub(event, () => {
    assert.ok(console.log.calledWith('Hello, World!'));
    done();
  });
});

Python

import base64
import mock

import main

mock_context = mock.Mock()
mock_context.event_id = '617187464135194'
mock_context.timestamp = '2019-07-15T22:09:03.761Z'

def test_print_hello_world(capsys):
    data = {}

    # Call tested function
    main.hello_pubsub(data, mock_context)
    out, err = capsys.readouterr()
    assert 'Hello World!' in out

def test_print_name(capsys):
    name = 'test'
    data = {'data': base64.b64encode(name.encode())}

    # Call tested function
    main.hello_pubsub(data, mock_context)
    out, err = capsys.readouterr()
    assert 'Hello {}!\n'.format(name) in out

Go


package helloworld

import (
	"context"
	"io/ioutil"
	"log"
	"os"
	"testing"
)

func TestHelloPubSub(t *testing.T) {
	tests := []struct {
		data string
		want string
	}{
		{want: "Hello, World!\n"},
		{data: "Go", want: "Hello, Go!\n"},
	}
	for _, test := range tests {
		r, w, _ := os.Pipe()
		log.SetOutput(w)
		originalFlags := log.Flags()
		log.SetFlags(log.Flags() &^ (log.Ldate | log.Ltime))

		m := PubSubMessage{
			Data: []byte(test.data),
		}
		HelloPubSub(context.Background(), m)

		w.Close()
		log.SetOutput(os.Stderr)
		log.SetFlags(originalFlags)

		out, err := ioutil.ReadAll(r)
		if err != nil {
			t.Fatalf("ReadAll: %v", err)
		}
		if got := string(out); got != test.want {
			t.Errorf("HelloPubSub(%q) = %q, want %q", test.data, got, test.want)
		}
	}
}

Usa el siguiente comando para ejecutar las pruebas de unidad:

Node.js

mocha test/sample.unit.pubsub.test.js --exit

Python

pytest sample_pubsub_test.py

Go

go test -v ./hello_pubsub_test.go

Pruebas de integración

Estas pruebas actúan como pruebas de integración para la función activada por Pub/Sub anterior:

Node.js

const childProcess = require('child_process');
const assert = require('assert');
const uuid = require('uuid');

it('helloPubSub: should print a name', done => {
  const startTime = new Date(Date.now()).toISOString();
  const name = uuid.v4();

  // Mock Pub/Sub call, as the emulator doesn't listen to Pub/Sub topics
  const encodedName = Buffer.from(name).toString('base64');
  const data = JSON.stringify({data: encodedName});
  childProcess.execSync(`functions call helloPubSub --data ${data}`);

  // Check the emulator's logs
  const logs = childProcess
    .execSync(`functions logs read helloPubSub --start-time ${startTime}`)
    .toString();
  assert.strictEqual(logs.includes(`Hello, ${name}!`), true);
  done();
});

it('helloPubSub: should print hello world', done => {
  const startTime = new Date(Date.now()).toISOString();

  // Mock Pub/Sub call, as the emulator doesn't listen to Pub/Sub topics
  childProcess.execSync('functions call helloPubSub --data {}');

  // Check the emulator's logs
  const logs = childProcess
    .execSync(`functions logs read helloPubSub --start-time ${startTime}`)
    .toString();
  assert.strictEqual(logs.includes('Hello, World!'), true);
  done();
});

A fin de ejecutar las pruebas de integración para esta función, completa los siguientes pasos:

Node.js

Para ejecutar la prueba, usa el siguiente comando:

mocha test/sample.integration.pubsub.test.js --exit

Pruebas del sistema

Estas pruebas actúan como pruebas del sistema para esta función:

Node.js

const childProcess = require('child_process');
const assert = require('assert');
const uuid = require('uuid');
const {PubSub} = require('@google-cloud/pubsub');
const pubsub = new PubSub();

process.env.FUNCTIONS_TOPIC =
  'projects/grass-clump-479/topics/gcloud-logging-test0165b071-1325-11e9-bc58-d3b6d1def78e';
const topicName = process.env.FUNCTIONS_TOPIC;
const baseCmd = 'gcloud functions';

it('helloPubSub: should print a name', async () => {
  const startTime = new Date(Date.now()).toISOString();
  const name = uuid.v4();

  // Publish to pub/sub topic
  const topic = pubsub.topic(topicName);
  const publisher = topic.publisher();
  await publisher.publish(Buffer.from(name));

  // Wait for logs to become consistent
  await new Promise(resolve => setTimeout(resolve, 15000));

  // Check logs after a delay
  const logs = childProcess
    .execSync(`${baseCmd} logs read helloPubSub --start-time ${startTime}`)
    .toString();
  assert.ok(logs.includes(`Hello, ${name}!`));
});

it('helloPubSub: should print hello world', async () => {
  const startTime = new Date(Date.now()).toISOString();

  // Publish to pub/sub topic
  const topic = pubsub.topic(topicName);
  const publisher = topic.publisher();
  await publisher.publish(Buffer.from(''), {a: 'b'});

  // Wait for logs to become consistent
  await new Promise(resolve => setTimeout(resolve, 15000));

  // Check logs after a delay
  const logs = childProcess
    .execSync(`${baseCmd} logs read helloPubSub --start-time ${startTime}`)
    .toString();
  assert.ok(logs.includes('Hello, World!'));
});

Python

from datetime import datetime
from os import getenv
import subprocess
import time
import uuid

from google.cloud import pubsub_v1
import pytest

PROJECT = getenv('GCP_PROJECT')
TOPIC = getenv('TOPIC')

assert PROJECT is not None
assert TOPIC is not None

@pytest.fixture(scope='module')
def publisher_client():
    yield pubsub_v1.PublisherClient()

def test_print_name(publisher_client):
    start_time = datetime.utcnow().isoformat()
    topic_path = publisher_client.topic_path(PROJECT, TOPIC)

    # Publish the message
    name = uuid.uuid4()
    data = str(name).encode('utf-8')
    publisher_client.publish(topic_path, data=data).result()

    # Wait for logs to become consistent
    time.sleep(15)

    # Check logs after a delay
    log_process = subprocess.Popen([
        'gcloud',
        'alpha',
        'functions',
        'logs',
        'read',
        'hello_pubsub',
        '--start-time',
        start_time
    ], stdout=subprocess.PIPE)
    logs = str(log_process.communicate()[0])
    assert 'Hello {}!'.format(name) in logs

Go


package helloworld

import (
	"context"
	"log"
	"os"
	"os/exec"
	"strings"
	"testing"
	"time"

	"cloud.google.com/go/pubsub"
	"github.com/gobuffalo/uuid"
)

func TestHelloPubSubSystem(t *testing.T) {
	ctx := context.Background()

	topicName := os.Getenv("FUNCTIONS_TOPIC")
	projectID := os.Getenv("GCP_PROJECT")

	startTime := time.Now().UTC().Format(time.RFC3339)

	// Create the Pub/Sub client and topic.
	client, err := pubsub.NewClient(ctx, projectID)
	if err != nil {
		log.Fatal(err)
	}
	topic := client.Topic(topicName)

	// Publish a message with a random string to verify.
	// We use a random string to make sure the function is logging the correct
	// message for this test invocation.
	u := uuid.Must(uuid.NewV4())
	msg := &pubsub.Message{
		Data: []byte(u.String()),
	}
	topic.Publish(ctx, msg).Get(ctx)

	// Wait for logs to be consistent.
	time.Sleep(20 * time.Second)

	// Check logs after a delay.
	cmd := exec.Command("gcloud", "alpha", "functions", "logs", "read", "HelloPubSub", "--start-time", startTime)
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("exec.Command: %v", err)
	}
	if got := string(out); !strings.Contains(got, u.String()) {
		t.Errorf("HelloPubSub got %q, want to contain %q", got, u.String())
	}
}

Sigue estos pasos para ejecutar las pruebas de sistema:

  1. En tu proyecto de GCP, selecciona un tema de Cloud Pub/Sub al cual suscribir la función. Si proporcionas el nombre de un tema de Cloud Pub/Sub que no existe, este se crea automáticamente.

  2. A continuación, implementa tus funciones con el siguiente comando:

    Node.js 8

    gcloud functions deploy helloPubSub --runtime nodejs8 --trigger-topic YOUR_PUBSUB_TOPIC

    Node.js 10 (Beta)

    gcloud functions deploy helloPubSub --runtime nodejs10 --trigger-topic YOUR_PUBSUB_TOPIC

    Node.js 6 (obsoleto)

    gcloud functions deploy helloPubSub --runtime nodejs6 --trigger-topic YOUR_PUBSUB_TOPIC

    Python

    gcloud functions deploy hello_pubsub --runtime python37 --trigger-topic YOUR_PUBSUB_TOPIC

    Go

    gcloud functions deploy HelloPubSub --runtime go111 --trigger-topic YOUR_PUBSUB_TOPIC

    donde YOUR_PUBSUB_TOPIC es el nombre del tema de Cloud Pub/Sub al que quieres que se suscriban tus funciones.

  3. Ejecuta las pruebas del sistema con el siguiente comando:

    Node.js

    export FUNCTIONS_TOPIC=YOUR_PUBSUB_TOPIC
    mocha test/sample.system.pubsub.test.js --exit
    

    Python

    export FUNCTIONS_TOPIC=YOUR_PUBSUB_TOPIC
    pytest sample_pubsub_test_system.py
    

    Go

    export FUNCTIONS_TOPIC=YOUR_PUBSUB_TOPIC
    go test -v ./hello_pubsub_system_test.go
    

    donde YOUR_PUBSUB_TOPIC es el nombre del tema de Cloud Pub/Sub al que quieres que se suscriban tus funciones.

Funciones activadas por Storage

Las pruebas para las funciones activadas por Storage son similares en estructura a sus contrapartes activadas por Cloud Pub/Sub. Al igual que las pruebas de las funciones activadas por Cloud Pub/Sub, las pruebas de las funciones activadas por Storage se estructuran de forma diferente según el lugar donde se aloja la función que se prueba.

Aquí te mostramos un ejemplo de una función activada por Storage:

Node.js 8/10

/**
 * Background Cloud Function to be triggered by Cloud Storage.
 *
 * @param {object} data The event payload.
 * @param {object} context The event metadata.
 */
exports.helloGCS = (data, context) => {
  const file = data;
  if (file.resourceState === 'not_exists') {
    console.log(`File ${file.name} deleted.`);
  } else if (file.metageneration === '1') {
    // metageneration attribute is updated on metadata changes.
    // on create value is 1
    console.log(`File ${file.name} uploaded.`);
  } else {
    console.log(`File ${file.name} metadata updated.`);
  }
};

Node.js 6 (obsoleto)

/**
 * Background Cloud Function to be triggered by Cloud Storage.
 *
 * @param {object} event The Cloud Functions event.
 * @param {function} callback The callback function.
 */
exports.helloGCS = (event, callback) => {
  const file = event.data;

  if (file.resourceState === 'not_exists') {
    console.log(`File ${file.name} deleted.`);
  } else if (file.metageneration === '1') {
    // metageneration attribute is updated on metadata changes.
    // value is 1 if file was newly created or overwritten
    console.log(`File ${file.name} uploaded.`);
  } else {
    console.log(`File ${file.name} metadata updated.`);
  }

  callback();
};

Python

def hello_gcs(data, context):
    """Background Cloud Function to be triggered by Cloud Storage.
    Args:
         data (dict): The dictionary with data specific to this type of event.
         context (google.cloud.functions.Context): The Cloud Functions
         event metadata.
    """
    print("File: {}.".format(data['objectId']))

Go


// Package helloworld provides a set of Cloud Functions samples.
package helloworld

import (
	"context"
	"log"
)

// GCSEvent is the payload of a GCS event.
type GCSEvent struct {
	Bucket         string `json:"bucket"`
	Name           string `json:"name"`
	Metageneration string `json:"metageneration"`
	ResourceState  string `json:"resourceState"`
}

// HelloGCS consumes a GCS event.
func HelloGCS(ctx context.Context, e GCSEvent) error {
	if e.ResourceState == "not_exists" {
		log.Printf("File %v deleted.", e.Name)
		return nil
	}
	if e.Metageneration == "1" {
		// The metageneration attribute is updated on metadata changes.
		// The on create value is 1.
		log.Printf("File %v created.", e.Name)
		return nil
	}
	log.Printf("File %v metadata updated.", e.Name)
	return nil
}

Pruebas de unidad

Estas son las pruebas de unidades para la función activada por Storage anterior:

Node.js 8/10

const assert = require('assert');
const uuid = require('uuid');
const utils = require('@google-cloud/nodejs-repo-tools');

const {helloGCS} = require('..');

beforeEach(utils.stubConsole);
afterEach(utils.restoreConsole);

it('helloGCS: should print uploaded message', async () => {
  // Initialize mocks
  const filename = uuid.v4();
  const event = {
    name: filename,
    resourceState: 'exists',
    metageneration: '1',
  };

  // Call tested function and verify its behavior
  await helloGCS(event);
  assert.strictEqual(
    console.log.calledWith(`File ${filename} uploaded.`),
    true
  );
});

it('helloGCS: should print metadata updated message', async () => {
  // Initialize mocks
  const filename = uuid.v4();
  const event = {
    name: filename,
    resourceState: 'exists',
    metageneration: '2',
  };

  // Call tested function and verify its behavior
  await helloGCS(event);
  assert.strictEqual(
    console.log.calledWith(`File ${filename} metadata updated.`),
    true
  );
});

it('helloGCS: should print deleted message', async () => {
  // Initialize mocks
  const filename = uuid.v4();
  const event = {
    name: filename,
    resourceState: 'not_exists',
    metageneration: '3',
  };

  // Call tested function and verify its behavior
  await helloGCS(event);
  assert.strictEqual(console.log.calledWith(`File ${filename} deleted.`), true);
});

Node.js 6 (obsoleto)

const assert = require('assert');
const uuid = require('uuid');
const utils = require('@google-cloud/nodejs-repo-tools');

const {helloGCS} = require('..');

beforeEach(utils.stubConsole);
afterEach(utils.restoreConsole);

it('helloGCS: should print uploaded message', done => {
  // Initialize mocks
  const filename = uuid.v4();
  const event = {
    data: {
      name: filename,
      resourceState: 'exists',
      metageneration: '1',
    },
  };

  // Call tested function and verify its behavior
  helloGCS(event, () => {
    assert.ok(console.log.calledWith(`File ${filename} uploaded.`));
    done();
  });
});

it('helloGCS: should print metadata updated message', done => {
  // Initialize mocks
  const filename = uuid.v4();
  const event = {
    data: {
      name: filename,
      resourceState: 'exists',
      metageneration: '2',
    },
  };

  // Call tested function and verify its behavior
  helloGCS(event, () => {
    assert.ok(console.log.calledWith(`File ${filename} metadata updated.`));
    done();
  });
});

it('helloGCS: should print deleted message', done => {
  // Initialize mocks
  const filename = uuid.v4();
  const event = {
    data: {
      name: filename,
      resourceState: 'not_exists',
      metageneration: '3',
    },
  };

  // Call tested function and verify its behavior
  helloGCS(event, () => {
    assert.ok(console.log.calledWith(`File ${filename} deleted.`));
    done();
  });
});

Python

import main

def test_print(capsys):
    name = 'test'
    data = {'objectId': name}

    # Call tested function
    main.hello_gcs(data, None)
    out, err = capsys.readouterr()
    assert out == 'File: {}.\n'.format(name)

Go


package helloworld

import (
	"context"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"testing"
)

func TestHelloGCS(t *testing.T) {
	name := "hello_gcs.txt"
	tests := []struct {
		resourceState  string
		metageneration string
		want           string
	}{
		{
			resourceState: "not_exists",
			want:          fmt.Sprintf("File %s deleted.\n", name),
		},
		{
			metageneration: "1",
			want:           fmt.Sprintf("File %s created.\n", name),
		},
		{
			want: fmt.Sprintf("File %s metadata updated.\n", name),
		},
	}

	for _, test := range tests {
		r, w, _ := os.Pipe()
		log.SetOutput(w)
		originalFlags := log.Flags()
		log.SetFlags(log.Flags() &^ (log.Ldate | log.Ltime))

		e := GCSEvent{
			Name:           name,
			ResourceState:  test.resourceState,
			Metageneration: test.metageneration,
		}
		HelloGCS(context.Background(), e)

		w.Close()
		log.SetOutput(os.Stderr)
		log.SetFlags(originalFlags)

		out, err := ioutil.ReadAll(r)
		if err != nil {
			t.Fatalf("ReadAll: %v", err)
		}

		if got := string(out); got != test.want {
			t.Errorf("HelloGCS(%+v) = %q, want %q", e, got, test.want)
		}
	}
}

Usa el siguiente comando para ejecutar las pruebas de unidad:

Node.js

mocha test/sample.unit.storage.test.js --exit

Python

pytest sample_storage_test.py

Go

go test -v ./hello_cloud_storage_test.go

Pruebas de integración

Estas son las pruebas de integración para la función activada por Storage anterior:

Node.js

const childProcess = require('child_process');
const assert = require('assert');
const uuid = require('uuid');

it('helloGCS: should print uploaded message', done => {
  const startTime = new Date(Date.now()).toISOString();
  const filename = uuid.v4(); // Use a unique filename to avoid conflicts

  // Mock GCS call, as the emulator doesn't listen to GCS buckets
  const data = JSON.stringify({
    name: filename,
    resourceState: 'exists',
    metageneration: '1',
  });

  childProcess.execSync(`functions-emulator call helloGCS --data '${data}'`);

  // Check the emulator's logs
  const logs = childProcess
    .execSync(`functions-emulator logs read helloGCS --start-time ${startTime}`)
    .toString();
  assert.ok(logs.includes(`File ${filename} uploaded.`));
  done();
});

it('helloGCS: should print metadata updated message', done => {
  const startTime = new Date(Date.now()).toISOString();
  const filename = uuid.v4(); // Use a unique filename to avoid conflicts

  // Mock GCS call, as the emulator doesn't listen to GCS buckets
  const data = JSON.stringify({
    name: filename,
    resourceState: 'exists',
    metageneration: '2',
  });

  childProcess.execSync(`functions-emulator call helloGCS --data '${data}'`);

  // Check the emulator's logs
  const logs = childProcess
    .execSync(`functions-emulator logs read helloGCS --start-time ${startTime}`)
    .toString();
  assert.ok(logs.includes(`File ${filename} metadata updated.`));
  done();
});

it('helloGCS: should print deleted message', done => {
  const startTime = new Date(Date.now()).toISOString();
  const filename = uuid.v4(); // Use a unique filename to avoid conflicts

  // Mock GCS call, as the emulator doesn't listen to GCS buckets
  const data = JSON.stringify({
    name: filename,
    resourceState: 'not_exists',
    metageneration: '3',
  });

  childProcess.execSync(`functions-emulator call helloGCS --data '${data}'`);

  // Check the emulator's logs
  const logs = childProcess
    .execSync(`functions-emulator logs read helloGCS --start-time ${startTime}`)
    .toString();
  assert.ok(logs.includes(`File ${filename} deleted.`));
});

Usa el siguiente comando para ejecutar las pruebas de integración:

Node.js

mocha test/sample.integration.storage.test.js --exit

Pruebas del sistema

Estas son las pruebas de sistema para la función activada por Storage anterior:

Node.js

const {Storage} = require('@google-cloud/storage');
const storage = new Storage();
const uuid = require('uuid');
const assert = require('assert');
const path = require('path');
const childProcess = require('child_process');
const localFileName = 'test.txt';

// Use unique GCS filename to avoid conflicts between concurrent test runs
const gcsFileName = `test-${uuid.v4()}.txt`;

const bucketName = process.env.FUNCTIONS_BUCKET;
const bucket = storage.bucket(bucketName);
const baseCmd = 'gcloud functions';

it('helloGCS: should print uploaded message', async () => {
  const startTime = new Date(Date.now()).toISOString();

  // Upload file
  const filepath = path.join(__dirname, localFileName);
  await bucket.upload(filepath, {
    destination: gcsFileName,
  });

  // Wait for consistency
  await new Promise(resolve => setTimeout(resolve, 15000));

  // Check logs
  const logs = childProcess
    .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
    .toString();
  assert.ok(logs.includes(`File ${gcsFileName} uploaded`));
});

it('helloGCS: should print metadata updated message', async () => {
  const startTime = new Date(Date.now()).toISOString();

  // Update file metadata
  const file = bucket.file(gcsFileName);
  await file.setMetadata(gcsFileName, {foo: 'bar'});

  // Wait for consistency
  await new Promise(resolve => setTimeout(resolve, 15000));

  // Check logs
  const logs = childProcess
    .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
    .toString();
  assert.strictEqual(logs.ok(`File ${gcsFileName} metadata updated`));
});

it('helloGCS: should print deleted message', async () => {
  const startTime = new Date(Date.now()).toISOString();

  // Delete file
  bucket.deleteFiles();

  // Wait for consistency
  await new Promise(resolve => setTimeout(resolve, 15000));

  // Check logs
  const logs = childProcess
    .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
    .toString();
  assert.ok(logs.includes(`File ${gcsFileName} deleted`));
});

Python

from datetime import datetime
from os import getenv, path
import subprocess
import time
import uuid

from google.cloud import storage
import pytest

PROJECT = getenv('GCP_PROJECT')
BUCKET = getenv('BUCKET')

assert PROJECT is not None
assert BUCKET is not None

@pytest.fixture(scope='module')
def storage_client():
    yield storage.Client()

@pytest.fixture(scope='module')
def bucket_object(storage_client):
    bucket_object = storage_client.get_bucket(BUCKET)
    yield bucket_object

@pytest.fixture(scope='module')
def uploaded_file(bucket_object):
    name = 'test-{}.txt'.format(str(uuid.uuid4()))
    blob = bucket_object.blob(name)

    test_dir = path.dirname(path.abspath(__file__))
    blob.upload_from_filename(path.join(test_dir, 'test.txt'))
    yield name
    blob.delete()

def test_hello_gcs(uploaded_file):
    start_time = datetime.utcnow().isoformat()
    time.sleep(10)  # Wait for logs to become consistent

    log_process = subprocess.Popen([
        'gcloud',
        'alpha',
        'functions',
        'logs',
        'read',
        'hello_gcs',
        '--start-time',
        start_time
    ], stdout=subprocess.PIPE)
    logs = str(log_process.communicate()[0])
    assert uploaded_file in logs

Go


package helloworld

import (
	"context"
	"fmt"
	"os"
	"os/exec"
	"strings"
	"testing"
	"time"

	"cloud.google.com/go/storage"
)

func TestHelloGCSSystem(t *testing.T) {
	ctx := context.Background()
	bucketName := os.Getenv("BUCKET_NAME")

	client, err := storage.NewClient(ctx)
	if err != nil {
		t.Fatalf("storage.NewClient: %v", err)
	}

	// Create a file.
	startTime := time.Now().UTC().Format(time.RFC3339)
	oh := client.Bucket(bucketName).Object("TestHelloGCSSystem")
	w := oh.NewWriter(ctx)
	fmt.Fprintf(w, "Content of the file")
	w.Close()

	// Wait for logs to be consistent.
	time.Sleep(20 * time.Second)

	// Check logs.
	want := "created"
	if got := readLogs(t, startTime); !strings.Contains(got, want) {
		t.Errorf("HelloGCS logged %q, want to contain %q", got, want)
	}

	// Modify the file.
	startTime = time.Now().UTC().Format(time.RFC3339)
	_, err = oh.Update(ctx, storage.ObjectAttrsToUpdate{
		Metadata: map[string]string{"Content-Type": "text/html"},
	})
	if err != nil {
		t.Errorf("Update: %v", err)
	}

	// Wait for logs to be consistent.
	time.Sleep(20 * time.Second)

	// Check logs.
	want = "updated"
	if got := readLogs(t, startTime); !strings.Contains(got, want) {
		t.Errorf("HelloGCS logged %q, want to contain %q", got, want)
	}

	// Delete the file.
	startTime = time.Now().UTC().Format(time.RFC3339)
	if err := oh.Delete(ctx); err != nil {
		t.Errorf("Delete: %v", err)
	}

	// Wait for logs to be consistent.
	time.Sleep(20 * time.Second)

	// Check logs.
	want = "deleted"
	if got := readLogs(t, startTime); !strings.Contains(got, want) {
		t.Errorf("HelloGCS logged %q, want to contain %q", got, want)
	}
}

func readLogs(t *testing.T, startTime string) string {
	t.Helper()
	cmd := exec.Command("gcloud", "alpha", "functions", "logs", "read", "HelloGCS", "--start-time", startTime)
	got, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("exec.Command: %v", err)
	}
	return string(got)
}

Usa el siguiente comando para implementar tu función:

Node.js 8

gcloud functions deploy helloGCS --runtime nodejs8 --trigger-bucket YOUR_GCS_BUCKET_NAME

Node.js 10 (Beta)

gcloud functions deploy helloGCS --runtime nodejs10 --trigger-bucket YOUR_GCS_BUCKET_NAME

Node.js 6 (obsoleto)

gcloud functions deploy helloGCS --runtime nodejs6 --trigger-bucket YOUR_GCS_BUCKET_NAME

Python

gcloud functions deploy hello_gcs --runtime python37 --trigger-bucket YOUR_GCS_BUCKET_NAME

Go

gcloud functions deploy HelloGCS --runtime go111 --trigger-bucket YOUR_GCS_BUCKET_NAME

donde YOUR_GCS_BUCKET_NAME es el depósito de Cloud Storage que quieres supervisar. Ten en cuenta que esto debe hacer referencia a un depósito que exista en el mismo proyecto de GCP en el que se implementa la función.

Usa los siguientes comandos para ejecutar las pruebas de sistema:

Node.js

export BUCKET_NAME=YOUR_GCS_BUCKET_NAME
mocha test/sample.system.storage.test.js --exit

Python

export BUCKET_NAME=YOUR_GCS_BUCKET_NAME
pytest sample_storage_test_system.py

Go

export BUCKET_NAME=YOUR_GCS_BUCKET_NAME
go test -v ./hello_cloud_storage_system_test.go

Implementación y pruebas continuas

A medida que desarrollas tu función, puedes ejecutar pruebas de unidades, de integración y del sistema para asegurarte de que las funciones actúen a nivel local y en un entorno de pruebas en GCP.

Una vez que termines de desarrollar funciones localmente, puedes configurar una plataforma de integración y de implementación continuas, como Cloud Build, para ejecutar las pruebas de Cloud Functions existentes de manera constante. Las pruebas continuas ayudan a asegurar que tu código sigue funcionando como se prevé y que tus dependencias permanecen actualizadas. Como las funciones de Cloud Functions no se actualizan automáticamente, también puedes configurar plataformas de integración continua (incluida Cloud Build) para probar y volver a implementar de forma automática tus funciones desde un repositorio de código fuente, como GitHub, Bitbucket o Cloud Source Repositories.

Sigue las instrucciones en la guía Automatiza compilaciones con activadores de compilación usando el archivo de configuración de la compilación cloudbuild.yaml que aparece a continuación para configurar Cloud Build a fin de probar y, luego, implementar tu función automáticamente.

Node.js

steps:
- name: 'gcr.io/cloud-builders/yarn'
  args: ['install']
  dir: 'functions/autodeploy'
- name: 'gcr.io/cloud-builders/npm'
  args: ['test']
  dir: 'functions/autodeploy'
- name: 'gcr.io/cloud-builders/gcloud'
  args: ['functions', 'deploy', '[YOUR_DEPLOYED_FUNCTION_NAME]', '[YOUR_FUNCTION_TRIGGER]', '--runtime', '[YOUR_RUNTIME]', '--entry-point', '[YOUR_FUNCTION_NAME_IN_CODE]']
  dir: 'functions/autodeploy'

Reemplaza

  • [YOUR_FUNCTION_NAME] por el nombre de tus funciones de Cloud Functions que se utilizará en Google Cloud Platform Console, el SDK de Cloud y la URL.
  • [YOUR_FUNCTION_TRIGGER] por el valor de activador apropiado, como --trigger-http.
  • [YOUR_RUNTIME] por el identificador del entorno de ejecución, como nodejs10.
  • [YOUR_FUNCTION_NAME_IN_CODE] por el nombre de la función tal como aparece en el código. --entry-point solo es necesario si este valor es diferente de [YOUR_FUNCTION_NAME].

Si Cloud Build no se ajusta a tus necesidades, consulta esta lista de plataformas de integración continua.

Otorga permisos para ejecutar implementaciones y compilaciones

Si usas Cloud Build, es necesario que otorgues permisos a la cuenta de servicio de Cloud Build.

Por ejemplo:

  • Para implementar Cloud Functions, te recomendamos que asignes la función de Desarrollador de Cloud Functions a la cuenta de servicio de Cloud Build (PROJECT_NUMBER@cloudbuild.gserviceaccount.com).
  • Si usas la función de Desarrollador de Cloud Functions, es necesario que también otorgues a la cuenta de servicio del entorno de ejecución de Cloud Functions (PROJECT_ID@appspot.gserviceaccount.com) la función de Usuario de cuenta de servicio de IAM.
¿Te sirvió esta página? Envíanos tu opinión:

Enviar comentarios sobre…

Documentación de Cloud Functions