LambdaとGoを使ったサーバーレスWebAPI開発実践入門

package example

import (
	"log"
	"os"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/guregu/dynamo"
)

var (
	gdb    *dynamo.DB
	region string

	usersTable string
)

func init() {
	region = os.Getenv("AWS_REGION")

	usersTable = os.Getenv("DYNAMO_TABLE_USERS")
	if usersTable == "" {
		log.Fatal("missing env variable: DYNAMO_TABLE_USERS")
	}

	gdb = dynamo.New(session.Must(session.NewSession(&aws.Config{
		Region: aws.String(region),
	})))
}

package example

import (
	"context"
	"errors"

	"github.com/guregu/dynamo"
)

func scanUsers(ctx context.Context) ([]User, error) {
	var resp []User
	table := gdb.Table(usersTable)
	if err := table.Scan().AllWithContext(ctx, &resp); err != nil {
		// 0件の場合も正常とします
		if errors.Is(err, dynamo.ErrNotFound) {
			return nil, nil
		}
		return resp, err
	}
	return resp, nil
}

package example

import (
	"fmt"

	"github.com/d-tsuji/example/gen/models"
	"github.com/d-tsuji/example/gen/restapi/operations"
	"github.com/go-openapi/runtime/middleware"
)

func GetUsers(p operations.GetUsersParams) middleware.Responder {
	ctx := p.HTTPRequest.Context()
	users, err := scanUsers(ctx)
	if err != nil {
		return operations.NewGetUsersInternalServerError().WithPayload(&models.Error{
			Message: fmt.Sprintf("scan users error: %v", err),
		})
	}
	var resp models.Users
	for _, u := range users {
		u := u
		resp = append(resp, &models.User{
			UserID: &u.UserID,
			Name:   &u.UserName,
		})
	}
	return operations.NewGetUsersOK().WithPayload(resp)
}

package example

import (
	"context"
	"io/ioutil"
	"net/http/httptest"
	"testing"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/d-tsuji/example/gen/models"
	"github.com/d-tsuji/example/gen/restapi/operations"
	"github.com/go-openapi/runtime"
	"github.com/guregu/dynamo"
	"github.com/nsf/jsondiff"
)

func init() {
	dbEndpoint := "http://localhost:4566"
	sess := session.Must(session.NewSessionWithOptions(session.Options{
		Profile:           "local",
		SharedConfigState: session.SharedConfigEnable,
		Config: aws.Config{
			Endpoint:   aws.String(dbEndpoint),
			DisableSSL: aws.Bool(true),
		},
	}))
	gdb = dynamo.New(sess)
}

func TestGetUsers(t *testing.T) {
	tests := []struct {
		name           string
		input          func(t *testing.T)
		wantStatusCode int
		want           string
	}{
		{
			name: "複数件のユーザの取得",
			input: func(t *testing.T) {
				err := gdb.CreateTable(usersTable, User{}).Provision(1, 1).RunWithContext(context.TODO())
				if err != nil {
					t.Errorf("dynamo create table %s: %v", usersTable, err)
				}
				inputUsers := []User{{UserID: "001", UserName: "gopher"}, {UserID: "002", UserName: "rubyist"}}
				for _, u := range inputUsers {
					if err := gdb.Table(usersTable).Put(u).RunWithContext(context.TODO()); err != nil {
						t.Errorf("dynamo input user %v: %v", u, err)
					}
				}
			},
			wantStatusCode: 200,
			want:           "./testdata/want_get_users_1.json",
		},
		{
			name: "ユーザ0件",
			input: func(t *testing.T) {
				err := gdb.CreateTable(usersTable, User{}).Provision(1, 1).RunWithContext(context.TODO())
				if err != nil {
					t.Errorf("dynamo create table %s: %v", usersTable, err)
				}
			},
			wantStatusCode: 200,
			want:           "./testdata/want_get_users_2.json",
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			tt.input(t)
			t.Cleanup(func() {
				if err := gdb.Table(usersTable).DeleteTable().RunWithContext(context.TODO()); err != nil {
					t.Fatalf("dynamo delete table %s: %v", usersTable, err)
				}
			})

			p := operations.NewGetUsersParams()
			p.HTTPRequest = httptest.NewRequest("GET", "/v1/users", nil)

			resp := GetUsers(p)

			w := httptest.NewRecorder()
			resp.WriteResponse(w, runtime.JSONProducer())

			want, err := ioutil.ReadFile(tt.want)
			if err != nil {
				t.Fatalf("want file read: %v", err)
			}

			if w.Result().StatusCode != tt.wantStatusCode {
				t.Errorf("status got %v, but want %v", w.Result().StatusCode, tt.wantStatusCode)
			}

			opt := jsondiff.DefaultConsoleOptions()
			if d, s := jsondiff.Compare(w.Body.Bytes(), want, &opt); d != jsondiff.FullMatch {
				t.Errorf("unmatch, got=%s, want=%s, diff=%s", string(w.Body.Bytes()), string(want), s)
			}
		})
	}
}

// This file is safe to edit. Once it exists it will not be overwritten

package restapi

// ...

func configureAPI(api *operations.ExampleAppAPI) http.Handler {
	// configure the api here
	api.ServeError = errors.ServeError

	// Set your custom logger if needed. Default one is log.Printf
	// Expected interface func(string, ...interface{})
	//
	// Example:
	// api.Logger = log.Printf

	api.JSONConsumer = runtime.JSONConsumer()

	api.JSONProducer = runtime.JSONProducer()

	// ==================================================================================
	// userハンドラ
	// 以下のように実装したハンドラをHTTPサーバに紐付けます。
	api.GetUsersHandler = operations.GetUsersHandlerFunc(example.GetUsers)
	api.PostUsersHandler = operations.PostUsersHandlerFunc(example.PostUsers)
	// ==================================================================================

	api.PreServerShutdown = func() {}

	api.ServerShutdown = func() {}

	return setupGlobalMiddleware(api.Serve(setupMiddlewares))
}

// ...

package main

import (
	"context"
	"log"

	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
	"github.com/awslabs/aws-lambda-go-api-proxy/httpadapter"
	"github.com/d-tsuji/example/gen/restapi"
	"github.com/d-tsuji/example/gen/restapi/operations"
	"github.com/go-openapi/loads"
)

var httpAdapter *httpadapter.HandlerAdapter

// Handler handles API requests
func Handler(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	if httpAdapter == nil {
		swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON)
		if err != nil {
			log.Fatalln(err)
		}

		api := operations.NewExampleAppAPI(swaggerSpec)
		server := restapi.NewServer(api)
		server.ConfigureAPI()

		// see https://github.com/go-swagger/go-swagger/issues/962#issuecomment-478382896
		httpAdapter = httpadapter.New(server.GetHandler())
	}
	return httpAdapter.ProxyWithContext(ctx, req)
}

func main() {
	lambda.Start(Handler)
}