github.com/shogo82148/goa-v1@v1.6.2/goagen/gen_controller/generator_test.go

package gencontroller_test

import (
	"os"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
	"github.com/shogo82148/goa-v1/design"
	"github.com/shogo82148/goa-v1/goagen/codegen"
	gencontroller "github.com/shogo82148/goa-v1/goagen/gen_controller"
	"github.com/shogo82148/goa-v1/version"
)

var _ = Describe("Generate", func() {
	var workspace *codegen.Workspace
	var outDir string
	var pkg string
	var files []string
	var genErr error

	// TODO: remove it
	_ = pkg
	_ = files
	_ = genErr

	BeforeEach(func() {
		var err error
		workspace, err = codegen.NewWorkspace("test")
		Ω(err).ShouldNot(HaveOccurred())
		outDir, err = os.MkdirTemp(workspace.Path, "")
		Ω(err).ShouldNot(HaveOccurred())
		os.Args = []string{"goagen", "--out=" + outDir, "--design=foo", "--version=" + version.String()}
	})

	JustBeforeEach(func() {
		files, genErr = gencontroller.Generate()
	})

	AfterEach(func() {
		workspace.Delete()
	})

	Context("with a simple API", func() {
		BeforeEach(func() {
			design.Design = &design.APIDefinition{
				Name: "testapi",
				Resources: map[string]*design.ResourceDefinition{
					"foo": {
						Name: "foo",
						Actions: map[string]*design.ActionDefinition{
							"show": {
								Name: "show",
								Routes: []*design.RouteDefinition{
									{
										Verb: "GET",
										Path: "",
									},
								},
							},
						},
					},
				},
			}
			fooRes := design.Design.Resources["foo"]
			showAct := fooRes.Actions["show"]
			showAct.Parent = fooRes
			showAct.Routes[0].Parent = showAct
		})

		// It("generates a simple controller", func() {
		// 	Ω(genErr).Should(BeNil())
		// 	Ω(files).Should(HaveLen(1))
		// 	content, err := ioutil.ReadFile(filepath.Join(outDir, "foo.go"))
		// 	Ω(err).ShouldNot(HaveOccurred())
		// 	Ω(len(strings.Split(string(content), "\n"))).Should(BeNumerically(">=", 16))
		// })

		// Context("with --out", func() {
		// 	BeforeEach(func() {
		// 		var err error
		// 		outDir, err = ioutil.TempDir(workspace.Path, "foo")
		// 		Ω(err).ShouldNot(HaveOccurred())
		// 		os.Args = []string{"goagen", "--out=" + outDir, "--design=foo", "--version=" + version.String()}
		// 	})

		// 	It("generates a controller package named from --out", func() {
		// 		Ω(genErr).Should(BeNil())
		// 		Ω(files).Should(HaveLen(1))
		// 		content, err := ioutil.ReadFile(filepath.Join(outDir, "foo.go"))
		// 		Ω(err).ShouldNot(HaveOccurred())
		// 		Ω(string(content)).Should(HavePrefix("package foo"))
		// 	})

		// 	Context("with --pkg", func() {
		// 		BeforeEach(func() {
		// 			pkg = "bar"
		// 			os.Args = []string{"goagen", "--out=" + outDir, "--pkg", pkg, "--design=foo", "--version=" + version.String()}
		// 		})

		// 		It("generates a controller package named from --pkg", func() {
		// 			Ω(genErr).Should(BeNil())
		// 			Ω(files).Should(HaveLen(1))
		// 			content, err := ioutil.ReadFile(filepath.Join(outDir, "foo.go"))
		// 			Ω(err).ShouldNot(HaveOccurred())
		// 			Ω(string(content)).Should(HavePrefix("package bar"))
		// 		})
		// 	})
		// })

		// Context("without --out", func() {
		// 	BeforeEach(func() {
		// 		os.Args = []string{"goagen", "--out=" + outDir, "--design=foo", "--version=" + version.String()}
		// 	})

		// 	It("generates a controller package named from default", func() {
		// 		Ω(genErr).Should(BeNil())
		// 		Ω(files).Should(HaveLen(1))
		// 		content, err := ioutil.ReadFile(filepath.Join(outDir, "foo.go"))
		// 		Ω(err).ShouldNot(HaveOccurred())
		// 		Ω(string(content)).Should(HavePrefix("package main"))
		// 	})

		// 	Context("with --pkg", func() {
		// 		BeforeEach(func() {
		// 			pkg = "bar"
		// 			os.Args = []string{"goagen", "--out=" + outDir, "--pkg", pkg, "--design=foo", "--version=" + version.String()}
		// 		})

		// 		It("generates a controller package named from --pkg", func() {
		// 			Ω(genErr).Should(BeNil())
		// 			Ω(files).Should(HaveLen(1))
		// 			content, err := ioutil.ReadFile(filepath.Join(outDir, "foo.go"))
		// 			Ω(err).ShouldNot(HaveOccurred())
		// 			Ω(string(content)).Should(HavePrefix("package bar"))
		// 		})
		// 	})
		// })
	})
})

var _ = Describe("NewGenerator", func() {
	var generator *gencontroller.Generator

	var args = struct {
		api       *design.APIDefinition
		outDir    string
		designPkg string
		appPkg    string
		force     bool
		regen     bool
		pkg       string
		resource  string
		noExample bool
	}{
		api: &design.APIDefinition{
			Name: "test api",
		},
		outDir:    "out_dir",
		designPkg: "design",
		appPkg:    "app",
		pkg:       "controller",
		resource:  "controller",
		force:     false,
	}

	Context("with options all options set", func() {
		BeforeEach(func() {

			generator = gencontroller.NewGenerator(
				gencontroller.API(args.api),
				gencontroller.OutDir(args.outDir),
				gencontroller.DesignPkg(args.designPkg),
				gencontroller.AppPkg(args.appPkg),
				gencontroller.Pkg(args.pkg),
				gencontroller.Resource(args.resource),
				gencontroller.Force(args.force),
				gencontroller.Regen(args.regen),
			)
		})

		It("has all public properties set with expected value", func() {
			Ω(generator).ShouldNot(BeNil())
			Ω(generator.API.Name).Should(Equal(args.api.Name))
			Ω(generator.OutDir).Should(Equal(args.outDir))
			Ω(generator.DesignPkg).Should(Equal(args.designPkg))
			Ω(generator.AppPkg).Should(Equal(args.appPkg))
			Ω(generator.Pkg).Should(Equal(args.pkg))
			Ω(generator.Resource).Should(Equal(args.resource))
			Ω(generator.Force).Should(Equal(args.force))
			Ω(generator.Regen).Should(Equal(args.regen))
		})

	})
})