Going in the Deep End

Thoughts after using Go on a few projects.

NB: A first class AWS SDK for Go would be awesome. This is definitely the missing tooth in a smile.

Testing

func assert(t testing.TB, condition bool, msg string, v ...interface{}) {
    if !condition {
        _, file, line, _ := runtime.Caller(1)
        fmt.Printf("33[31m%s:%d: "+msg+"33[39mnn", append([]interface{}{filepath.Base(file), line}, v...)...)
        tb.FailNow()
    }
}

func ok(t testing.TB, err error) {
    if err != nil {
        _, file, line, _ := runtime.Caller(1)
        fmt.Printf("33[31m%s:%d: unexpected error: %s33[39mnn", filepath.Base(file), line, err.Error())
        tb.FailNow()
    }
}

func equals(t testing.TB, got, want interface{}) {
    if !reflect.DeepEqual(got, want) {
        _, file, line, _ := runtime.Caller(1)
        fmt.Printf("33[31m%s:%d:nntgot: %#vnntwant: %#v33[39mnn", filepath.Base(file), line, got, want)
        tb.FailNow()
    }
}

func TestUnmarshalXML(t *testing.T) {
    r := XMLWrap{}
    err := xml.Unmarshal([]byte(xmlData), &r)
    ok(t, err)
    equals(t, r.RootID, "anID")
    equals(t, r.RootValue, "aValue")
}   

func TestReadConfig(t *testing.T) {
    testValues := []struct {
        key  string
        want interface{}
    }{
        {"a_string", "This is a string."},
        {"a_int", 123},
        {"a_float64", 123.456},
    }

    for _, tv := range testValues {
        got := Config[tv.key]
        equals(t, got, tv.want)
    }
}

func TestNotFound(t *testing.T) {
        r, err := http.NewRequest("DELETE", "http://pkg.test/testuri", nil)
        ok(t, err)
        w := httptest.NewRecorder()
        NotFound(w, r)
        equals(t, w.Header().Get("Content-Type"), "application/json")
        equals(t, w.Code, 404)
        equals(t, w.Body.String(), "{"Status":"Not Found","StatusCode":404,"RequestMethod":"DELETE","RequestURI":""}")
    }

func TestAClientCallError(t *testing.T){
    ts := httptest.NewServer(
        http.HandlerFunc(func(w http.ResponseWriter, r  *http.Request) {
            w.Header().Set("Server", "golang httptest")
            w.WriteHeader(http.StatusInternalServerError)
            return
        }))
    defer ts.Close()

    client, err := NewClient("SecretKey")
    ok(t, err)
    wrap := &XMLWrap{}
    err = client.APICall("some_data", ts.URL, wrap)
    assert(t, strings.Contains(err.Error(), "500 Internal Server Error"), "Unexpected response received.")
}

Google AppEngine

import (
    "fmt"
    "net/http"

    "appengine"
    "appengine/urlfetch"
)   

func handler(w http.ResponseWriter, r *http.Request) {
    c := appengine.NewContext(r)
    client := urlfetch.Client(c)
    resp, err := client.Get("http://example.com/api/call")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    fmt.Fprintf(w, "API call returned status %v", resp.Status)
}

import (
    "testing"

    "appengine/aetest"
)

func TestAPICall(t *testing.T) {
    c, err := aetest.NewContext(nil)
    if err != nil {
        t.Fatal(err)
    }
    defer c.Close()

    client := urlfetch.Client(c)
    ...             
}

Running Managed VMs in GAE

go get google.golang.org/appengine

# app.yaml
application: test-vm-http2
version: 1
api_version: go1
runtime: go
    # New knob
vm: true

manual_scaling:
  instances: 1
# New knob
vm_settings:
  machine_type: n1-standard-1

- url: /.*
  script: _go_app

package hellovm

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

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

func handle(w http.ResponseWriter, r *http.Request) {
    if r.URL.Path != "/" {
        http.NotFound(w, r)
        return
    }

    resp, err := http.Get("http://example.com/")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    w.Header().Set("Content-Type", "text/html")
    fmt.Fprintf(w, "%s", body)
}

Testing via an Interface

func init() {
    http.Handle("/foo", aeContext(handler))
    http.Handle("/another", aeContext(handlers.Another))
}

func handler(c appengine.Context, w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, world! %s", config.Config["tms_api_key"])
}

// aeContext wraps handlers & injects the appengine.Context. This is
// primarily to allow testing of handlers directly.
type aeContext func(appengine.Context, http.ResponseWriter, *http.Request)

// ServeHTTP allows aeContext to serve our handlers
func (fn aeContext) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    c := appengine.NewContext(r)
    fn(c, w, r)
}

// Contexter provides a way to use context. This exists primarily to allow for
// testing without depending on aetest.Context. aetest.Context starts dev_appserver,
// which makes tests take *forever*.

// Contexter has the following methods:

// GetHTTPClient, which returns an appengine-compatible HTTP client for a 
// real use and a testing one for the Dummy context

// Criticalf and Errorf, which wrap the appengine logging interface in a real
// implementation and do nothing in the testing context
type Contexter interface {
    GetHTTPClient() *http.Client
    // NB: We collect the other methods here to record what we need to implement. 
    // Anything we don't can just be an empty method. This ins't stricly 
    // necessary.
    Criticalf(format string, args ...interface{})
    Errorf(format string, args ...interface{})
    ...
}

...
    func handler(c appengine.Context, w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, world! %s", config.Config["tms_api_key"])
}

// aeContext wraps handlers & injects the appengine.Context. This is
// primarily to allow testing of handlers directly.
type aeContext func(Contexter, http.ResponseWriter, *http.Request)

// ServeHTTP allows aeContext to serve our handlers
func (fn aeContext) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    c := NewContext(r)
    fn(c, w, r)
}
...

// Context is a Contexter which wraps a real appengine.Context for
// testing purposes (i.e., to avoid launching an instance of dev_appserver.py).
type Context struct {
    // This is the real appengine.Context.
    c appengine.Context
}

// NewContext returns a new Context instance for production use.
func NewContext(r *http.Request) Contexter {
    c := appengine.NewContext(r)
    return Context{c: c}
}

// GetHTTPClient returns an appengine-compatible http.Client.
func (c Context) GetHTTPClient() *http.Client {
    return urlfetch.Client(c.c)
}

// Errorf logs to the underlying appengine.Context
func (c Context) Errorf(format string, args ...interface{}) {
    c.c.Errorf(format, args...)
}

// Criticalf logs to the underlying appengine.Context
func (c Context) Criticalf(format string, args ...interface{}) {
    c.c.Criticalf(format, args...)
}

type DummyContext struct {
}

// GetHTTPClient returns a dependency-free http.Client.
func (c DummyContext) GetHTTPClient() *http.Client {
    return &http.Client{}
}

// errorf logs to the underlying appengine.Context
func (c DummyContext) Errorf(format string, args ...interface{}) {
}

// criticalf logs to the underlying appengine.Context
func (c DummyContext) Criticalf(format string, args ...interface{}) {
}

func TestErrch(t *testing.T) {
    ts := httptest.NewServer(
        http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            w.Header().Set("Server", "golang httptest")
            w.WriteHeader(http.StatusInternalServerError)
            return
        }))
    defer ts.Close()

    ctxr := vtest.DummyContext{}
    client, err := NewClient(ctxr, "SecretKey")
    ok(t, err)
    wr := &XMLWrap{}
    err = client.Call("someData", ts.URL, wr)
    assert(t, strings.Contains(err.Error(), "500 Internal Server Error"), "Unexpected response received.")
}

Conclusion