func createTestMethod(resource *design.ResourceDefinition, action *design.ActionDefinition, response *design.ResponseDefinition, route *design.RouteDefinition, routeIndex int, mediaType *design.MediaTypeDefinition, view *design.ViewDefinition) TestMethod {
routeNameQualifier := suffixRoute(action.Routes, routeIndex)
viewNameQualifier := func() string {
if view != nil && view.Name != "default" {
return view.Name
}
return ""
}()
method := TestMethod{}
method.Name = fmt.Sprintf("%s%s%s%s%s", codegen.Goify(action.Name, true), codegen.Goify(resource.Name, true), codegen.Goify(response.Name, true), routeNameQualifier, codegen.Goify(viewNameQualifier, true))
method.ActionName = codegen.Goify(action.Name, true)
method.ResourceName = codegen.Goify(resource.Name, true)
method.Comment = fmt.Sprintf("test setup")
method.ControllerName = fmt.Sprintf("%s.%sController", TargetPackage, codegen.Goify(resource.Name, true))
method.ContextVarName = fmt.Sprintf("%sCtx", codegen.Goify(action.Name, false))
method.ContextType = fmt.Sprintf("%s.New%s%sContext", TargetPackage, codegen.Goify(action.Name, true), codegen.Goify(resource.Name, true))
method.RouteVerb = route.Verb
method.Status = response.Status
method.FullPath = goPathFormat(route.FullPath())
if view != nil && mediaType != nil {
p, _, err := mediaType.Project(view.Name)
if err != nil {
panic(err)
}
tmp := codegen.GoTypeName(p, nil, 0, false)
if !p.IsBuiltIn() {
tmp = fmt.Sprintf("%s.%s", TargetPackage, tmp)
}
validate := codegen.RecursiveChecker(p.AttributeDefinition, false, false, false, "payload", "raw", 1, true)
returnType := ObjectType{}
returnType.Type = tmp
returnType.Pointer = "*"
returnType.Validatable = validate != ""
method.ReturnType = &returnType
}
if len(route.Params()) > 0 {
var params = []ObjectType{}
for _, paramName := range route.Params() {
for name, att := range action.Params.Type.ToObject() {
if name == paramName {
param := ObjectType{}
param.Name = codegen.Goify(name, false)
param.Type = codegen.GoTypeRef(att.Type, nil, 0, false)
if att.Type.IsPrimitive() && action.Params.IsPrimitivePointer(name) {
param.Pointer = "*"
}
params = append(params, param)
}
}
}
method.Params = params
}
if action.Payload != nil {
payload := ObjectType{}
payload.Name = "payload"
payload.Type = fmt.Sprintf("%s.%s", TargetPackage, codegen.Goify(action.Payload.TypeName, true))
if !action.Payload.IsPrimitive() && !action.Payload.IsArray() && !action.Payload.IsHash() {
payload.Pointer = "*"
}
validate := codegen.RecursiveChecker(action.Payload.AttributeDefinition, false, false, false, "payload", "raw", 1, true)
if validate != "" {
payload.Validatable = true
}
method.Payload = &payload
}
return method
}
})
Describe("ValidationChecker", func() {
Context("given an attribute definition and validations", func() {
var attType design.DataType
var validation *dslengine.ValidationDefinition
att := new(design.AttributeDefinition)
target := "val"
context := "context"
var code string // generated code
JustBeforeEach(func() {
att.Type = attType
att.Validation = validation
code = codegen.RecursiveChecker(att, false, false, target, context, 1)
})
Context("of enum", func() {
BeforeEach(func() {
attType = design.Integer
validation = &dslengine.ValidationDefinition{
Values: []interface{}{1, 2, 3},
}
})
It("produces the validation go code", func() {
Ω(code).Should(Equal(enumValCode))
})
})
func (g *Generator) createTestMethod(resource *design.ResourceDefinition, action *design.ActionDefinition,
response *design.ResponseDefinition, route *design.RouteDefinition, routeIndex int,
mediaType *design.MediaTypeDefinition, view *design.ViewDefinition) *TestMethod {
var (
actionName, ctrlName, varName string
routeQualifier, viewQualifier, respQualifier string
comment string
returnType *ObjectType
payload *ObjectType
)
actionName = codegen.Goify(action.Name, true)
ctrlName = codegen.Goify(resource.Name, true)
varName = codegen.Goify(action.Name, false)
routeQualifier = suffixRoute(action.Routes, routeIndex)
if view != nil && view.Name != "default" {
viewQualifier = codegen.Goify(view.Name, true)
}
respQualifier = codegen.Goify(response.Name, true)
hasReturnValue := view != nil && mediaType != nil
if hasReturnValue {
p, _, err := mediaType.Project(view.Name)
if err != nil {
panic(err) // bug
}
tmp := codegen.GoTypeName(p, nil, 0, false)
if !p.IsError() {
tmp = fmt.Sprintf("%s.%s", g.Target, tmp)
}
validate := codegen.RecursiveChecker(p.AttributeDefinition, false, false, false, "payload", "raw", 1, false)
returnType = &ObjectType{}
returnType.Type = tmp
if p.IsObject() && !p.IsError() {
returnType.Pointer = "*"
}
returnType.Validatable = validate != ""
}
comment = "runs the method " + actionName + " of the given controller with the given parameters"
if action.Payload != nil {
comment += " and payload"
}
comment += ".\n// It returns the response writer so it's possible to inspect the response headers"
if hasReturnValue {
comment += " and the media type struct written to the response"
}
comment += "."
if action.Payload != nil {
payload = &ObjectType{}
payload.Name = "payload"
payload.Type = fmt.Sprintf("%s.%s", g.Target, codegen.Goify(action.Payload.TypeName, true))
if !action.Payload.IsPrimitive() && !action.Payload.IsArray() && !action.Payload.IsHash() {
payload.Pointer = "*"
}
validate := codegen.RecursiveChecker(action.Payload.AttributeDefinition, false, false, false, "payload", "raw", 1, false)
if validate != "" {
payload.Validatable = true
}
}
return &TestMethod{
Name: fmt.Sprintf("%s%s%s%s%s", actionName, ctrlName, respQualifier, routeQualifier, viewQualifier),
ActionName: actionName,
ResourceName: ctrlName,
Comment: comment,
Params: pathParams(action, route),
QueryParams: queryParams(action),
Payload: payload,
ReturnType: returnType,
ControllerName: fmt.Sprintf("%s.%sController", g.Target, ctrlName),
ContextVarName: fmt.Sprintf("%sCtx", varName),
ContextType: fmt.Sprintf("%s.New%s%sContext", g.Target, actionName, ctrlName),
RouteVerb: route.Verb,
Status: response.Status,
FullPath: goPathFormat(route.FullPath()),
}
}
