func (g *validation) generateTests(msg *generator.Descriptor, field *pb.FieldDescriptorProto, fieldName string, idx int, patterns map[string]string) {
if limbo.IsRequiredProperty(field) {
g.generateRequiredTest(msg, field, fieldName)
}
if n, ok := limbo.GetMinItems(field); ok {
g.generateMinItemsTest(msg, field, fieldName, int(n))
}
if n, ok := limbo.GetMaxItems(field); ok {
g.generateMaxItemsTest(msg, field, fieldName, int(n))
}
if pattern, ok := limbo.GetPattern(field); ok {
patternVar := fmt.Sprintf("valPattern_%s_%d", msg.GetName(), idx)
patterns[patternVar] = pattern
g.generatePatternTest(msg, field, fieldName, pattern, patternVar)
}
if n, ok := limbo.GetMinLength(field); ok {
g.generateMinLengthTest(msg, field, fieldName, int(n))
}
if n, ok := limbo.GetMaxLength(field); ok {
g.generateMaxLengthTest(msg, field, fieldName, int(n))
}
if field.GetType() == pb.FieldDescriptorProto_TYPE_MESSAGE {
g.generateSubMessageTest(msg, field, fieldName)
}
}
func (g *jsonschema) messageToSchema(file *generator.FileDescriptor, desc *generator.Descriptor) (interface{}, []string) {
typeName := file.GetPackage() + "." + strings.Join(desc.TypeName(), ".")
typeName = strings.TrimPrefix(typeName, ".")
title := desc.TypeName()[len(desc.TypeName())-1]
var (
dependencies []string
properties = make(map[string]interface{})
requiredProperties []string
)
for i, field := range desc.GetField() {
if field.OneofIndex != nil {
continue
}
f, dep := g.fieldToSchema(field)
if f == nil {
continue
}
if limbo.IsRequiredProperty(field) {
requiredProperties = append(requiredProperties, getJSONName(field))
}
{
comment := g.gen.Comments(fmt.Sprintf("%s,%d,%d", desc.Path(), 2, i))
comment = strings.TrimSpace(comment)
if comment != "" {
f["description"] = comment
}
}
properties[getJSONName(field)] = f
if dep != "" {
dependencies = append(dependencies, dep)
}
}
schema := map[string]interface{}{
"type": "object",
"properties": properties,
}
if len(requiredProperties) > 0 {
schema["required"] = requiredProperties
}
if len(desc.OneofDecl) > 0 {
allOffDefs := make([]interface{}, 0, 1+len(desc.OneofDecl))
oneOfDefs := make([][]interface{}, len(desc.OneofDecl))
for i, field := range desc.GetField() {
if field.OneofIndex == nil {
continue
}
oneofIndex := *field.OneofIndex
f, dep := g.fieldToSchema(field)
if f == nil {
continue
}
if field.IsRepeated() {
f = map[string]interface{}{
"type": "array",
"items": f,
}
}
{
comment := g.gen.Comments(fmt.Sprintf("%s,%d,%d", desc.Path(), 2, i))
comment = strings.TrimSpace(comment)
if comment != "" {
f["description"] = comment
}
}
def := map[string]interface{}{
"type": "object",
"properties": map[string]interface{}{
getJSONName(field): f,
},
"required": []string{getJSONName(field)},
}
oneOfDefs[oneofIndex] = append(oneOfDefs[oneofIndex], def)
if dep != "" {
dependencies = append(dependencies, dep)
}
}
allOffDefs = append(allOffDefs, schema)
for i, defs := range oneOfDefs {
def := map[string]interface{}{
"oneOf": defs,
}
{
comment := g.gen.Comments(fmt.Sprintf("%s,%d,%d", desc.Path(), 8, i))
comment = strings.TrimSpace(comment)
if comment != "" {
def["description"] = comment
}
}
allOffDefs = append(allOffDefs, def)
}
schema = map[string]interface{}{
"type": "object",
"allOf": allOffDefs,
}
}
{
comment := g.gen.Comments(desc.Path())
comment = strings.TrimSpace(comment)
if comment != "" {
schema["description"] = comment
}
}
{
schema["title"] = title
// schema["id"] = typeName
}
{
dependencies = uniqStrings(dependencies)
}
return schema, dependencies
}
