in internal/build/cmd/generate/commands/gentests/generator.go [621:926]
func (g *Generator) genAction(a Action, skipBody ...bool) {
// Initialize the request
g.w("\t\treq = opensearchapi." + a.Request() + "{\n")
// Pass the parameters
for k, v := range a.Params() {
// fmt.Printf("%s.%s: <%T> %v\n", a.Request(), k, v, v)
if strings.HasPrefix(fmt.Sprintf("%s", v), "$") {
v = `stash[` + strconv.Quote(strings.ReplaceAll(strings.ReplaceAll(fmt.Sprintf("%s", v), "{", ""), "}", "")) + `]`
}
switch v.(type) {
case bool:
g.w("\t\t\t" + k + ": ")
typ, ok := apiRegistry[a.Request()][k]
if !ok {
panic(fmt.Sprintf("%s.%s: field not found", a.Request(), k))
}
switch typ {
case "bool":
g.w(strconv.FormatBool(v.(bool)))
case "*bool":
g.w(`opensearchapi.BoolPtr(` + strconv.FormatBool(v.(bool)) + `)`)
case "string":
g.w(`"` + strconv.FormatBool(v.(bool)) + `"`)
case "[]string":
// TODO: Listify
g.w(`[]string{"` + strconv.FormatBool(v.(bool)) + `"}`)
default:
g.w(strconv.FormatBool(v.(bool)))
}
g.w(",\n")
case string:
if k == "Body" {
g.w("\t\t\t" + k + ": ")
body := v.(string)
if !strings.HasSuffix(body, "\n") {
body = body + "\n"
}
g.w("strings.NewReader(`" + body + "`)")
} else {
g.w("\t\t\t" + k + ": ")
// TODO: Handle comma separated strings as lists
// fmt.Printf("%s: %#v\n", a.Request(), apiRegistry[a.Request()])
// fmt.Printf("%s: %#v\n", k, apiRegistry[a.Request()][k])
typ, ok := apiRegistry[a.Request()][k]
if !ok {
panic(fmt.Sprintf("%s.%s: field not found", a.Request(), k))
}
var value string
if strings.HasPrefix(v.(string), "stash[") {
switch typ {
case "bool":
value = `fmt.Sprintf("%v", ` + v.(string) + `)`
case "string":
value = fmt.Sprintf("%s.(string)", v)
case "[]string":
// TODO: Comma-separated list => Quoted list
value = fmt.Sprintf(`[]string{%s.(string)}`, v)
case "int":
value = `func() int {
switch ` + v.(string) + `.(type) {
case int:
return ` + v.(string) + `.(int)
case float64:
return int(` + v.(string) + `.(float64))
}
case json.Number:
v, _ := ` + v.(string) + `.(encjson.Number).Int64()
vv := int(v)
return vv
panic(fmt.Sprintf(` + "`" + `Unexpected type %T for ` + v.(string) + "`" + `, ` + v.(string) + `))
}()`
case "*int":
value = `func() *int {
switch ` + v.(string) + `.(type) {
case int:
v := ` + v.(string) + `.(int)
return &v
case float64:
v := int(` + v.(string) + `.(float64))
return &v
case json.Number:
v, _ := ` + v.(string) + `.(encjson.Number).Int64()
vv := int(v)
return &vv
}
panic(fmt.Sprintf(` + "`" + `Unexpected type %T for ` + v.(string) + "`" + `, ` + v.(string) + `))
}()`
case "time.Duration":
value = `fmt.Sprintf("%d", ` + v.(string) + `)`
default:
panic(fmt.Sprintf("Unexpected type %q for value %v", typ, v))
}
} else {
switch typ {
case "[]string":
value = `[]string{` + fmt.Sprintf("%q", v) + `}`
case "time.Duration":
// re := regexp.MustCompile("^(\\d+).*")
// value = re.ReplaceAllString(fmt.Sprintf("%s", v), "$1")
inputValue := v.(string)
if strings.HasSuffix(inputValue, "d") {
inputValue = inputValue[:len(inputValue)-1]
numericValue, err := strconv.Atoi(inputValue)
if err != nil {
panic(fmt.Sprintf("Cannot convert duration [%s]: %s", inputValue, err))
}
// Convert to hours
inputValue = fmt.Sprintf("%dh", numericValue*24)
}
dur, err := time.ParseDuration(inputValue)
if err != nil {
panic(fmt.Sprintf("Cannot parse duration [%s]: %s", v, err))
}
value = fmt.Sprintf("%d", dur.Nanoseconds())
default:
if strings.HasSuffix(k, "ID") {
value = fmt.Sprintf("url.QueryEscape(%q)", v)
} else {
value = fmt.Sprintf("%q", v)
}
}
}
g.w(value)
}
g.w(",\n")
case int, *int, float64:
g.w("\t\t\t" + k + ": ")
typ, ok := apiRegistry[a.Request()][k]
if !ok {
panic(fmt.Sprintf("%s.%s: field not found", a.Request(), k))
}
var value string
switch typ {
case "string":
value = `"` + fmt.Sprintf("%d", v) + `"`
case "[]string":
value = `[]string{"` + fmt.Sprintf("%d", v) + `"}`
case "time.Duration":
re := regexp.MustCompile("^(\\d+).*")
value = re.ReplaceAllString(fmt.Sprintf("%d", v), "$1")
case "*int":
switch v.(type) {
case int:
g.w(`opensearchapi.IntPtr(` + fmt.Sprintf("%d", v) + `)`)
case float64:
if vv, ok := v.(float64); ok {
g.w(`opensearchapi.IntPtr(` + fmt.Sprintf("%d", int(vv)) + `)`)
}
default:
panic(fmt.Sprintf("Unexpected type [%T] for [%s]", v, k))
}
default:
value = fmt.Sprintf("%v", v)
}
g.w(value)
g.w(",\n")
case []interface{}:
g.w("\t\t\t" + k + ": ")
typ, ok := apiRegistry[a.Request()][k]
if !ok {
panic(fmt.Sprintf("%s.%s: field not found", a.Request(), k))
}
switch typ {
case "string":
switch v.(type) {
case string:
g.w("`" + v.(string) + "`")
case []interface{}:
vvv := make([]string, 0)
for _, vv := range v.([]interface{}) {
vvv = append(vvv, fmt.Sprintf("%s", vv))
}
g.w("`" + strings.Join(vvv, ",") + "`")
default:
panic(fmt.Sprintf("<%s> %s{}.%s: unexpected value <%T> %#v", typ, a.Request(), k, v, v))
}
case "[]string":
qv := make([]string, 0)
for _, vv := range v.([]interface{}) {
// TODO: Check type
qv = append(qv, fmt.Sprintf("%q", vv.(string)))
}
g.w(`[]string{` + strings.Join(qv, ",") + `}`)
case "io.Reader":
// Serialize Bulk payloads ...
if k == "Body" {
var b strings.Builder
for _, vv := range v.([]interface{}) {
switch vv.(type) {
case string:
b.WriteString(vv.(string))
default:
j, err := json.Marshal(convert(vv))
if err != nil {
panic(fmt.Sprintf("%s{}.%s: %s (%s)", a.Request(), k, err, v))
}
b.WriteString(string(j))
}
b.WriteString("\n")
}
b.WriteString("\n")
g.w("\t\tstrings.NewReader(`" + b.String() + "`)")
// ... or just convert the value to JSON
} else {
j, err := json.Marshal(convert(v))
if err != nil {
panic(fmt.Sprintf("%s{}.%s: %s (%s)", a.Request(), k, err, v))
}
g.w("\t\tstrings.NewReader(`" + fmt.Sprintf("%s", j) + "`)")
}
}
g.w(",\n")
case map[interface{}]interface{}:
g.w("\t\t\t" + k + ": ")
// vv := unstash(convert(v).(map[string]interface{}))
// fmt.Println(vv)
j, err := json.Marshal(convert(v))
if err != nil {
panic(fmt.Sprintf("JSON parse error: %s; %s", err, v))
} else {
// Unstash values
reStash := regexp.MustCompile(`("\$[^"]+")`)
j = reStash.ReplaceAll(j, []byte("` + strconv.Quote(fmt.Sprintf(\"%v\", stash[$1])) + `"))
g.w("\t\tstrings.NewReader(`" + fmt.Sprintf("%s", j) + "`)")
g.w(",\n")
}
default:
g.w(fmt.Sprintf("\t\t// TODO: %s (%v)\n", k, v))
}
}
if len(a.headers) > 0 {
if strings.Contains(a.headers["Accept"], "yaml") && strings.HasPrefix(a.Request(), "Cat") {
g.w("\t\t" + `Format: "yaml",` + "\n")
}
g.w("\t\tHeader: http.Header{\n")
for name, value := range a.headers {
if name == "Content-Type" && value == "application/json" {
continue
}
if name == "Authorization" {
auth_fields := strings.Split(value, " ")
auth_name := auth_fields[0]
auth_value := auth_fields[1]
if strings.HasPrefix(auth_value, "$") {
auth_value = `fmt.Sprintf("%s", stash["` + strings.ReplaceAll(strings.ReplaceAll(auth_value, "{", ""), "}", "") + `"])`
} else {
auth_value = `"` + auth_value + `"`
}
g.w("\t\t\t" + `"Authorization": []string{"` + auth_name + ` " + ` + auth_value + `},` + "\n")
} else {
g.w("\t\t\t\"" + name + "\": []string{\"" + value + "\"},\n")
}
}
g.w("\t\t},\n")
}
g.w("\t\t}\n\n")
// Get response
g.w("\t\tres, err = req.Do(context.Background(), client)\n")
g.w(` if err != nil {
t.Fatalf("ERROR: %s", err)
}
defer res.Body.Close()
`)
g.w("\n\n")
if len(a.catch) < 1 {
// Handle error responses
g.w(` handleResponseError(t, res)` + "\n")
} else {
// TODO: Test catch
}
if len(skipBody) < 1 || (len(skipBody) > 0 && skipBody[0] == false) {
// Read and parse the body
g.w(` handleResponseBody(t, res)` + "\n")
}
}