[検証中]更新のあったファイルだけ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