Test locali delle unità per Go

I test locali delle unità vengono eseguiti all'interno del tuo ambiente senza accedere ai componenti remoti. App Engine fornisce utilità di test che utilizzano implementazioni locali di Cloud Datastore e di altri servizi App Engine.

I servizi di sviluppo simulano il comportamento del servizio reale in locale per i test. Ad esempio, l'utilizzo del datastore mostrato in Scrivere test di Cloud Datastore e Memcache ti consente di testare il codice del datastore senza effettuare richieste al datastore reale. Qualsiasi entità archiviata durante un test di unità del datastore viene archiviata localmente ed eliminata al termine dell'esecuzione del test. Puoi eseguire test piccoli e rapidi senza alcuna dipendenza dal datastore stesso.

Questo documento descrive come scrivere test di unità per i servizi App Engine locali utilizzando il pacchetto di test Go.

Il pacchetto Go Testing

Puoi automatizzare il download, la creazione e il test dei pacchetti Go utilizzando lo strumento goapp. goapp fa parte dell'SDK App Engine per Go.

La combinazione del comando goapp test e del pacchetto Gotesting standard può essere utilizzata per eseguire test di unità sul codice dell'applicazione. Per informazioni sui test con Go, consulta la sezione Test di Come scrivere codice Go e la documentazione di riferimento del pacchetto testing.

I test di unità sono contenuti in file che terminano con il suffisso _test.go. Ad esempio, supponiamo che tu voglia testare una funzione denominata composeNewsletter che restituisce un *mail.Message. Il seguente file newsletter_test.go mostra un semplice test per la funzione:

package newsletter

import (
	"reflect"
	"testing"

	"google.golang.org/appengine/mail"
)

func TestComposeNewsletter(t *testing.T) {
	want := &mail.Message{
		Sender:  "newsletter@appspot.com",
		To:      []string{"User <user@example.com>"},
		Subject: "Weekly App Engine Update",
		Body:    "Don't forget to test your code!",
	}
	if msg := composeNewsletter(); !reflect.DeepEqual(msg, want) {
		t.Errorf("composeMessage() = %+v, want %+v", msg, want)
	}
}

Questo test viene richiamato utilizzando il comando goapp test dalla directory del pacchetto:

goapp test

Lo strumento goapp si trova nella directory principale dell'SDK App Engine. Ti consigliamo di inserire questa directory nella variabile PATH del sistema per semplificare l'esecuzione dei test.

Il pacchetto aetest

Molte chiamate di funzioni ai servizi App Engine richiedono un context.Context come argomento. Il pacchetto appengine/aetest fornito con l'SDK consente di creare un context.Context falso per eseguire i test utilizzando i servizi forniti nell'ambiente di sviluppo.

import (
	"testing"

	"google.golang.org/appengine/aetest"
)

func TestWithContext(t *testing.T) {
	ctx, done, err := aetest.NewContext()
	if err != nil {
		t.Fatal(err)
	}
	defer done()

	// Run code and tests requiring the context.Context using ctx.
	// ...
}

La chiamata a aetest.NewContext avvierà dev_appserver.py in un sottoprocesso, che verrà utilizzato per gestire le chiamate API durante il test. Questo sottoprocesso verrà chiuso con la chiamata a done.

Per un maggiore controllo sull'istanza sottostante, puoi utilizzare aetest.NewInstance. In questo modo puoi creare più contesti e associarli agli oggetti http.Request.

import (
	"errors"
	"testing"

	"golang.org/x/net/context"

	"google.golang.org/appengine"
	"google.golang.org/appengine/aetest"
	"google.golang.org/appengine/datastore"
)

func TestMyFunction(t *testing.T) {
	inst, err := aetest.NewInstance(nil)
	if err != nil {
		t.Fatalf("Failed to create instance: %v", err)
	}
	defer inst.Close()

	req1, err := inst.NewRequest("GET", "/gophers", nil)
	if err != nil {
		t.Fatalf("Failed to create req1: %v", err)
	}
	c1 := appengine.NewContext(req1)

	req2, err := inst.NewRequest("GET", "/herons", nil)
	if err != nil {
		t.Fatalf("Failed to create req2: %v", err)
	}
	c2 := appengine.NewContext(req2)

	// Run code and tests with *http.Request req1 and req2,
	// and context.Context c1 and c2.
	// ...
}

Per ulteriori informazioni, consulta la documentazione di riferimento del pacchetto aetest.

Scrittura di test di Cloud Datastore e Memcache

Testare il codice che utilizza il datastore o memcache è semplice dopo aver creato un context.Context con il pacchetto aetest: nella chiamata di test aetest.NewContext per creare un contesto da passare alla funzione in test.

L'applicazione di dimostrazione transaction nell'SDK contiene un esempio di strutturazione del codice per consentirne la testabilità e di come testare il codice che utilizza il datastore:

func TestWithdrawLowBal(t *testing.T) {
	ctx, done, err := aetest.NewContext()
	if err != nil {
		t.Fatal(err)
	}
	defer done()
	key := datastore.NewKey(ctx, "BankAccount", "", 1, nil)
	if _, err := datastore.Put(ctx, key, &BankAccount{100}); err != nil {
		t.Fatal(err)
	}

	err = withdraw(ctx, "myid", 128, 0)
	if err == nil || err.Error() != "insufficient funds" {
		t.Errorf("Error: %v; want insufficient funds error", err)
	}

	b := BankAccount{}
	if err := datastore.Get(ctx, key, &b); err != nil {
		t.Fatal(err)
	}
	if bal, want := b.Balance, 100; bal != want {
		t.Errorf("Balance %d, want %d", bal, want)
	}
}

Questo test può essere eseguito utilizzando il comando goapp test:

goapp test ./demos/transaction

I test per memcache seguono lo stesso schema: configura lo stato iniziale di memcache nel test, esegui la funzione in test e verifica che la funzione abbia eseguito query/modificato memcache nel modo previsto.