func TestSchemaAnalysis_SimpleSchema(t *testing.T) { for i, v := range append(knownSchemas, spec.ArrayProperty(nil), spec.MapProperty(nil)) { sch, err := Schema(SchemaOpts{Schema: v}) if assert.NoError(t, err, "failed to analyze schema at %d: %v", i, err) { assert.True(t, sch.IsSimpleSchema, "item at %d should be a simple schema", i) } asch, err := Schema(SchemaOpts{Schema: spec.ArrayProperty(v)}) if assert.NoError(t, err, "failed to analyze array schema at %d: %v", i, err) { assert.True(t, asch.IsSimpleSchema, "array item at %d should be a simple schema", i) } msch, err := Schema(SchemaOpts{Schema: spec.MapProperty(v)}) if assert.NoError(t, err, "failed to analyze map schema at %d: %v", i, err) { assert.True(t, msch.IsSimpleSchema, "map item at %d should be a simple schema", i) } } for i, v := range complexSchemas { sch, err := Schema(SchemaOpts{Schema: v}) if assert.NoError(t, err, "failed to analyze schema at %d: %v", i, err) { assert.False(t, sch.IsSimpleSchema, "item at %d should not be a simple schema", i) } } }
func TestSchemaAnalysis_Map(t *testing.T) { for i, v := range append(knownSchemas, spec.MapProperty(nil)) { sch, err := Schema(SchemaOpts{Schema: spec.MapProperty(v)}) if assert.NoError(t, err, "failed to analyze schema at %d: %v", i, err) { assert.True(t, sch.IsMap, "item at %d should be a map type", i) assert.True(t, sch.IsSimpleMap, "item at %d should be a simple map type", i) } } for i, v := range complexSchemas { sch, err := Schema(SchemaOpts{Schema: spec.MapProperty(v)}) if assert.NoError(t, err, "failed to analyze schema at %d: %v", i, err) { assert.True(t, sch.IsMap, "item at %d should be a map type", i) assert.False(t, sch.IsSimpleMap, "item at %d should not be a simple map type", i) } } }
func TestSchemaAnalysis_ExtendedObject(t *testing.T) { for i, v := range knownSchemas { wex := spec.MapProperty(v).SetProperty("name", *spec.StringProperty()) sch, err := Schema(SchemaOpts{Schema: wex}) if assert.NoError(t, err, "failed to analyze schema at %d: %v", i, err) { assert.True(t, sch.IsExtendedObject, "item at %d should be an extended map object type", i) assert.False(t, sch.IsMap, "item at %d should not be a map type", i) assert.False(t, sch.IsSimpleMap, "item at %d should not be a simple map type", i) } } }
(&spec.Schema{}), // 10 (&spec.Schema{}).Typed("object", ""), // 11 (&spec.Schema{}).Typed("", ""), // 12 (&spec.Schema{}).Typed("", "uuid"), // 13 } func newCObj() *spec.Schema { return (&spec.Schema{}).Typed("object", "").SetProperty("id", *spec.Int64Property()) } var complexObject = newCObj() var complexSchemas = []*spec.Schema{ complexObject, spec.ArrayProperty(complexObject), spec.MapProperty(complexObject), } func knownRefs(base string) []spec.Ref { urls := []string{"bool", "string", "integer", "float", "date", "object", "format"} var result []spec.Ref for _, u := range urls { result = append(result, spec.MustCreateRef(fmt.Sprintf("%s/%s", base, path.Join("known", u)))) } return result } func complexRefs(base string) []spec.Ref { urls := []string{"object", "array", "map"}
func assertBuiltinAdditionalPropertiesElem(t testing.TB, resolver *typeResolver, aliased bool, i int, val builtinVal) bool { val.Nullable = false if nullableExtension(val.Extensions) != nil { val.Nullable = *nullableExtension(val.Extensions) } sliceType := "map[string]" + val.Expected if val.Nullable { sliceType = "map[string]*" + val.Expected } val.Expected = sliceType val.Aliased = aliased if aliased { val.AliasedType = val.Expected val.Expected = "models.MyAliasedThing" } items := new(spec.Schema) items.Typed(val.Type, val.Format) items.Default = val.Default items.ReadOnly = val.ReadOnly items.Extensions = val.Extensions items.Minimum = val.Minimum items.Maximum = val.Maximum items.MultipleOf = val.MultipleOf items.MinLength = val.MinLength items.MaxLength = val.MaxLength sch := spec.MapProperty(items) rt, err := resolver.ResolveSchema(sch, !aliased, val.Required) if assert.NoError(t, err) { // pretty.Println(rt) if val.Nullable { if !assert.True(t, rt.ElemType.IsNullable, "expected nullable for item at: %d", i) { // fmt.Println("isRequired:", val.Required) // pretty.Println(sch) return false } } else { if !assert.False(t, rt.ElemType != nil && rt.ElemType.IsNullable, "expected not nullable for item at: %d", i) { // fmt.Println("isRequired:", val.Required) // pretty.Println(sch) return false } } if !assert.Equal(t, val.Aliased, rt.IsAliased, "expected (%q, %q) to be an aliased type at %d", val.Type, val.Format, i) { return false } if val.Aliased { if !assert.Equal(t, val.AliasedType, rt.AliasedType, "expected %q (%q, %q) to be aliased as %q, but got %q at %d", val.Expected, val.Type, val.Format, val.AliasedType, rt.AliasedType, i) { return false } } if !assertBuiltinSliceElemnResolve(t, val.Type, val.Format, val.Expected, rt, i) { return false } } return true }