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 TestTypeResolver_AnonymousStructs(t *testing.T) { _, resolver, err := basicTaskListResolver(t) if assert.NoError(t, err) { // anonymous structs should be accounted for parent := new(spec.Schema) parent.Typed("object", "") parent.Properties = make(map[string]spec.Schema) parent.Properties["name"] = *spec.StringProperty() parent.Properties["age"] = *spec.Int32Property() rt, err := resolver.ResolveSchema(parent, true) if assert.NoError(t, err) { assert.False(t, rt.IsNullable) assert.True(t, rt.IsAnonymous) assert.True(t, rt.IsComplexObject) } parent.Extensions = make(spec.Extensions) parent.Extensions["x-isnullable"] = true rt, err = resolver.ResolveSchema(parent, true) if assert.NoError(t, err) { assert.True(t, rt.IsNullable) assert.True(t, rt.IsAnonymous) assert.True(t, rt.IsComplexObject) } } }
func (sg *schemaGenContext) buildItems() error { presentsAsSingle := sg.Schema.Items != nil && sg.Schema.Items.Schema != nil if presentsAsSingle && sg.Schema.AdditionalItems != nil { // unsure if htis a valid of invalid schema return fmt.Errorf("single schema (%s) can't have additional items", sg.Name) } if presentsAsSingle { return sg.buildArray() } if sg.Schema.Items != nil { // This is a tuple, build a new model that represents this if sg.Named { sg.GenSchema.Name = sg.Name sg.GenSchema.GoType = swag.ToGoName(sg.Name) if sg.TypeResolver.ModelsPackage != "" { sg.GenSchema.GoType = sg.TypeResolver.ModelsPackage + "." + sg.GenSchema.GoType } for i, s := range sg.Schema.Items.Schemas { elProp := sg.NewTupleElement(&s, i) if err := elProp.makeGenSchema(); err != nil { return err } sg.MergeResult(elProp) elProp.GenSchema.Name = "p" + strconv.Itoa(i) sg.GenSchema.Properties = append(sg.GenSchema.Properties, elProp.GenSchema) } return nil } // for an anonoymous object, first build the new object // and then replace the current one with a $ref to the // new tuple object var sch spec.Schema sch.Typed("object", "") sch.Properties = make(map[string]spec.Schema) for i, v := range sg.Schema.Items.Schemas { sch.Required = append(sch.Required, "P"+strconv.Itoa(i)) sch.Properties["P"+strconv.Itoa(i)] = v } sch.AdditionalItems = sg.Schema.AdditionalItems tup := sg.makeNewStruct(sg.GenSchema.Name+"Tuple"+strconv.Itoa(sg.Index), sch) if err := tup.makeGenSchema(); err != nil { return err } tup.GenSchema.IsTuple = true tup.GenSchema.IsComplexObject = false tup.GenSchema.Title = tup.GenSchema.Name + " a representation of an anonymous Tuple type" tup.GenSchema.Description = "" sg.ExtraSchemas[tup.Name] = tup.GenSchema sg.Schema = *spec.RefProperty("#/definitions/" + tup.Name) if err := sg.makeGenSchema(); err != nil { return err } sg.MergeResult(tup) } return nil }
func TestTypeResolver_BasicTypes(t *testing.T) { _, resolver, err := basicTaskListResolver(t) if assert.NoError(t, err) { // primitives and string formats for _, val := range schTypeVals { sch := new(spec.Schema) sch.Typed(val.Type, val.Format) rt, err := resolver.ResolveSchema(sch, true) if assert.NoError(t, err) { assert.False(t, rt.IsNullable) assertPrimitiveResolve(t, val.Type, val.Format, val.Expected, rt) } } // arrays of primitives and string formats for _, val := range schTypeVals { var sch spec.Schema sch.Typed(val.Type, val.Format) rt, err := resolver.ResolveSchema(new(spec.Schema).CollectionOf(sch), true) if assert.NoError(t, err) { assert.True(t, rt.IsArray) } } // primitives and string formats for _, val := range schTypeVals { sch := new(spec.Schema) sch.Typed(val.Type, val.Format) sch.Extensions = make(spec.Extensions) sch.Extensions["x-isnullable"] = true rt, err := resolver.ResolveSchema(sch, true) if assert.NoError(t, err) { assert.True(t, rt.IsNullable, "expected %q (%q) to be nullable", val.Type, val.Format) assertPrimitiveResolve(t, val.Type, val.Format, val.Expected, rt) } } // arrays of primitives and string formats for _, val := range schTypeVals { var sch spec.Schema sch.Typed(val.Type, val.Format) sch.AddExtension("x-isnullable", true) rt, err := resolver.ResolveSchema(new(spec.Schema).CollectionOf(sch), true) if assert.NoError(t, err) { assert.True(t, rt.IsArray) } } } }
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) } } }
func TestTypeResolver_ObjectType(t *testing.T) { _, resolver, err := basicTaskListResolver(t) resolver.ModelName = "TheModel" defer func() { resolver.ModelName = "" }() if assert.NoError(t, err) { //very poor schema definitions (as in none) types := []string{"object", ""} for _, tpe := range types { sch := new(spec.Schema) sch.Typed(tpe, "") rt, err := resolver.ResolveSchema(sch, true) if assert.NoError(t, err) { assert.True(t, rt.IsMap) assert.False(t, rt.IsComplexObject) assert.Equal(t, "map[string]interface{}", rt.GoType) assert.Equal(t, "object", rt.SwaggerType) } sch.Properties = make(map[string]spec.Schema) var ss spec.Schema sch.Properties["tags"] = *(&ss).CollectionOf(*spec.StringProperty()) rt, err = resolver.ResolveSchema(sch, false) assert.True(t, rt.IsComplexObject) assert.False(t, rt.IsMap) assert.Equal(t, "models.TheModel", rt.GoType) assert.Equal(t, "object", rt.SwaggerType) sch.Properties = nil nsch := new(spec.Schema) nsch.Typed(tpe, "") nsch.AllOf = []spec.Schema{*sch} rt, err = resolver.ResolveSchema(nsch, false) if assert.NoError(t, err) { assert.True(t, rt.IsComplexObject) assert.False(t, rt.IsMap) assert.Equal(t, "models.TheModel", rt.GoType) assert.Equal(t, "object", rt.SwaggerType) } } sch := new(spec.Schema) rt, err := resolver.ResolveSchema(sch, true) if assert.NoError(t, err) { assert.True(t, rt.IsMap) assert.False(t, rt.IsComplexObject) assert.Equal(t, "map[string]interface{}", rt.GoType) assert.Equal(t, "object", rt.SwaggerType) } sch = new(spec.Schema) var sp spec.Schema sp.Typed("object", "") sch.AllOf = []spec.Schema{sp} rt, err = resolver.ResolveSchema(sch, true) if assert.NoError(t, err) { assert.True(t, rt.IsComplexObject) assert.False(t, rt.IsMap) assert.Equal(t, "models.TheModel", rt.GoType) assert.Equal(t, "object", rt.SwaggerType) } } }
func TestTypeResolver_AdditionalProperties(t *testing.T) { _, resolver, err := basicTaskListResolver(t) if assert.NoError(t, err) { // primitives as additional properties for _, val := range schTypeVals { sch := new(spec.Schema) sch.Typed(val.Type, val.Format) parent := new(spec.Schema) parent.AdditionalProperties = new(spec.SchemaOrBool) parent.AdditionalProperties.Schema = sch rt, err := resolver.ResolveSchema(parent, true) if assert.NoError(t, err) { assert.True(t, rt.IsMap) assert.False(t, rt.IsComplexObject) assert.Equal(t, "map[string]"+val.Expected, rt.GoType) assert.Equal(t, "object", rt.SwaggerType) } } // array of primitives as additional properties for _, val := range schTypeVals { sch := new(spec.Schema) sch.Typed(val.Type, val.Format) parent := new(spec.Schema) parent.AdditionalProperties = new(spec.SchemaOrBool) parent.AdditionalProperties.Schema = new(spec.Schema).CollectionOf(*sch) rt, err := resolver.ResolveSchema(parent, true) if assert.NoError(t, err) { assert.True(t, rt.IsMap) assert.False(t, rt.IsComplexObject) assert.Equal(t, "map[string][]"+val.Expected, rt.GoType) assert.Equal(t, "object", rt.SwaggerType) } } // refs as additional properties for _, val := range schRefVals { sch := new(spec.Schema) sch.Ref, _ = spec.NewRef("#/definitions/" + val.Type) parent := new(spec.Schema) parent.AdditionalProperties = new(spec.SchemaOrBool) parent.AdditionalProperties.Schema = sch rt, err := resolver.ResolveSchema(parent, true) if assert.NoError(t, err) { assert.True(t, rt.IsMap) assert.False(t, rt.IsComplexObject) assert.Equal(t, "map[string]"+val.Expected, rt.GoType) assert.Equal(t, "object", rt.SwaggerType) } } // when additional properties and properties present, it's a complex object // primitives as additional properties for _, val := range schTypeVals { sch := new(spec.Schema) sch.Typed(val.Type, val.Format) parent := new(spec.Schema) parent.Properties = make(map[string]spec.Schema) parent.Properties["id"] = *spec.Int32Property() parent.AdditionalProperties = new(spec.SchemaOrBool) parent.AdditionalProperties.Schema = sch rt, err := resolver.ResolveSchema(parent, true) if assert.NoError(t, err) { assert.True(t, rt.IsComplexObject) assert.False(t, rt.IsMap) assert.Equal(t, "map[string]"+val.Expected, rt.GoType) assert.Equal(t, "object", rt.SwaggerType) } } // array of primitives as additional properties for _, val := range schTypeVals { sch := new(spec.Schema) sch.Typed(val.Type, val.Format) parent := new(spec.Schema) parent.Properties = make(map[string]spec.Schema) parent.Properties["id"] = *spec.Int32Property() parent.AdditionalProperties = new(spec.SchemaOrBool) parent.AdditionalProperties.Schema = new(spec.Schema).CollectionOf(*sch) rt, err := resolver.ResolveSchema(parent, true) if assert.NoError(t, err) { assert.True(t, rt.IsComplexObject) assert.False(t, rt.IsMap) assert.Equal(t, "map[string][]"+val.Expected, rt.GoType) assert.Equal(t, "object", rt.SwaggerType) } } // refs as additional properties for _, val := range schRefVals { sch := new(spec.Schema) sch.Ref, _ = spec.NewRef("#/definitions/" + val.Type) parent := new(spec.Schema) parent.Properties = make(map[string]spec.Schema) parent.Properties["id"] = *spec.Int32Property() parent.AdditionalProperties = new(spec.SchemaOrBool) parent.AdditionalProperties.Schema = sch rt, err := resolver.ResolveSchema(parent, true) if assert.NoError(t, err) { assert.True(t, rt.IsComplexObject) assert.False(t, rt.IsMap) assert.Equal(t, "map[string]"+val.Expected, rt.GoType) assert.Equal(t, "object", rt.SwaggerType) } } } }