Golangでテストしやすいコードをかく

この記事は<a href="http://qiita.com/advent-calendar/2016/lifull">株式会社ネクスト(Lifull) Advent Calendar 2016</a>の2日目の記事です。

みなさんはじめまして、ネクストのchissoです。
はじめてQiitaに投稿するのでドキドキしています。

そんなことはさておき、この記事では、Golangで自動テストしやすいコードを書く方法について、私なりに気づいたことをまとめます。

## 想定読者
* 普段よくRSpecを書いている
* Golang初心者
* Interfaceってなに？

## 目指すところ
「メソッド単位でテストコードを実行できる状態にする」
これだけです。

私は普段Rubyを書くことが多く、RSpecを使ってメソッド単位でユニットテストを作成しています。
ですが、Rubyと同じ感覚でコードを書いて、RSpecと同じノリでGolangのテストを書こうとしてハマりました。
（静的型付けの言語・Interfaceに疎く、そもそもコードがダメすぎたことが原因でした。）

## GolangではRSpecのようにmock(stub)が作れない
言語仕様として当たり前なのですが、私がなにもわかっていなかった時代に書いていたGolangのコードを、Rubyのコードと比較しつつ進めていきます。

``` sample1.go
package main

import(
  "fmt"
)

type Hoge struct {
  hoge string
}

func main() {
  h := Hoge{"hogehoge"}
  echo(h)
}

func echo(h Hoge) string {
  str := h.getHoge()
  fmt.Println(str)
  return str
}

func (h Hoge) getHoge() string {
  return h.hoge
}
```

``` sample1.rb
class Main
  def initialize(hoge)
    @hoge_instance = hoge
  end

  def echo
    p @hoge_instance.get_hoge
  end
end

class Hoge
  def initialize(str)
    @hoge = str
  end

  def get_hoge
    @hoge 
  end
end
```

package/classの設計とか、Rubyでget_hogeってなんだよ、みたいなツッコミは一旦置いておいて、、

この両者において、echoのテストを書くことを考えてみます。
先にRSpecを使う前提でRubyから。

``` sample1_spec.rb

require './sample.rb'

describe Main do
  # とりあえずechoのテストだけ
  describe '#echo' do
    let(:hoge) { double('hoge') }
    let(:str) { 'hogehoge' }
    let(:target) { described_class.new(hoge) }

    subject { target.echo }

    before do
      # Hogeのメソッドはモックする
      allow(hoge).to receive(:get_hoge).and_return(str)
    end

    it 'get_hogeの値をpすること' do
      expect(target).to receive(:p).with(str)
      subject
    end
  end
end
```

ではGolangはというと・・・さきほどのsample1.goをベースにすると、**echoのユニットテストは書けません**。

Hogeというstruct、そしてgetHogeというメソッドを**上書きすることができない**ため、mockすることができないのです。

今回は簡単のため同一ファイル（package）内でstructを作成していますが、私は当初packageをまたいでこのようなコードを書いてしまっていました。
ユニットテストが書きたいのに、他のpackageの**実装**に依存したテストコードになってしまうのです。

日々悩み、ネットの海を徘徊し、辿り着いた答えが下記となります。

##解決策：  interfaceを使う
Golangを使い始めた最初は、なんでも突っ込める魔法のビンのように思っていたinterface{}。
interfaceの意味を理解して使いこなすことで、ユニットテスト可能なpackage（≒ class）を作れるようになれます。

Golangのinterfaceについては、下記の記事が詳しいです。

* <a href="http://qiita.com/tenntenn/items/eac962a49c56b2b15ee8">インタフェースの実装パターン #golang</a>

interfaceを使ってsample1.goを書き直してみます。

``` sample2.go
package main

import(
  "fmt"
)

// Hoge　structをラップするかたちでinterfaceを宣言
type HogeInterface interface {
  getHoge() string
}

type Hoge struct {
  hoge string
}

func main () {
  h := Hoge{"hogehoge"}
  echo(h)
}

// 引数をstructではなくinterfaceにする
func echo(h HogeInterface) string {
  str := h.getHoge()
  fmt.Println(str)
  return str
}

func (h Hoge) getHoge() string {
  return h.hoge
}
```

たったこれだけの変化で、echoがユニットテスト可能になります。

``` sample2_test.go
package main

import (
  "testing"
)

// Hogeのモックを宣言
// specの let(:hoge) { double('hogehoge') }に相当
type HogeMock struct {}

// HogeMockにgetHogeを実装
// specの allow(hoge).to receive(:get_hoge).and_return("hogehoge")に相当
func (h HogeMock) getHoge() string {
  return "hogehoge"
}

func TestEcho(t *testing.T) {
  mock := HogeMock{}
  hoge := echo(mock)

  if hoge != mock.getHoge() {
    t.Error("error!")
  }  
}

```

このようにstructをinterfaceでラップすることで、他のメソッドやpackageとの依存関係はその”振る舞い”（= interface）だけに留めることができ、各メソッドでユニットテストを作成することができるようになります。

これをやった上で、凝ったテストをやりたい場合にはテスト用のライブラリを使うとはかどります。
私はやはりRSpec風に書きたかったので、<a href="https://onsi.github.io/ginkgo/">ginkgo</a>というライブラリを使いました。

ただし、これだけでは対応できないパターンもあったので、テストしやすいコードを書く方法をもう一つご紹介しておきます。

##関数を変数化する
私は下記の記事でこの方法を学びました。
<a href="http://matope.hatenablog.com/entry/2014/08/14/111143">Golangで関数をグローバル変数に代入してテスト時にスタブする</a>

実際のコードに近い形で例を示します。
###API接続packageとmodel packageを切り離す
APIからデータを取得して整形する、modelに相当するようなpackageがあるとして、このmodelをテストする時は実際にAPIを叩きたくありません。
そこで、APIのclientを担うpackageを作成し、そのclientを使ってAPIを呼び出すメソッドを変数化しておきます。

```client.go
package client

import(
  "encoding/json"
  "io/ioutil"
  "net/http"
)

type clientInterface interface {
  buildUri(string, string) string
  buildQueryString(map[string]string) string
  getHttpClient() http.Client
}

type client struct {
  host    string
  port    int
  timeout int
}

var c clientInterface

func init() {
  c = &client{
    host:    "www.example.com",
    port:    80,
    timeout: 5,
  }
}

// APIからjsonでデータを受け取り、任意のstructにparseする
var Get = func (path string, params map[string]string, target interface{}) error {
  p := c.buildQueryString(params)
  uri := c.buildUri(path, p)
  httpClient := c.getHttpClient()

  response, err := httpClient.Get(uri)
  if err != nil {
    return err
  }
  defer response.Body.Close()

  body, err := ioutil.ReadAll(reponse.Body)
  if err != nil {
    return err
  }

  err = json.Unmarshall(body, &target)
  if err != nil {
    return err
  }

  return nil
}

// 以下、clientInterfaceはいい感じに実装します。
```

API接続packageをこのようにしておくことで、取得パスに応じたmodelの作成を行うことができます。（さらにPost/Delete/Putをapi.go内で作成する場合も同様）
そして、Getを下記のようにモックしてやれば、それぞれのmodelでテストが行えます。

```model_test.go
// modelのpackageで、上記client.goをclientとしてimportする想定。
// 変数として宣言したGetメソッドを上書きする
client.Get = func(path string, params map[string]string, target interface{}) error {
  j := `{"id": 1, "name": "chisso"}`
  json.Unmarshall(j, &target)
  return nil
}

// error時をテストしたいときも自在
client.Get = func(path string, params map[string]string, target interface{}) error {
  return errors.New("Not Found")
}
```
エラー時の再現が自在になる恩恵は大きいと思います。
clientで起こった各種errorをmodelできちんとハンドリングする場合に、モックしたGetメソッドで各種エラーを引き起こせるので、とてもテストしやすいです。

なお、client自身もinterface化しているので、Get自身もきちんとユニットテスト可能です。

また、複数のAPIを利用するような場合であれば、コンストラクタを変数として提供することでそれぞれうまくモックすることができます。

##まとめ
いかがでしたでしょうか。
interfaceをきちんと理解している人にとってはとても当たり前の話だったかもしれません。

ただ、もし自分のようにphpやRubyからプログラミングに入り、テストコード書いてたけどinterfaceの概念がうまく理解できてなかった人の助けになれば幸いです。

<a href="http://qiita.com/advent-calendar/2016/lifull">株式会社ネクスト(Lifull) Advent Calendar 2016</a>の<a href="http://qiita.com/zom/items/c72c7bac63462225971b">3日目の記事</a>は私の部署の先輩でもある<a href="http://qiita.com/zom">zomさん</a>です。
ご期待下さい！