func TestTypeResolver_AdditionalItems(t *testing.T) {
_, resolver, err := basicTaskListResolver(t)
tpe := spec.StringProperty()
if assert.NoError(t, err) {
// arrays of primitives and string formats with additional formats
for _, val := range schTypeVals {
var sch spec.Schema
sch.Typed(val.Type, val.Format)
var coll spec.Schema
coll.Type = []string{"array"}
coll.Items = new(spec.SchemaOrArray)
coll.Items.Schema = tpe
coll.AdditionalItems = new(spec.SchemaOrBool)
coll.AdditionalItems.Schema = &sch
rt, err := resolver.ResolveSchema(&coll, true)
if assert.NoError(t, err) && assert.True(t, rt.IsArray) {
assert.True(t, rt.HasAdditionalItems)
assert.False(t, rt.IsNullable)
//if assert.NotNil(t, rt.ElementType) {
//assertPrimitiveResolve(t, "string", "", "string", *rt.ElementType)
//}
}
}
}
}
func setSchemaType(s *spec.Schema, f *descriptor.Field) {
if f.GetLabel() == godesc.FieldDescriptorProto_LABEL_REPEATED {
s.Type = spec.StringOrArray([]string{"array"})
items := new(spec.Schema)
if f.GetType() == godesc.FieldDescriptorProto_TYPE_MESSAGE {
items.Ref = messageRef(f.Message)
} else {
ty, format := toSwaggerType(f.GetType())
items.Type = spec.StringOrArray([]string{ty})
items.Format = format
}
s.Items = &spec.SchemaOrArray{Schema: items}
return
}
if f.GetType() == godesc.FieldDescriptorProto_TYPE_MESSAGE {
s.Ref = messageRef(f.Message)
return
}
ty, format := toSwaggerType(f.GetType())
s.Type = spec.StringOrArray([]string{ty})
s.Format = format
}
func bodyTypable(in string, schema *spec.Schema) (swaggerTypable, *spec.Schema) {
if in == "body" {
// get the schema for items on the schema property
if schema == nil {
schema = new(spec.Schema)
}
if schema.Items == nil {
schema.Items = new(spec.SchemaOrArray)
}
if schema.Items.Schema == nil {
schema.Items.Schema = new(spec.Schema)
}
schema.Typed("array", "")
return schemaTypable{schema.Items.Schema, 0}, schema
}
return nil, nil
}
func TestTypeResolver_TupleTypes(t *testing.T) {
_, resolver, err := basicTaskListResolver(t)
if assert.NoError(t, err) {
// tuple type (items with multiple schemas)
parent := new(spec.Schema)
parent.Typed("array", "")
parent.Items = new(spec.SchemaOrArray)
parent.Items.Schemas = append(
parent.Items.Schemas,
*spec.StringProperty(),
*spec.Int64Property(),
*spec.Float64Property(),
*spec.BoolProperty(),
*spec.ArrayProperty(spec.StringProperty()),
*spec.RefProperty("#/definitions/Comment"),
)
rt, err := resolver.ResolveSchema(parent, true)
if assert.NoError(t, err) {
assert.False(t, rt.IsArray)
assert.True(t, rt.IsTuple)
}
}
}