Cannot change consistency using “goapp test”

Question

Google's AppEngine service provides an eventually consistent database for storage of application data in production. For testing, Google provides a similar database that emulates the consistency characteristics of the production database. Testing requirements may vary so Google supplies command line parameters to their test server, dev_appserver.py , that modify the consistency characteristics as needed for testing.

I am using the goapp tools to run our automated test environment for my AppEngine development. goapp test is responsible for running our automated server API tests. goapp test does not appear to have a way of setting the datastore's consistency level via the command line parameters, unlike dev_appserver.py , even though goapp test launches dev_appserver.py at some point during the testing process.

Is there a way to pass command line parameters to dev_appserver.py from goapp test ? If not, is there an alternative method for setting the consistency from the command line?

Answer 1

I presume you are using the aetest package . If this is the case you should set the StronglyConsistentDatastore member of the aetest.Options struct accordingly.

Here is an example:

hello.go

package hello

import (
    "fmt"
    "net/http"
    "time"

    "appengine"
    datastore "appengine/datastore"
)

type Employee struct {
        FirstName          string
        LastName           string
        HireDate           time.Time
}

func init() {
    http.HandleFunc("/", handler)
}

func handler(w http.ResponseWriter, r *http.Request) {
    ctx := appengine.NewContext(r)

    q := datastore.NewQuery("Employee").Filter("FirstName =", "Antonio")

    var people []Employee

    if _, err := q.GetAll(ctx, &people); err != nil {
        fmt.Fprintf(w, "Error %v", err)
    }

    fmt.Fprintf(w, "Matches %v", len(people))
}

hello_test.go

package hello

import (
    "time"
    "testing"
    "net/http/httptest"
    "appengine"
    "appengine/aetest"
    datastore "appengine/datastore"
)

const consistency_strong = true; // set to false and the test will fail

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

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

    employee := &Employee{
            FirstName: "Antonio",
            LastName:  "Salieri",
            HireDate:  time.Now(),
    }

    key := datastore.NewIncompleteKey(ctx, "Employee", nil)

    _, err = datastore.Put(ctx, key, employee)

    if err != nil {
        t.Fatalf("Error setting test data: %v", err)
    }

    w := httptest.NewRecorder()

    handler(w, req)

    if w.Body.String() != "Matches 1" {
        t.Fatalf("Expected 1 record got %v", w.Body)
    }
}

As you have mentioned the go tools merely wrap dev_appserver.py. This means that if you are not using aetest you can always run your app with a chosen consistency policy like so:

/usr/local/go_appengine/dev_appserver.py --datastore_consistency_policy consistent .