再次自我黑客马拉松--不用第三方库实现一个基于golang的web service

在上篇博客《自我黑客马拉松--从零开始创建一个基于Go语言的Web Service》中，笔者从零开始接触Go语言，挑战了一下自我，实现了一个web service. 不过这里有一个问题，在上次的实现中，用了一些第三方的库，比如beego框架和go-simplejson. 从工程的角度来说，利用框架等第三方库的优点是，很多地方的编码变得简单，代码量较少；但是缺点是：一、对golang本身built-in的库如net/http和encoding/json都还了解得很不够；二、一旦第三方的库出了问题，查找问题和修正bug都比较麻烦。所以这次，笔者打算再自我挑战一下，不用任何第三方库只用golang自带的库来把上次的4个API实现一遍，另外还要加上单元测试！

这次的目录结构比较简单，所有文件全放一个文件夹下了。鉴于上次的package叫做cityweather，那么这次的package就叫做cityweather2吧！（真是不会起名字啊）

对requirement不熟悉的朋友，还是请看上篇博客里的介绍吧。

这次一共有4个文件：main.go, controller.go, model.go 和 model_test.go，详情如下：

1. main.go

package main

import (
    "net/http"
)


func main() {    
    http.HandleFunc("/", topHandler)
    http.ListenAndServe(":8080", nil)
}

2. controller.go

package main

import (
    "io"
    "fmt"
    "net/http"
    "strings"
    "encoding/json"
    
    _ "github.com/mattn/go-sqlite3"
)

// POST /location
func postLocationHandler(w http.ResponseWriter, r *http.Request) {
    defer r.Body.Close()
    body := make([]byte, r.ContentLength)
    r.Body.Read(body)
    
    var city CityName
    err := json.Unmarshal(body, &city)
    if err != nil {
        w.WriteHeader(http.StatusInternalServerError)
        io.WriteString(w, err.Error())
        return
    }

    status, err := AddOneCity(city.Name)
    
    w.WriteHeader(status)
    if err != nil {
        io.WriteString(w, err.Error())
    }
}


// GET /location
func getAllLocationsHandler(w http.ResponseWriter, r *http.Request) {
    cities, respCode, err := GetAllCities()
    w.WriteHeader(respCode)
    
    if err == nil {
        citiesStr := "["
        for i, city := range cities {
            if i > 0 {
                citiesStr += (", " + city)
            } else {
                citiesStr += city
            }
        }
        citiesStr += "]"
        
        io.WriteString(w, citiesStr)
    } else {
      io.WriteString(w, err.Error())
    }
}


// DELETE /location/{name}
func deleteCityHandler(w http.ResponseWriter, r *http.Request, city string) {
    respCode, err := DeleteOneCity(city)
    
    w.WriteHeader(respCode)
    if err != nil {
        io.WriteString(w, err.Error())
    }
}


// GET /location/{name}
func getCityWeatherHandler(w http.ResponseWriter, r *http.Request, city string) {
    result, respCode, err := GetOneCityWeather(city)
    resp, err := json.Marshal(result)
    
    w.WriteHeader(respCode)
    if err == nil {
        w.Write(resp)
    } else {
        io.WriteString(w, err.Error())
    }
}


func topHandler(w http.ResponseWriter, r *http.Request) {
    items := strings.Split(r.URL.Path, "/")
    
    if (len(items) > 4 || len(items) <=1) {
        w.WriteHeader(http.StatusNotFound)
        fmt.Fprintf(w, "404 Not Found: %s", r.URL.Path)
        return
    }
    
    loc := "location"
    firstPlace := strings.ToLower(items[1])
    
    if firstPlace == loc {
        if (r.Method == http.MethodPost && len(items) == 2) {  // POST /location
            postLocationHandler(w, r)
            
        } else if (r.Method == http.MethodGet && (len(items) == 2 || (len(items) == 3 && items[2] == ""))) {  // GET /location
            getAllLocationsHandler(w, r)
            
        } else if (r.Method == http.MethodGet && (len(items) == 3 || (len(items) == 4 && items[3] == ""))) {  // GET /location/{name}
            getCityWeatherHandler(w, r, items[2])
        
        } else if (r.Method == http.MethodDelete && len(items) == 3) {  // DELETE /location/{name}
            deleteCityHandler(w, r, items[2])
        
        } else {
            w.WriteHeader(http.StatusNotFound)
            fmt.Fprintf(w, "404 Not Found: %s", r.URL.Path)
        }
    } else {
        w.WriteHeader(http.StatusNotFound)
            fmt.Fprintf(w, "404 Not Found: %s", r.URL.Path)
    }
}

3. model.go

package main 

import (
    "os"
    "fmt"
    "time"
    "regexp"
    "net/http"
    "io/ioutil"
    "database/sql"
    "encoding/json"
)

const weatherTable string = "city_weather"
const timeOutSeconds int64 = 3600
const OpenWeatherURL string = "http://api.openweathermap.org/data/2.5/weather"
const AppID string = "xxxxxxxxxxxxxxxxxxxxxxx"

var gopath string
var dbpath string

type CityName struct {  // for Unmarshal HTTP Request Body
    Name    string
}

type CityWeather struct {   // for Database
    Id          int64   // primary key, auto increment
    Name        string  // city name, UNIQUE
    Main        string  // main in weather
    Description string  // description in weather
    Icon        string  // icon in weather
    Wid         int64   // id in weather
    TimeStamp   int64   // timestamp when updating
}

type WeatherReport struct {
    Id      int64       `json:"id"`
    Main    string      `json:"main"`
    Description string  `json:"description"`
    Icon    string      `json:"icon"`
}

type ReportResult struct {  // for HTTP Response
    Weather    []WeatherReport  `json:"weather"`
}


func checkErr(err error) {
    if err != nil {
        panic(err)
    }
}


func init() {
    InitializeDatabase()
}


func InitializeDatabase() {
    gopath = os.Getenv("GOPATH")
    dbpath = gopath + "/bin/weather.db"
    
    db, err := sql.Open("sqlite3", dbpath)
    defer db.Close()
    checkErr(err)

    createTable := fmt.Sprintf("CREATE TABLE IF NOT EXISTS `%s` (`id` integer NOT NULL PRIMARY KEY AUTOINCREMENT, `name` varchar(255) NOT NULL DEFAULT ''  UNIQUE, `main` varchar(255) NOT NULL DEFAULT '' , `description` varchar(255) NOT NULL DEFAULT '' , `icon` varchar(255) NOT NULL DEFAULT '' , `wid` integer NOT NULL DEFAULT 0 , `time_stamp` integer NOT NULL DEFAULT 0);", weatherTable)
    
    _, err = db.Exec(createTable)
    checkErr(err)
}


// For "POST /location"
func AddOneCity(city string) (respCode int, err error) {
    db, err := sql.Open("sqlite3", dbpath)
    defer db.Close()
    if err != nil {
        return http.StatusInternalServerError, err
    }

    queryStr := fmt.Sprintf("SELECT name FROM %s WHERE name=?", weatherTable)    
    tmpName := ""
    db.QueryRow(queryStr, city).Scan(&tmpName)
    
    if tmpName != "" {    // result set is not empty
       respCode = http.StatusConflict   // 409
    } else {
        insertStr := fmt.Sprintf("INSERT INTO %s (`name`, `wid`, `time_stamp`) values (?, ?, ?)", weatherTable)

        stmt, err := db.Prepare(insertStr)
        if err != nil {
            return http.StatusInternalServerError, err
        } 

        _, err = stmt.Exec(city, -1, 0)
        if err != nil {
            return http.StatusInternalServerError, err
        } 

        respCode = http.StatusCreated   // 201
    }
    
    return respCode, err
}


// GET /location
func GetAllCities() (allCities []string, respCode int, err error) {
    allCities = []string{}
    
    db, err := sql.Open("sqlite3", dbpath)
    defer db.Close()
    if err != nil {
        return allCities, http.StatusInternalServerError, err
    }
    
    queryStr := fmt.Sprintf("SELECT name FROM %s", weatherTable)
    rows, err := db.Query(queryStr)
    if err != nil {
        return allCities, http.StatusInternalServerError, err
    }
    
    for rows.Next() {
        var cityName string
        err = rows.Scan(&cityName)
        if err != nil {
            return allCities, http.StatusInternalServerError, err
        }
        
        allCities = append(allCities, cityName)
    }
    
    return allCities, http.StatusOK, err
}


// DELETE /location/{name}
func DeleteOneCity(city string) (respCode int, err error) {
    db, err := sql.Open("sqlite3", dbpath)
    defer db.Close()
    if err != nil {
        return http.StatusInternalServerError, err
    } 
    
    execStr := fmt.Sprintf("DELETE FROM %s WHERE name=?", weatherTable)
    stmt, err := db.Prepare(execStr)
    if err != nil {
        return http.StatusInternalServerError, err
    } 
    _, err = stmt.Exec(city)
    if err != nil {
        return http.StatusInternalServerError, err
    } 
    
    return http.StatusOK, err
}


// GET /location/{name}
func GetOneCityWeather(city string) (result *ReportResult, respCode int, err error) {
    cw := new(CityWeather)
    result = new(ReportResult)

    db, err := sql.Open("sqlite3", dbpath)
    defer db.Close()
    if err != nil {
        return result, http.StatusInternalServerError, err
    }
    
    // Get data of the specified city from Database
    cw.Id = 0
    queryStr := fmt.Sprintf("SELECT id, name, main, description, icon, wid, time_stamp FROM %s WHERE name=?", weatherTable)    
    db.QueryRow(queryStr, city).Scan(&cw.Id, &cw.Name, &cw.Main, &cw.Description, &cw.Icon, &cw.Wid, &cw.TimeStamp)
    
    if cw.Id == 0 {
        return result, http.StatusNotFound, nil
    }
    
    currentTime := time.Now().UTC().UnixNano()
    passedSeconds := (currentTime - cw.TimeStamp) / 1e9
    
    if passedSeconds > timeOutSeconds {  // If older than one hour or the first get, need to update database
        client := &http.Client{}
        url := fmt.Sprintf("%s?q=%s&APPID=%s", OpenWeatherURL, city, AppID)
        reqest, err := http.NewRequest("GET", url, nil)
        if err != nil {
            return result, http.StatusServiceUnavailable, err    // 503
        }
        
        response, err := client.Do(reqest)
        defer response.Body.Close()
        
        if err != nil {
            return result, http.StatusServiceUnavailable, err   // 503
        } else {   // Get Response from openweather!!
            body, err := ioutil.ReadAll(response.Body)
            if err != nil {
                return result, http.StatusInternalServerError, err  // 500
            }
            
            bodyStr := string(body)
            
            // get "weather" part as string
            reg := regexp.MustCompile(`"weather":(\[.+\])`)
            ws := (reg.FindStringSubmatch(bodyStr))[1]
            
            // convert "weather" string to bytes
            tmpBytes := make([]byte, len(ws))
            copy(tmpBytes[:], ws)
            
            // Unmarshal the bytes to ReportResult.Weather
            var rcds []WeatherReport
            json.Unmarshal(tmpBytes, &rcds)
            result.Weather = rcds
            
            // update cw
            cw.Wid         = rcds[0].Id
            cw.Main        = rcds[0].Main
            cw.Description = rcds[0].Description
            cw.Icon        = rcds[0].Icon
            cw.TimeStamp   = currentTime

            // Update Database
            updateStr := fmt.Sprintf("UPDATE %s SET wid=?, main=?, description=?, icon=?, time_stamp=? WHERE name=?", weatherTable)
            stmt, err := db.Prepare(updateStr)
            if err != nil {
                return result, http.StatusInternalServerError, err
            }

            _, err = stmt.Exec(cw.Wid, cw.Main, cw.Description, cw.Icon, cw.TimeStamp, city)
            if err != nil {
                return result, http.StatusInternalServerError, err
            }
        }
    } else {    // If shorter than timeOutSeconds, get the data from Database
        var item WeatherReport
        item.Id          = cw.Wid
        item.Main        = cw.Main
        item.Icon        = cw.Icon
        item.Description = cw.Description
        
        result.Weather = []WeatherReport{item}
    }
    
    return result, http.StatusOK, nil
}

4. model_test.go

package main

import (
    "testing"
    "net/http"
)

const sampleCityName string = "Shanghai"


func reportFailure(t *testing.T, respCode int, err error) {
    if respCode != http.StatusOK || err != nil {
        t.Errorf("Test Faield: respCode = %d, err = %v", respCode, err)
    }
}

func Test_DeleteOneCity(t *testing.T) {
    respCode, err := DeleteOneCity(sampleCityName)
    reportFailure(t, respCode, err)
}

func Test_AddOneCity(t *testing.T) {
    respCode, err := AddOneCity(sampleCityName)
    if respCode != http.StatusCreated || err != nil {   // 201
        t.Errorf("Test Failed when adding %s for the first time: respCode = %d, err = %v", sampleCityName, respCode, err)
    }
    
    respCode, err = AddOneCity(sampleCityName)
    if respCode != http.StatusConflict || err != nil {   // 409
        t.Errorf("Test Failed when adding %s for the second time: respCode = %d, err = %v", sampleCityName, respCode, err)
    }
}


func Test_GetAllCities(t *testing.T) {
    allCities, respCode, err := GetAllCities()
    reportFailure(t, respCode, err)
    
    found := false
    for _,v := range(allCities) {
        if v == sampleCityName {
            found = true
            break
        }
    }
    if found == false {
        t.Errorf("Test Faield due to no expected city")
    }
}


func Test_GetOneCityWeather(t *testing.T) {
    result, respCode, err := GetOneCityWeather(sampleCityName)
    reportFailure(t, respCode, err)
    
    if result == nil || result.Weather == nil || len(result.Weather) == 0 {
        t.Errorf("Test Failed: returned result = %v", result)
    }
}

对了，run test的时候只要在该文件夹下跑一句"go test -v"即可。当然，如果跑“go test -cover”，那么就可以看到代码覆盖率了。

最后，笔者思考了一下有哪些不足之处，以遍日后改进，大约如下：

1. 在做model.go的单元测试时，没有去mock数据库的行为。那么应该怎么做呢？笔者没有仔细去研究了，大约是可以利用这个第三方的库吧：https://github.com/DATA-DOG/go-sqlmock

2. 没有写controller.go的单元测试。该怎么写呢？首先那么些个controller函数最后都是写到web上的，但其实它们调用的是一个接口 -- http.ResponseWriter,所以，我们只要fake几个http.Request作为输入参数，再mock这个http.ResponseWriter接口，将其原本写入到web的数据写入到另一个地方（文件或channel？），再从这个地方将数据取出来和期望值做对比，应该就可以实现了。

以上是笔者作为一个golang菜鸟的一些个人想法了。

（完）

---