Golang scm.Change类代码示例

// Run implements Check.
func (c *Coverage) Run(change scm.Change, options *Options) error {
	profile, err := c.RunProfile(change, options)
	if err != nil {
		return err
	}

	if c.UseGlobalInference {
		out, err := ProcessProfile(profile, &c.Global)
		if out != "" {
			log.Printf("coverage for %s:\n%s\n", change.Repo().Root(), out)
		}
		if err != nil {
			return fmt.Errorf("coverage for %s: %s", change.Repo().Root(), err)
		}
	} else {
		for _, testPkg := range change.Indirect().TestPackages() {
			p := profile.Subset(pkgToDir(testPkg))
			settings := c.SettingsForPkg(testPkg)
			if settings.MinCoverage == 0 {
				continue
			}
			out, err := ProcessProfile(p, settings)
			if out != "" {
				log.Printf("%s:\n%s\n", testPkg, out)
			}
			if err != nil {
				return fmt.Errorf("coverage for %s: %s", testPkg, err)
			}
		}
	}
	return nil
}

// RunProfile runs a coverage run according to the settings and return results.
func (c *Coverage) RunProfile(change scm.Change, options *Options) (profile CoverageProfile, err error) {
	// go test accepts packages, not files.
	var testPkgs []string
	if c.UseGlobalInference {
		testPkgs = change.All().TestPackages()
	} else {
		testPkgs = change.Indirect().TestPackages()
	}
	if len(testPkgs) == 0 {
		// Sir, there's no test.
		return nil, nil
	}

	tmpDir, err2 := ioutil.TempDir("", "pre-commit-go")
	if err2 != nil {
		return nil, err2
	}
	defer func() {
		err2 := internal.RemoveAll(tmpDir)
		if err == nil {
			err = err2
		}
	}()

	if c.UseGlobalInference {
		profile, err = c.RunGlobal(change, options, tmpDir)
	} else {
		profile, err = c.RunLocal(change, options, tmpDir)
	}
	if err != nil {
		return nil, err
	}

	if c.isGoverallsEnabled() {
		// Please send a pull request if the following doesn't work for you on your
		// favorite CI system.
		out, _, _, err2 := options.Capture(change.Repo(), "goveralls", "-coverprofile", filepath.Join(tmpDir, "profile.cov"))
		// Don't fail the build.
		if err2 != nil {
			fmt.Printf("%s", out)
		}
	}
	return profile, nil
}

// RunLocal runs all tests and reports the merged coverage of each individual
// covered package.
func (c *Coverage) RunLocal(change scm.Change, options *Options, tmpDir string) (CoverageProfile, error) {
	testPkgs := change.Indirect().TestPackages()
	type result struct {
		file string
		err  error
	}
	results := make(chan *result)
	for i, tp := range testPkgs {
		go func(index int, testPkg string) {
			settings := c.SettingsForPkg(testPkg)
			// Skip coverage if disabled for this directory.
			if settings.MinCoverage == 0 {
				results <- nil
				return
			}

			p := filepath.Join(tmpDir, fmt.Sprintf("test%d.cov", index))
			args := []string{
				"go", "test", "-v", "-covermode=count",
				"-coverprofile", p,
				"-timeout", fmt.Sprintf("%ds", options.MaxDuration),
				testPkg,
			}
			out, exitCode, duration, _ := options.Capture(change.Repo(), args...)
			if duration > time.Second {
				log.Printf("%s was slow: %s", args, round(duration, time.Millisecond))
			}
			if exitCode != 0 {
				results <- &result{err: fmt.Errorf("%s %s failed:\n%s", strings.Join(args, " "), testPkg, processStackTrace(out))}
				return
			}
			results <- &result{file: p}
		}(i, tp)
	}

	// Sends to coveralls.io if applicable. Do not write to disk unless needed.
	var f readWriteSeekCloser
	var err error
	if c.isGoverallsEnabled() {
		if f, err = os.Create(filepath.Join(tmpDir, "profile.cov")); err != nil {
			return nil, err
		}
	} else {
		f = &buffer{}
	}

	// Aggregate all results.
	counts := map[string]int{}
	for i := 0; i < len(testPkgs); i++ {
		result := <-results
		if err != nil {
			continue
		}
		if result == nil {
			continue
		}
		if result.err != nil {
			err = result.err
			continue
		}
		if err2 := loadRawCoverage(result.file, counts); err == nil {
			// Wait for all tests to complete before returning.
			err = err2
		}
	}
	if err != nil {
		f.Close()
		return nil, err
	}
	return loadMergeAndClose(f, counts, change)
}

// RunGlobal runs the tests under coverage with global inference.
//
// This means that test can contribute coverage in any other package, even
// outside their own package.
func (c *Coverage) RunGlobal(change scm.Change, options *Options, tmpDir string) (CoverageProfile, error) {
	coverPkg := ""
	for i, p := range change.All().Packages() {
		if s := c.SettingsForPkg(p); s.MinCoverage != 0 {
			if i != 0 {
				coverPkg += ","
			}
			coverPkg += p
		}
	}

	// This part is similar to Test.Run() except that it passes a unique
	// -coverprofile file name, so that all the files can later be merged into a
	// single file.
	testPkgs := change.All().TestPackages()
	type result struct {
		file string
		err  error
	}
	results := make(chan *result)
	for index, tp := range testPkgs {
		f := filepath.Join(tmpDir, fmt.Sprintf("test%d.cov", index))
		go func(f string, testPkg string) {
			// Maybe fallback to 'pkg + "/..."' and post process to remove
			// uninteresting directories. The rationale is that it will eventually
			// blow up the OS specific command argument length.
			args := []string{
				"go", "test", "-v", "-covermode=count", "-coverpkg", coverPkg,
				"-coverprofile", f,
				"-timeout", fmt.Sprintf("%ds", options.MaxDuration),
				testPkg,
			}
			out, exitCode, duration, err := options.Capture(change.Repo(), args...)
			if duration > time.Second {
				log.Printf("%s was slow: %s", args, round(duration, time.Millisecond))
			}
			if exitCode != 0 {
				err = fmt.Errorf("%s %s failed:\n%s", strings.Join(args, " "), testPkg, processStackTrace(out))
			}
			results <- &result{f, err}
		}(f, tp)
	}

	// Sends to coveralls.io if applicable. Do not write to disk unless needed.
	var f readWriteSeekCloser
	var err error
	if c.isGoverallsEnabled() {
		if f, err = os.Create(filepath.Join(tmpDir, "profile.cov")); err != nil {
			return nil, err
		}
	} else {
		f = &buffer{}
	}

	// Aggregate all results.
	counts := map[string]int{}
	for i := 0; i < len(testPkgs); i++ {
		result := <-results
		if err != nil {
			continue
		}
		if result.err != nil {
			err = result.err
			continue
		}
		if err2 := loadRawCoverage(result.file, counts); err == nil {
			// Wait for all tests to complete before returning.
			err = err2
		}
	}
	if err != nil {
		f.Close()
		return nil, err
	}
	return loadMergeAndClose(f, counts, change)
}