[検証中]更新のあったファイルだけgo testを走らせテストを高速化する #golang #gae

$ go version
go version go1.6.2 darwin/amd64
$ go test -coverprofile=~/Desktop/coverprofile fmt
ok      fmt     0.115s  coverage: 92.3% of statements
$ head ~/Desktop/coverprofile
mode: set
fmt/format.go:30.13,31.29 1 1
fmt/format.go:31.29,34.3 2 1
fmt/format.go:67.28,69.2 1 1
fmt/format.go:71.33,74.2 2 1
fmt/format.go:77.85,80.11 3 1
fmt/format.go:84.2,85.11 2 1
fmt/format.go:96.2,96.8 1 1
fmt/format.go:80.11,83.3 2 0
fmt/format.go:85.11,86.21 1 1

for PKG in `find $PJROOT -type d`
do
    goapp test -coverprofile=$PJROOT/$PKG/coverprofile $PKG
done

package main

import (
    "bufio"
    "bytes"
    "flag"
    "fmt"
    "go/build"
    "io/ioutil"
    "os"
    "path/filepath"
    "strings"
)

var (
    pjroot  string
    profile string
)

func init() {
    flag.StringVar(&pjroot, "pjroot", ".", "project root")
    flag.StringVar(&profile, "profile", "coverprofile", "coverprofile file name")
}

// files は.goファイルと_test.goファイルを抽出します。
func files() (gofiles, testfiles []string) {
    for _, f := range flag.Args() {
        if filepath.Ext(f) != ".go" {
            continue
        }

        if strings.HasSuffix(f, "_test.go") {
            testfiles = append(testfiles, f)
        } else {
            gofiles = append(gofiles, f)
        }
    }
    return
}

// DependencyFinder は任意のファイルが依存するパッケージを探す機能を提供します。
type DependencyFinder struct {
    pkgs         map[string]bool
    testfiles    []string
    gofiles      []string
    profiles     []string
    pjroot       string
    coverprofile string
    pfs          map[string]*bytes.Buffer
}

// NewDependencyFinder は新しい DependencyFinder を作成します。
func NewDependencyFinder(pjroot, coverprofile string, gofiles, testfiles []string) *DependencyFinder {
    return &DependencyFinder{
        pkgs:         map[string]bool{},
        testfiles:    testfiles,
        gofiles:      gofiles,
        pjroot:       pjroot,
        coverprofile: coverprofile,
    }
}

// packageFromTestFiles はテストファイルからそのテストファイルが対象としてパッケージを抽出します。
func (df *DependencyFinder) fromTestFiles() {

    for _, tf := range df.testfiles {
        path, err := filepath.Abs(tf)
        if err != nil {
            continue
        }
        dir := filepath.Dir(path)

        pkg, err := build.ImportDir(dir, build.FindOnly|build.IgnoreVendor)
        if err != nil {
            continue
        }

        df.pkgs[pkg.ImportPath] = true
    }
}

// findProfiles はプロファイルファイルを探します。
func (df *DependencyFinder) findProfiles() error {
    return filepath.Walk(df.pjroot, func(path string, info os.FileInfo, err error) error {
        if err != nil {
            return err
        }

        if !info.IsDir() && info.Name() == df.coverprofile {
            f, err := filepath.Rel(df.pjroot, path)
            if err != nil {
                return err
            }
            df.profiles = append(df.profiles, f)
        }
        return nil
    })
}

// fromProfiles は coverprofile から指定した.goファイルが依存するパッケージを取得します。
func (df *DependencyFinder) fromProfiles() error {

    df.pfs = map[string]*bytes.Buffer{}
    for _, gofile := range df.gofiles {
        for _, profile := range df.profiles {
            gf, err := filepath.Rel(df.pjroot, gofile)
            if err != nil {
                return err
            }

            pkg, err := df.dependPackage(gf, profile)
            if err != nil {
                return err
            }

            if pkg != "" {
                df.pkgs[pkg] = true
            }
        }
    }

    return nil
}

// dependPackage は coverprofile に指定したGoファイルが依存しているかどうか取得します。
// 依存している場合は、パッケージ名を取得します。
func (df *DependencyFinder) dependPackage(gf, pf string) (string, error) {
    buf, ok := df.pfs[pf]
    if !ok {
        b, err := ioutil.ReadFile(filepath.Join(df.pjroot, pf))
        if err != nil {
            return "", err
        }
        buf = bytes.NewBuffer(b)
        df.pfs[pf] = buf
    }

    defer buf.Reset()

    s := bufio.NewScanner(buf)
    for s.Scan() {
        if strings.Contains(s.Text(), gf) {
            pkg := filepath.Dir(pf)
            return pkg, nil
        }
    }

    return "", s.Err()
}

// Find はGoファイルに依存しているパッケージを取得します。
func (df *DependencyFinder) Find() ([]string, error) {

    df.fromTestFiles()

    if err := df.findProfiles(); err != nil {
        return nil, err
    }

    if err := df.fromProfiles(); err != nil {
        return nil, err
    }

    var pkgs []string
    for pkg := range df.pkgs {
        pkgs = append(pkgs, pkg)
    }

    return pkgs, nil
}

func main() {
    flag.Parse()

    gofiles, testfiles := files()

    df := NewDependencyFinder(pjroot, profile, gofiles, testfiles)
    pkgs, err := df.Find()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v", err)
        os.Exit(1)
    }

    for _, pkg := range pkgs {
        fmt.Println(pkg)
    }
}

$ go build -o deppkg deppkg.go

$ git diff --name-only | deppkg -pjroot=$PJROOT

#!/bin/sh

PJROOT=`dirname $0`/src
DEPPKG=`which deppkg`

for PKG in `git diff --name-only HEAD | xargs deppkg -pjroot $PJROOT`
do
    echo "start test for $PKG"
    go test -coverprofile=$PJROOT/$PKG/coverprofile $PKG
    if [ $? != 0 ]; then
        exit 1
    fi
done