package mygae

import (
    "ds" //自作のライブラリ群(後述します)
    "html/template"
    "log"
    "net/http"

    "github.com/gin-gonic/gin"
)
//初期化
func init() {
    http.Handle("/", GetMainEngine())
}

func GetMainEngine() *gin.Engine {
    LoadTemplaytes()
    server := gin.Default()
    server.LoadHTMLGlob("templates/*")
    server.GET("/", Listing)
    server.GET("/get/:id", GetTodo)
    server.POST("/post/", MakeTodo)
    return server
}
//localhost:8080/にアクセス(GETリクエスト)した時の処理。
//Datastoreに存在する全てのTodoを列挙し、そのStringIDを抽出。
//それをHTMLテンプレートに流し込みリンクとして列挙するようにしています。
func Listing(g *gin.Context) {
    keys, err := DataStoreManager.ListingTodoData(g)
    if err != nil {
        g.String(500, "Get Error at Listing %v", err)
        return
    }
    ids := make([]string, len(keys))
    for i, v := range keys {
        ids[i] = v.StringID()
    }
    g.HTML(200, "t.html", gin.H{
        "KeyIDs": ids,
    })
}
//localhost:8080/get/(ID数値)にアクセス(GETリクエスト)した時の処理
//IDを抽出し、それをKeyとしてTodoのEntityを構造体として持ってくる。
//最後にそれをJSONで返している。
func GetTodo(g *gin.Context) {
    ids := g.Param("id")
    todo, err := DataStoreManager.GetTodoList(ids, g)
    if err != nil {
        g.String(500, "Get Error at GetTodo %v", err)
    }
    g.JSON(200, todo)
}

//localhost:8080/post/にPOSTがあった時に行われる処理
//curl -X POST -H 'Content-Type: application/json' -d '{"Title" : "Title1" , "Description" : "いろいろやる"}' localhost:8080/post/
//↑のような例をやると正しくDatastoreに格納される。
func MakeTodo(g *gin.Context) {
    var todo DataStoreManager.Todo
    if g.BindJSON(&todo) == nil {
        if err := DataStoreManager.PutToDoList(todo, g); err != nil {
            g.String(500, "Put Error %v", err)
            return
        }
        g.String(200, "PutSuccess")
    } else {
        g.String(500, "Cant Make JSON")
    }
}
//HTMLテンプレートをロードする。
//データを列挙するページでのみ使用している。
func LoadTemplaytes() {
    baseTemplate, err := template.New("root").Parse("t.html")
    template.Must(todoTemplate, err2)
}

package DataStoreManager

import (
    "log"
    "github.com/gin-gonic/gin"
    "google.golang.org/appengine"
    "google.golang.org/appengine/datastore"
)

type (
    //jsonとdatastoreでの名前設定。そしてbindJSONするときに必ず値が入るようにrequiredを設定
    Todo struct {
        Title       string `datastore:"Title" json:"Title" binding:"required"`
        Description string `datastore:"Description" json:"Description" binding:"required"`
    }
)
//datastoreからTodoKindの全てのKeyを返す。
//最終的にKeyのIDのみあれば良いのでKeyを返却している。
//Entityを全て取得するより早いので公式にもKeyのみであればKeysOnlyを使うように推奨されている
func ListingTodoData(g *gin.Context) ([]*datastore.Key, error) {
    c := appengine.NewContext(g.Request)
    query := datastore.NewQuery("Todo").KeysOnly()
    var keys = []*datastore.Key{}
    var err error

    if keys, err = query.GetAll(c, nil); err != nil {
        return nil, err
    }
    return keys, nil
}
//todoIDの文字列からKeyを作成。
//そのKeyからEntityを引っ張ってきてそれを構造体として返す。
func GetTodoList(todoID string, g *gin.Context) (*Todo, error) {
    c := appengine.NewContext(g.Request)

    todoKey := datastore.NewKey(c, "Todo", todoID, 0, nil)
    todoData := Todo{}
    if err := datastore.Get(c, todoKey, &todoData); err != nil {
        return nil, err
    }
    return &todoData, nil
}

//引数の構造体をそのままdatastoreにPutする。
//その際KeyはAllocateID関数で作成されたUniqueなIDを用いて作成されており被ることはない。
func PutToDoList(todo Todo, g *gin.Context) error {
    c := appengine.NewContext(g.Request)
    ids, _ := AllocateID(c, "Todo")
    todoKey := datastore.NewKey(c, "Todo", ids, 0, nil)

    if _, err := datastore.Put(c, todoKey, &todo); err != nil {
        log.Fatalf("Error Occured while Putting data: %v", err)
        return err
    }
    return nil
}
//UniqueなIDを文字列で返してくれるいいやつ
func AllocateID(c context.Context, kind string) (string, error) {
    id, _, err := datastore.AllocateIDs(c, kind, nil, 1)
    return fmt.Sprint(id), err
}

package mygae
import (
    "bytes"
    "log"
    "net/http"
    "net/http/httptest"
    "testing"
    "time"
)
//Listing機能をテストする
func TestServerListing(t *testing.T) {
    httptest.NewServer(GetMainEngine())
    testListing(t)
}
//データを引っ張ってくるのをテストする
func TestServerGet(t *testing.T) {
    testGet(t)
}
//POSTした結果をテストする
func TestServerPOST(t *testing.T) {
    testPost(t)
}
//Listingをテストする。goapp serveで実際のサーバは8080Portで既に立っているためそこにGETを送る。
func testListing(t *testing.T) {
    resp, err := http.Get("http://localhost:8080/")
    if err != nil {
        t.Fatalf("geterror %v", err)
        return
    }
    // 関数を抜ける際に必ずresponseをcloseするようにdeferでcloseを呼ぶ
    defer resp.Body.Close()
    if resp.StatusCode != 200 {
        t.Fatalf("%v", resp.StatusCode)
    }
}
//GETも同様にTodoを取得するためにGETリクエストを適当なURLに行う
//testIDCaseはIDとテストが通るか(通ると想定するケースはTrue)をMapとして持っておく。
//期待した結果ともし違う場合はt.Fatalfメソッドでテストを失敗として処理する。
func testGet(t *testing.T) {
    testIDCase := map[string]bool{"1": true, "2": true, "n": false}
    for key, value := range testIDCase {
        log.Println(key, value)
        resp, _ := http.Get("http://localhost:8080/get/" + key)

        if resp.StatusCode == 200 != value {
            t.Fatalf("%v", resp.StatusCode)
        }
        defer resp.Body.Close()
    }
}
//POSTもGETTodoのGETがPOSTになっただけでやることはほとんど変わらない。
//通ると想定するケースはTrue、通らないと想定するケースはfalseを各String値に紐付けてテストを行う。
func testPost(t *testing.T) {
    strs := map[string]bool{`{"Title" : "Title1" , "Description" : "いろいろやる"}`: true,
        `{"Title" : "Title1" , "Description2" : "いろいろやる"}`:                         false,
        `{"Title2" : "Title1" , "Description" : "いろいろやる"}`:                         false,
        `{"Title" : "gajgapgndfsngdsgkhnpsdknhsdgkhmkgsdhn" , "Description" : ""}`: false,
        `{"Title" : "" , "Description" : "いろいろやる"}`:                                false}

    for key, value := range strs {
        log.Println(key, value)
        url := "http://localhost:8080/post/"

        req, err := http.NewRequest(
            "POST",
            url,
            bytes.NewBuffer([]byte(key)),
        )

        if err != nil {
            t.Fatalf("Error Occured %v", err)
        }

        client := &http.Client{Timeout: time.Duration(15 * time.Second)}
        resp, _ := client.Do(req)
        if resp.StatusCode == 200 != value {
            t.Fatalf("Error Occured: key is %v", key)
        }
        defer resp.Body.Close()
    }
}

1 true
2 true
n false
{"Title" : "Title1" , "Description" : "いろいろやる"} true
{"Title" : "Title1" , "Description2" : "いろいろやる"} false
{"Title2" : "Title1" , "Description" : "いろいろやる"} false
{"Title" : "gajgapgndfsngdsgkhnpsdknhsdgkhmkgsdhn" , "Description" : ""} false
{"Title" : "" , "Description" : "いろいろやる"} false
PASS
ok      _/Users/takumi.negishi/go_appengine/gopath/gae_projects/todolist

    application: todolist #元々デバッグで使っていたdatastoreは汚したくない。。
    version: 1
    runtime: go
    api_version: go1
    handlers:
    - url: /.*
      script: _go_app
#…以下省略

    application: todolist-test #こんな感じに変える。別に-testじゃなくても良い。
    version: 1
    runtime: go
    api_version: go1
    handlers:
    - url: /.*
      script: _go_app
#…以下省略

func TestServer(t *testing.T) {
    LoadTemplates()
    server := gin.Default()
    server.GET("/test/", func(g *gin.Context) {
        Listing(g)
    })
    http.Handle("/", server)

    //サーバをたてて
    resp, err := http.Get("http://localhost:8080/test/")

    defer resp.Body.Close()
    if err != nil {
        t.Fatalf("Error:: %v", err)
        return
    }
//respによって判断する。
}