// generateFormatExample returns a random example based on the format the user asks.
func (eg *exampleGenerator) generateFormatExample() interface{} {
if !eg.hasFormatValidation() {
return nil
}
format := eg.a.Validation.Format
if res, ok := map[string]interface{}{
"email": eg.r.faker.Email(),
"hostname": eg.r.faker.DomainName() + "." + eg.r.faker.DomainSuffix(),
"date-time": time.Unix(int64(eg.r.Int())%1454957045, 0).Format(time.RFC3339), // to obtain a "fixed" rand
"ipv4": eg.r.faker.IPv4Address().String(),
"ipv6": eg.r.faker.IPv6Address().String(),
"uri": eg.r.faker.URL(),
"mac": func() string {
res, err := regen.Generate(`([0-9A-F]{2}-){5}[0-9A-F]{2}`)
if err != nil {
return "12-34-56-78-9A-BC"
}
return res
}(),
"cidr": "192.168.100.14/24",
"regexp": eg.r.faker.Characters(3) + ".*",
}[format]; ok {
return res
}
panic("Validation: unknown format '" + format + "'") // bug
}
// generateValidatedPatternExample generates a random value that satisifies the pattern. Note: if
// multiple patterns are given, only one of them is used. currently, it doesn't support multiple.
func (eg *exampleGenerator) generateValidatedPatternExample() interface{} {
if !eg.hasPatternValidation() {
return false
}
pattern := eg.a.Validation.Pattern
example, err := regen.Generate(pattern)
if err != nil {
return eg.r.faker.Name()
}
return example
}
// generateValidatedPatternExample generates a random value that satisifies the pattern. Note: if
// multiple patterns are given, only one of them is used. currently, it doesn't support multiple.
func (eg *exampleGenerator) generateValidatedPatternExample() interface{} {
for _, v := range eg.a.Validations {
if actual, ok := v.(*dslengine.PatternValidationDefinition); ok {
example, err := regen.Generate(actual.Pattern)
if err != nil {
return eg.r.faker.Name()
}
return example
}
}
return nil
}
// Example returns a random instance of the attribute that validates.
func (a *AttributeDefinition) Example(r *RandomGenerator) interface{} {
randomValidationLengthExample := func(count int) interface{} {
if a.Type.IsArray() {
res := make([]interface{}, count)
for i := 0; i < count; i++ {
res[i] = a.Type.ToArray().ElemType.Example(r)
}
return res
}
return r.faker.Characters(count)
}
randomLengthExample := func(validExample func(res float64) bool) interface{} {
if a.Type.Kind() == IntegerKind {
res := r.Int()
for !validExample(float64(res)) {
res = r.Int()
}
return res
}
res := r.Float64()
for !validExample(res) {
res = r.Float64()
}
return res
}
for _, v := range a.Validations {
switch actual := v.(type) {
case *EnumValidationDefinition:
count := len(actual.Values)
i := r.Int() % count
return actual.Values[i]
case *FormatValidationDefinition:
if res, ok := map[string]interface{}{
"email": r.faker.Email(),
"hostname": r.faker.DomainName() + "." + r.faker.DomainSuffix(),
"date-time": time.Now().Format(time.RFC3339),
"ipv4": r.faker.IPv4Address().String(),
"ipv6": r.faker.IPv6Address().String(),
"uri": r.faker.URL(),
"mac": func() string {
res, err := regen.Generate(`([0-9A-F]{2}-){5}[0-9A-F]{2}`)
if err != nil {
return "12-34-56-78-9A-BC"
}
return res
}(),
"cidr": "192.168.100.14/24",
"regexp": r.faker.Characters(3) + ".*",
}[actual.Format]; ok {
return res
}
panic("unknown format") // bug
case *PatternValidationDefinition:
res, err := regen.Generate(actual.Pattern)
if err != nil {
return r.faker.Name()
}
return res
case *MinimumValidationDefinition:
return randomLengthExample(func(res float64) bool {
return res >= actual.Min
})
case *MaximumValidationDefinition:
return randomLengthExample(func(res float64) bool {
return res <= actual.Max
})
case *MinLengthValidationDefinition:
count := actual.MinLength + (r.Int() % 3)
return randomValidationLengthExample(count)
case *MaxLengthValidationDefinition:
count := actual.MaxLength - (r.Int() % 3)
return randomValidationLengthExample(count)
}
}
return a.Type.Example(r)
}