func TestLoad(t *testing.T) {
expect := expect.New(t)
expect(func() {
packages.Load("foo")
}).To.Panic()
dirs := packages.Load(".")
expect(dirs).To.Have.Len(1)
wd, err := os.Getwd()
expect(err).To.Be.Nil()
expect(dirs[0].Path()).To.Equal(wd)
expect(dirs[0].Packages()).To.Have.Keys("packages", "packages_test")
dirs = packages.Load("github.com/nelsam/hel/mocks")
expect(dirs).To.Have.Len(1)
expectedPath := strings.TrimSuffix(wd, "packages") + "mocks"
expect(dirs[0].Path()).To.Equal(expectedPath)
dirs = packages.Load("github.com/nelsam/hel/...")
expect(dirs).To.Have.Len(4)
pkg, err := dirs[0].Import("path/filepath", "filepath")
expect(err).To.Be.Nil()
expect(pkg).Not.To.Be.Nil()
_, err = dirs[0].Import("path/filepath", "foo")
expect(err).Not.To.Be.Nil()
expect(err.Error()).To.Equal("Could not find package foo")
}
func init() {
output, err := exec.Command("which", "goimports").Output()
if err != nil {
fmt.Println("Could not locate goimports: ", err.Error())
fmt.Println("If goimports is not installed, please install it somewhere in your path. " +
"See https://godoc.org/golang.org/x/tools/cmd/goimports.")
os.Exit(1)
}
goimportsPath = strings.TrimSpace(string(output))
cmd = &cobra.Command{
Use: "hel",
Short: "A mock generator for Go",
Long: "A simple mock generator. The origin of the name is the Norse goddess, Hel, " +
"who guards over the souls of those unworthy to enter Valhalla. You can probably " +
"guess how much I like mocks.",
Run: func(cmd *cobra.Command, args []string) {
if len(args) > 0 {
fmt.Println("Invalid usage.\n")
err := cmd.Help()
if err != nil {
panic(err)
}
os.Exit(1)
}
packagePatterns, err := cmd.Flags().GetStringSlice("package")
if err != nil {
panic(err)
}
typePatterns, err := cmd.Flags().GetStringSlice("type")
if err != nil {
panic(err)
}
outputName, err := cmd.Flags().GetString("output")
if err != nil {
panic(err)
}
chanSize, err := cmd.Flags().GetInt("chan-size")
if err != nil {
panic(err)
}
blockingReturn, err := cmd.Flags().GetBool("blocking-return")
if err != nil {
panic(err)
}
fmt.Printf("Loading directories matching pattern"+pluralize(packagePatterns, "", "s")+" %v", packagePatterns)
var dirList []packages.Dir
progress(func() {
dirList = packages.Load(packagePatterns...)
})
fmt.Print("\n")
fmt.Println("Found directories:")
for _, dir := range dirList {
fmt.Println(" " + dir.Path())
}
fmt.Print("\n")
fmt.Printf("Loading interface types in matching directories")
var typeDirs types.Dirs
progress(func() {
godirs := make([]types.GoDir, 0, len(dirList))
for _, dir := range dirList {
godirs = append(godirs, dir)
}
typeDirs = types.Load(godirs...).Filter(typePatterns...)
})
fmt.Print("\n\n")
fmt.Printf("Generating mocks in output file %s", outputName)
progress(func() {
for _, typeDir := range typeDirs {
mockPath, err := makeMocks(typeDir, outputName, chanSize, blockingReturn)
if err != nil {
panic(err)
}
if mockPath != "" {
if err = exec.Command(goimportsPath, "-w", mockPath).Run(); err != nil {
panic(err)
}
}
}
})
fmt.Print("\n")
},
}
cmd.Flags().StringSliceP("package", "p", []string{"."}, "The package(s) to generate mocks for.")
cmd.Flags().StringSliceP("type", "t", []string{}, "The type(s) to generate mocks for. If no types "+
"are passed in, all exported interface types will be generated.")
cmd.Flags().StringP("output", "o", "helheim_test.go", "The file to write generated mocks to. Since hel does "+
"not generate exported types, this file will be saved directly in all packages with generated mocks. "+
"Also note that, since the types are not exported, you will want the file to end in '_test.go'.")
cmd.Flags().IntP("chan-size", "s", 100, "The size of channels used for method calls.")
cmd.Flags().BoolP("blocking-return", "b", false, "Always block when returning from mock even if there is no return value.")
}
