func testGenerated(t *testing.T, path string) { cb := tests.New().Path(path).Jauto().Sauto(parser.Parse) pi, err := parser.Parse(cb.Ctx(), path) require.NoError(t, err) generatedBytes, err := generate.Structs(cb.Ctx(), pi.Env) require.NoError(t, err) generatedString := string(generatedBytes) existingFilePath := filepath.Join(pi.Dir, "generated.go") existingBytes, err := ioutil.ReadFile(existingFilePath) require.NoError(t, err) existingString := string(existingBytes) // TODO: The "goimports" tool will often re-order the imports, so this is // a kludge to remove it before comparing. This is not ideal! importsRegex := regexp.MustCompile(`(?ms:\nimport \(\n.*\n\)\n)`) generatedString = importsRegex.ReplaceAllString(generatedString, "-") existingString = importsRegex.ReplaceAllString(existingString, "-") if generatedString != existingString { fmt.Println("Generated code for " + path + " is not what is present:") fmt.Println(generatedString) } require.Equal(t, generatedString, existingString) }
// Generate generates the source code for type structs, and writes the // generated.go to the filesystem. func Generate(ctx context.Context, env *envctx.Env) error { wgctx.Add(ctx, "Generate") defer wgctx.Done(ctx, "Generate") cmd := cmdctx.FromContext(ctx) cmd.Printf("Generating types for %s... ", env.Path) outputDir := env.Dir filename := "generated.go" source, err := generate.Structs(ctx, env) if err != nil { return kerr.Wrap("XFNESBLBTQ", err) } // We only backup in the system structs and types files because they are // the only generated files we ever need to roll back backup := env.Path == "kego.io/system" if err = save(outputDir, source, filename, backup); err != nil { return kerr.Wrap("UONJTTSTWW", err) } else { cmd.Println("OK.") } return nil }
func InitialiseAndGenerate(t *testing.T, cb *tests.ContextBuilder, name string, files map[string]string) (string, error) { path, _ := cb.TempPackage(name, files) ctx, _, err := process.Initialise(cb.Ctx(), &process.Options{ Path: path, }) if err != nil { return "", err } cb.SetCtx(ctx) source, err := generate.Structs(ctx, cb.Env()) if err != nil { return "", err } return string(source), nil }
func TestParse(t *testing.T) { cb := tests.New().TempGopath(true) defer cb.Cleanup() files := map[string]string{ "a.json": `{ "type": "system:type", "id": "a", "rule": { "type": "system:type", "embed": ["system:rule"], "fields": { "a": { "type": "system:@bool" } } } }`, "b.json": `{ "type": "system:type", "id": "b", "fields": { "c": { "type": "@a", "a": true, "optional": true }, "d": { "type": "@b" } } }`, } path, dir := cb.TempPackage("a", files) path = "kego.io/system" cb.Path(path).Dir(dir).Cmd().Sempty().Jsystem() pi, err := Parse(cb.Ctx(), path) require.NoError(t, err) _, err = generate.Structs(cb.Ctx(), pi.Env) require.NoError(t, err) }
func TestGenerateSourceNoTypes(t *testing.T) { cb := tests.Context("a.b/c").Spkg("a.b/c") _, err := generate.Structs(cb.Ctx(), cb.Env()) require.NoError(t, err) }
func TestGenerateSourceErr1(t *testing.T) { cb := tests.Context("a.b/c").Sempty() _, err := generate.Structs(cb.Ctx(), cb.Env()) assert.IsError(t, err, "DQVQWTKRSK") }