github.com/josephspurrier/go-swagger@v0.2.1-0.20221129144919-1f672a142a00/generator/schemavalidation_test.go (about)

     1  // Copyright 2015 go-swagger maintainers
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //    http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package generator
    16  
    17  import (
    18  	"bytes"
    19  	"testing"
    20  
    21  	"github.com/go-openapi/loads"
    22  	"github.com/go-openapi/swag"
    23  	"github.com/stretchr/testify/assert"
    24  	"github.com/stretchr/testify/require"
    25  )
    26  
    27  func TestSchemaValidation_RequiredProps(t *testing.T) {
    28  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
    29  	require.NoError(t, err)
    30  
    31  	k := "RequiredProps"
    32  	schema := specDoc.Spec().Definitions[k]
    33  
    34  	opts := opts()
    35  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
    36  	require.NoError(t, err)
    37  	assert.Len(t, gm.Properties, 6)
    38  
    39  	for _, p := range gm.Properties {
    40  		require.True(t, p.Required)
    41  
    42  		buf := bytes.NewBuffer(nil)
    43  		err := templates.MustGet("model").Execute(buf, gm)
    44  		require.NoError(t, err)
    45  
    46  		formatted, err := opts.LanguageOpts.FormatContent("required_props.go", buf.Bytes())
    47  		require.NoErrorf(t, err, buf.String())
    48  
    49  		res := string(formatted)
    50  		assertInCode(t, k+") Validate(formats", res)
    51  		assertInCode(t, "validate"+swag.ToGoName(p.Name), res)
    52  		assertInCode(t, "err := validate.Required", res)
    53  		assertInCode(t, "errors.CompositeValidationError(res...)", res)
    54  	}
    55  }
    56  
    57  func TestSchemaValidation_Strings(t *testing.T) {
    58  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
    59  	require.NoError(t, err)
    60  
    61  	k := "NamedString"
    62  	schema := specDoc.Spec().Definitions[k]
    63  
    64  	opts := opts()
    65  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
    66  	require.NoError(t, err)
    67  
    68  	requireValidation(t, "", "m", gm.GenSchema)
    69  
    70  	buf := bytes.NewBuffer(nil)
    71  	err = templates.MustGet("model").Execute(buf, gm)
    72  	require.NoError(t, err)
    73  
    74  	formatted, err := opts.LanguageOpts.FormatContent("named_string.go", buf.Bytes())
    75  	require.NoErrorf(t, err, buf.String())
    76  
    77  	res := string(formatted)
    78  	assertInCode(t, k+") Validate(formats", res)
    79  	assertInCode(t, "err := validate.MinLength", res)
    80  	assertInCode(t, "err := validate.MaxLength", res)
    81  	assertInCode(t, "err := validate.Pattern", res)
    82  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
    83  }
    84  
    85  func TestSchemaValidation_StringProps(t *testing.T) {
    86  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
    87  	require.NoError(t, err)
    88  
    89  	k := "StringValidations"
    90  	schema := specDoc.Spec().Definitions[k]
    91  
    92  	opts := opts()
    93  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
    94  	require.NoError(t, err)
    95  
    96  	prop := gm.Properties[0]
    97  	requireValidation(t, "\"name\"", "m.Name", prop)
    98  
    99  	buf := bytes.NewBuffer(nil)
   100  	err = templates.MustGet("model").Execute(buf, gm)
   101  	require.NoError(t, err)
   102  
   103  	formatted, err := opts.LanguageOpts.FormatContent("string_validations.go", buf.Bytes())
   104  	require.NoErrorf(t, err, buf.String())
   105  
   106  	res := string(formatted)
   107  	assertInCode(t, k+") Validate(formats", res)
   108  	assertInCode(t, "m.validateName(formats", res)
   109  	assertInCode(t, "err := validate.MinLength(\"name\",", res)
   110  	assertInCode(t, "err := validate.MaxLength(\"name\",", res)
   111  	assertInCode(t, "err := validate.Pattern(\"name\",", res)
   112  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   113  }
   114  
   115  func TestSchemaValidation_NamedNumber(t *testing.T) {
   116  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   117  	require.NoError(t, err)
   118  	k := "NamedNumber"
   119  	schema := specDoc.Spec().Definitions[k]
   120  
   121  	opts := opts()
   122  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   123  	require.NoError(t, err)
   124  
   125  	requireValidation(t, "", "m", gm.GenSchema)
   126  
   127  	buf := bytes.NewBuffer(nil)
   128  	err = templates.MustGet("model").Execute(buf, gm)
   129  	require.NoError(t, err)
   130  
   131  	formatted, err := opts.LanguageOpts.FormatContent("named_number.go", buf.Bytes())
   132  	require.NoErrorf(t, err, buf.String())
   133  
   134  	res := string(formatted)
   135  	assertInCode(t, k+") Validate(formats", res)
   136  	assertInCode(t, "err := validate.MinimumInt", res)
   137  	assertInCode(t, "err := validate.MaximumInt", res)
   138  	assertInCode(t, "err := validate.MultipleOf(", res) // factor is not an integer
   139  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   140  }
   141  
   142  func TestSchemaValidation_NumberProps(t *testing.T) {
   143  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   144  	require.NoError(t, err)
   145  
   146  	k := "NumberValidations"
   147  	schema := specDoc.Spec().Definitions[k]
   148  
   149  	opts := opts()
   150  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   151  	require.NoError(t, err)
   152  
   153  	prop := gm.Properties[0]
   154  	requireValidation(t, "\"age\"", "m.Age", prop)
   155  
   156  	buf := bytes.NewBuffer(nil)
   157  	err = templates.MustGet("model").Execute(buf, gm)
   158  	require.NoError(t, err)
   159  
   160  	formatted, err := opts.LanguageOpts.FormatContent("number_validations.go", buf.Bytes())
   161  	require.NoErrorf(t, err, buf.String())
   162  
   163  	res := string(formatted)
   164  	assertInCode(t, k+") Validate(formats", res)
   165  	assertInCode(t, "m.validateAge(formats", res)
   166  	assertInCode(t, "err := validate.MinimumInt(\"age\",", res)
   167  	assertInCode(t, "err := validate.MaximumInt(\"age\",", res)
   168  	assertInCode(t, "err := validate.MultipleOf(\"age\",", res) // factor is not an integer
   169  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   170  }
   171  
   172  func TestSchemaValidation_NamedArray(t *testing.T) {
   173  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   174  	require.NoError(t, err)
   175  
   176  	k := "NamedArray"
   177  	schema := specDoc.Spec().Definitions[k]
   178  
   179  	opts := opts()
   180  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   181  	require.NoError(t, err)
   182  
   183  	requireValidation(t, "", "m", gm.GenSchema)
   184  
   185  	buf := bytes.NewBuffer(nil)
   186  	err = templates.MustGet("model").Execute(buf, gm)
   187  	require.NoError(t, err)
   188  
   189  	formatted, err := opts.LanguageOpts.FormatContent("named_array.go", buf.Bytes())
   190  	require.NoErrorf(t, err, buf.String())
   191  
   192  	res := string(formatted)
   193  	assertInCode(t, k+") Validate(formats", res)
   194  	assertInCode(t, "err := validate.MinItems(\"\"", res)
   195  	assertInCode(t, "err := validate.MaxItems(\"\"", res)
   196  	assertInCode(t, "err := validate.MinLength(strconv.Itoa(i),", res)
   197  	assertInCode(t, "err := validate.MaxLength(strconv.Itoa(i),", res)
   198  	assertInCode(t, "err := validate.Pattern(strconv.Itoa(i),", res)
   199  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   200  }
   201  
   202  func TestSchemaValidation_ArrayProps(t *testing.T) {
   203  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   204  	require.NoError(t, err)
   205  
   206  	k := "ArrayValidations"
   207  	schema := specDoc.Spec().Definitions[k]
   208  
   209  	opts := opts()
   210  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   211  	require.NoError(t, err)
   212  
   213  	prop := gm.Properties[0]
   214  	requireValidation(t, "\"tags\"", "m.Tags", prop)
   215  
   216  	buf := bytes.NewBuffer(nil)
   217  	err = templates.MustGet("model").Execute(buf, gm)
   218  	require.NoError(t, err)
   219  
   220  	formatted, err := opts.LanguageOpts.FormatContent("array_validations.go", buf.Bytes())
   221  	require.NoErrorf(t, err, buf.String())
   222  
   223  	res := string(formatted)
   224  	assertInCode(t, k+") Validate(formats", res)
   225  	assertInCode(t, "m.validateTags(formats", res)
   226  	assertInCode(t, "err := validate.MinItems(\"tags\"", res)
   227  	assertInCode(t, "err := validate.MaxItems(\"tags\"", res)
   228  	assertInCode(t, "err := validate.MinLength(\"tags\"+\".\"+strconv.Itoa(i),", res)
   229  	assertInCode(t, "err := validate.MaxLength(\"tags\"+\".\"+strconv.Itoa(i),", res)
   230  	assertInCode(t, "err := validate.Pattern(\"tags\"+\".\"+strconv.Itoa(i),", res)
   231  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   232  }
   233  
   234  func TestSchemaValidation_NamedNestedArray(t *testing.T) {
   235  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   236  	require.NoError(t, err)
   237  
   238  	k := "NamedNestedArray"
   239  	schema := specDoc.Spec().Definitions[k]
   240  
   241  	opts := opts()
   242  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   243  	require.NoError(t, err)
   244  
   245  	requireValidation(t, "", "m", gm.GenSchema)
   246  
   247  	buf := bytes.NewBuffer(nil)
   248  	err = templates.MustGet("model").Execute(buf, gm)
   249  	require.NoError(t, err)
   250  
   251  	formatted, err := opts.LanguageOpts.FormatContent("named_nested_array.go", buf.Bytes())
   252  	require.NoErrorf(t, err, buf.String())
   253  
   254  	res := string(formatted)
   255  	assertInCode(t, k+") Validate(formats", res)
   256  	assertInCode(t, "iNamedNestedArraySize := int64(len(m))", res)
   257  	assertInCode(t, "iiNamedNestedArraySize := int64(len(m[i]))", res)
   258  	assertInCode(t, "iiiNamedNestedArraySize := int64(len(m[i][ii]))", res)
   259  	assertInCode(t, "err := validate.MinItems(\"\"", res)
   260  	assertInCode(t, "err := validate.MaxItems(\"\"", res)
   261  	assertInCode(t, "err := validate.MinItems(strconv.Itoa(i),", res)
   262  	assertInCode(t, "err := validate.MaxItems(strconv.Itoa(i),", res)
   263  	assertInCode(t, "err := validate.MinItems(strconv.Itoa(i)+\".\"+strconv.Itoa(ii),", res)
   264  	assertInCode(t, "err := validate.MaxItems(strconv.Itoa(i)+\".\"+strconv.Itoa(ii),", res)
   265  	assertInCode(t, "err := validate.MinLength(strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   266  	assertInCode(t, "err := validate.MaxLength(strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   267  	assertInCode(t, "err := validate.Pattern(strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   268  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   269  }
   270  
   271  func TestSchemaValidation_NestedArrayProps(t *testing.T) {
   272  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   273  	require.NoError(t, err)
   274  
   275  	k := "NestedArrayValidations"
   276  	schema := specDoc.Spec().Definitions[k]
   277  
   278  	opts := opts()
   279  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   280  	require.NoError(t, err)
   281  
   282  	prop := gm.Properties[0]
   283  	requireValidation(t, "\"tags\"", "m.Tags", prop)
   284  
   285  	buf := bytes.NewBuffer(nil)
   286  	err = templates.MustGet("model").Execute(buf, gm)
   287  	require.NoError(t, err)
   288  
   289  	formatted, err := opts.LanguageOpts.FormatContent("nested_array_validations.go", buf.Bytes())
   290  	require.NoErrorf(t, err, buf.String())
   291  
   292  	res := string(formatted)
   293  	assertInCode(t, k+") Validate(formats", res)
   294  	assertInCode(t, "m.validateTags(formats", res)
   295  	assertInCode(t, "iTagsSize := int64(len(m.Tags))", res)
   296  	assertInCode(t, "iiTagsSize := int64(len(m.Tags[i]))", res)
   297  	assertInCode(t, "iiiTagsSize := int64(len(m.Tags[i][ii]))", res)
   298  	assertInCode(t, "err := validate.MinItems(\"tags\"", res)
   299  	assertInCode(t, "err := validate.MaxItems(\"tags\"", res)
   300  	assertInCode(t, "err := validate.MinItems(\"tags\"+\".\"+strconv.Itoa(i),", res)
   301  	assertInCode(t, "err := validate.MaxItems(\"tags\"+\".\"+strconv.Itoa(i),", res)
   302  	assertInCode(t, "err := validate.MinItems(\"tags\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii),", res)
   303  	assertInCode(t, "err := validate.MaxItems(\"tags\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii),", res)
   304  	assertInCode(t, "err := validate.MinLength(\"tags\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   305  	assertInCode(t, "err := validate.MaxLength(\"tags\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   306  	assertInCode(t, "err := validate.Pattern(\"tags\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   307  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   308  }
   309  
   310  func TestSchemaValidation_NamedNestedObject(t *testing.T) {
   311  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   312  	require.NoError(t, err)
   313  
   314  	k := "NamedNestedObject"
   315  	schema := specDoc.Spec().Definitions[k]
   316  
   317  	opts := opts()
   318  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   319  	require.NoError(t, err)
   320  
   321  	requireValidation(t, "", "m", gm.GenSchema)
   322  
   323  	buf := bytes.NewBuffer(nil)
   324  	err = templates.MustGet("model").Execute(buf, gm)
   325  	require.NoError(t, err)
   326  
   327  	formatted, err := opts.LanguageOpts.FormatContent("named_nested_object.go", buf.Bytes())
   328  	require.NoErrorf(t, err, buf.String())
   329  
   330  	res := string(formatted)
   331  	assertInCode(t, k+") Validate(formats", res)
   332  	assertInCode(t, k+"Meta) Validate(formats", res)
   333  	assertInCode(t, k+") validateMeta(formats", res)
   334  	assertInCode(t, "m.Meta.Validate(formats)", res)
   335  	assertInCode(t, "err := validate.MinLength(\"meta\"+\".\"+\"first\",", res)
   336  	assertInCode(t, "err := validate.MaxLength(\"meta\"+\".\"+\"first\",", res)
   337  	assertInCode(t, "err := validate.Pattern(\"meta\"+\".\"+\"first\",", res)
   338  	assertInCode(t, "err := validate.Minimum(\"meta\"+\".\"+\"second\",", res)
   339  	assertInCode(t, "err := validate.Maximum(\"meta\"+\".\"+\"second\",", res)
   340  	assertInCode(t, "err := validate.MultipleOf(\"meta\"+\".\"+\"second\",", res)
   341  	assertInCode(t, "iThirdSize := int64(len(m.Third))", res)
   342  	assertInCode(t, "err := validate.MinItems(\"meta\"+\".\"+\"third\",", res)
   343  	assertInCode(t, "err := validate.MaxItems(\"meta\"+\".\"+\"third\",", res)
   344  	assertInCode(t, "err := validate.Minimum(\"meta\"+\".\"+\"third\"+\".\"+strconv.Itoa(i),", res)
   345  	assertInCode(t, "err := validate.Maximum(\"meta\"+\".\"+\"third\"+\".\"+strconv.Itoa(i),", res)
   346  	assertInCode(t, "err := validate.MultipleOf(\"meta\"+\".\"+\"third\"+\".\"+strconv.Itoa(i),", res)
   347  	assertInCode(t, "iFourthSize := int64(len(m.Fourth))", res)
   348  	assertInCode(t, "iiFourthSize := int64(len(m.Fourth[i]))", res)
   349  	assertInCode(t, "iiiFourthSize := int64(len(m.Fourth[i][ii]))", res)
   350  	assertInCode(t, "err := validate.MinItems(\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i),", res)
   351  	assertInCode(t, "err := validate.MaxItems(\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i),", res)
   352  	assertInCode(t, "err := validate.MinItems(\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii),", res)
   353  	assertInCode(t, "err := validate.MaxItems(\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii),", res)
   354  	assertInCode(t, "err := validate.Minimum(\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   355  	assertInCode(t, "err := validate.Maximum(\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   356  	assertInCode(t, "err := validate.MultipleOf(\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   357  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   358  }
   359  
   360  func TestSchemaValidation_NestedObjectProps(t *testing.T) {
   361  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   362  	require.NoError(t, err)
   363  
   364  	k := "NestedObjectValidations"
   365  	schema := specDoc.Spec().Definitions[k]
   366  
   367  	opts := opts()
   368  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   369  	require.NoError(t, err)
   370  
   371  	prop := gm.Properties[0]
   372  	requireValidation(t, "\"args\"", "m.Args", prop)
   373  
   374  	buf := bytes.NewBuffer(nil)
   375  	err = templates.MustGet("model").Execute(buf, gm)
   376  	require.NoError(t, err)
   377  
   378  	formatted, err := opts.LanguageOpts.FormatContent("nested_object_validations.go", buf.Bytes())
   379  	require.NoErrorf(t, err, buf.String())
   380  
   381  	res := string(formatted)
   382  	assertInCode(t, k+") Validate(formats", res)
   383  	assertInCode(t, k+"Args) Validate(formats", res)
   384  	assertInCode(t, k+"ArgsMeta) Validate(formats", res)
   385  	assertInCode(t, "m.validateArgs(formats", res)
   386  	assertInCode(t, "err := validate.MinLength(\"args\"+\".\"+\"meta\"+\".\"+\"first\",", res)
   387  	assertInCode(t, "err := validate.MaxLength(\"args\"+\".\"+\"meta\"+\".\"+\"first\",", res)
   388  	assertInCode(t, "err := validate.Pattern(\"args\"+\".\"+\"meta\"+\".\"+\"first\",", res)
   389  	assertInCode(t, "err := validate.Minimum(\"args\"+\".\"+\"meta\"+\".\"+\"second\",", res)
   390  	assertInCode(t, "err := validate.Maximum(\"args\"+\".\"+\"meta\"+\".\"+\"second\",", res)
   391  	assertInCode(t, "err := validate.MultipleOf(\"args\"+\".\"+\"meta\"+\".\"+\"second\",", res)
   392  	assertInCode(t, "iThirdSize := int64(len(m.Third))", res)
   393  	assertInCode(t, "err := validate.MinItems(\"args\"+\".\"+\"meta\"+\".\"+\"third\",", res)
   394  	assertInCode(t, "err := validate.MaxItems(\"args\"+\".\"+\"meta\"+\".\"+\"third\",", res)
   395  	assertInCode(t, "err := validate.Minimum(\"args\"+\".\"+\"meta\"+\".\"+\"third\"+\".\"+strconv.Itoa(i),", res)
   396  	assertInCode(t, "err := validate.Maximum(\"args\"+\".\"+\"meta\"+\".\"+\"third\"+\".\"+strconv.Itoa(i),", res)
   397  	assertInCode(t, "err := validate.MultipleOf(\"args\"+\".\"+\"meta\"+\".\"+\"third\"+\".\"+strconv.Itoa(i),", res)
   398  	assertInCode(t, "iFourthSize := int64(len(m.Fourth))", res)
   399  	assertInCode(t, "iiFourthSize := int64(len(m.Fourth[i]))", res)
   400  	assertInCode(t, "iiiFourthSize := int64(len(m.Fourth[i][ii]))", res)
   401  	assertInCode(t, "err := validate.MinItems(\"args\"+\".\"+\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i),", res)
   402  	assertInCode(t, "err := validate.MaxItems(\"args\"+\".\"+\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i),", res)
   403  	assertInCode(t, "err := validate.MinItems(\"args\"+\".\"+\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii),", res)
   404  	assertInCode(t, "err := validate.MaxItems(\"args\"+\".\"+\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii),", res)
   405  	assertInCode(t, "err := validate.Minimum(\"args\"+\".\"+\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   406  	assertInCode(t, "err := validate.Maximum(\"args\"+\".\"+\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   407  	assertInCode(t, "err := validate.MultipleOf(\"args\"+\".\"+\"meta\"+\".\"+\"fourth\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   408  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   409  }
   410  
   411  func TestSchemaValidation_NamedArrayMulti(t *testing.T) {
   412  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   413  	require.NoError(t, err)
   414  
   415  	k := "NamedArrayMulti"
   416  	schema := specDoc.Spec().Definitions[k]
   417  
   418  	opts := opts()
   419  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   420  	require.NoError(t, err)
   421  
   422  	requireValidation(t, "", "m", gm.GenSchema)
   423  
   424  	buf := bytes.NewBuffer(nil)
   425  	err = templates.MustGet("model").Execute(buf, gm)
   426  	require.NoError(t, err)
   427  
   428  	formatted, err := opts.LanguageOpts.FormatContent("named_array_multi.go", buf.Bytes())
   429  	require.NoErrorf(t, err, buf.String())
   430  
   431  	res := string(formatted)
   432  	assertInCode(t, k+") Validate(formats", res)
   433  	assertInCode(t, k+") validateP0(formats", res)
   434  	assertInCode(t, k+") validateP1(formats", res)
   435  	assertInCode(t, "err := validate.Required(\"0\",", res)
   436  	assertInCode(t, "err := validate.MinLength(\"0\",", res)
   437  	assertInCode(t, "err := validate.MaxLength(\"0\",", res)
   438  	assertInCode(t, "err := validate.Pattern(\"0\",", res)
   439  	assertInCode(t, "err := validate.Required(\"1\",", res)
   440  	assertInCode(t, "err := validate.Minimum(\"1\",", res)
   441  	assertInCode(t, "err := validate.Maximum(\"1\",", res)
   442  	assertInCode(t, "err := validate.MultipleOf(\"1\",", res)
   443  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   444  }
   445  
   446  func TestSchemaValidation_ArrayMultiProps(t *testing.T) {
   447  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   448  	require.NoError(t, err)
   449  
   450  	k := "ArrayMultiValidations"
   451  	schema := specDoc.Spec().Definitions[k]
   452  
   453  	opts := opts()
   454  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   455  	require.NoError(t, err)
   456  
   457  	prop := gm.Properties[0]
   458  	requireValidation(t, "\"args\"", "m.Args", prop)
   459  
   460  	buf := bytes.NewBuffer(nil)
   461  	err = templates.MustGet("model").Execute(buf, gm)
   462  	require.NoError(t, err)
   463  
   464  	formatted, err := opts.LanguageOpts.FormatContent("array_multi_validations.go", buf.Bytes())
   465  	require.NoErrorf(t, err, buf.String())
   466  
   467  	res := string(formatted)
   468  	assertInCode(t, k+") Validate(formats", res)
   469  	assertInCode(t, "m.validateArgs(formats", res)
   470  	assertInCode(t, "err := validate.Required(\"P0\",", res)
   471  	assertInCode(t, "err := validate.MinLength(\"P0\",", res)
   472  	assertInCode(t, "err := validate.MaxLength(\"P0\",", res)
   473  	assertInCode(t, "err := validate.Pattern(\"P0\",", res)
   474  	assertInCode(t, "err := validate.Required(\"P1\",", res)
   475  	assertInCode(t, "err := validate.Minimum(\"P1\",", res)
   476  	assertInCode(t, "err := validate.Maximum(\"P1\",", res)
   477  	assertInCode(t, "err := validate.MultipleOf(\"P1\",", res)
   478  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   479  }
   480  
   481  func TestSchemaValidation_NamedArrayAdditional(t *testing.T) {
   482  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   483  	require.NoError(t, err)
   484  
   485  	k := "NamedArrayAdditional"
   486  	schema := specDoc.Spec().Definitions[k]
   487  
   488  	opts := opts()
   489  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   490  	require.NoError(t, err)
   491  
   492  	requireValidation(t, "", "m", gm.GenSchema)
   493  
   494  	buf := bytes.NewBuffer(nil)
   495  	err = templates.MustGet("model").Execute(buf, gm)
   496  	require.NoError(t, err)
   497  
   498  	formatted, err := opts.LanguageOpts.FormatContent("named_array_additional.go", buf.Bytes())
   499  	require.NoErrorf(t, err, buf.String())
   500  
   501  	res := string(formatted)
   502  	assertInCode(t, k+") Validate(formats", res)
   503  	assertInCode(t, k+") validateP0(formats", res)
   504  	assertInCode(t, k+") validateP1(formats", res)
   505  	assertInCode(t, "err := validate.Required(\"0\",", res)
   506  	assertInCode(t, "err := validate.MinLength(\"0\",", res)
   507  	assertInCode(t, "err := validate.MaxLength(\"0\",", res)
   508  	assertInCode(t, "err := validate.Pattern(\"0\",", res)
   509  	assertInCode(t, "err := validate.Required(\"1\",", res)
   510  	assertInCode(t, "err := validate.Minimum(\"1\",", res)
   511  	assertInCode(t, "err := validate.Maximum(\"1\",", res)
   512  	assertInCode(t, "err := validate.MultipleOf(\"1\",", res)
   513  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   514  	assertInCode(t, "m.NamedArrayAdditionalItems[i]", res)
   515  }
   516  
   517  func TestSchemaValidation_ArrayAdditionalProps(t *testing.T) {
   518  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   519  	require.NoError(t, err)
   520  
   521  	k := "ArrayAdditionalValidations"
   522  	schema := specDoc.Spec().Definitions[k]
   523  
   524  	opts := opts()
   525  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   526  	require.NoError(t, err)
   527  
   528  	prop := gm.Properties[0]
   529  	requireValidation(t, "\"args\"", "m.Args", prop)
   530  	buf := bytes.NewBuffer(nil)
   531  	err = templates.MustGet("model").Execute(buf, gm)
   532  	require.NoError(t, err)
   533  
   534  	formatted, err := opts.LanguageOpts.FormatContent("array_additional_validations.go", buf.Bytes())
   535  	require.NoErrorf(t, err, buf.String())
   536  
   537  	res := string(formatted)
   538  	assertInCode(t, k+") Validate(formats", res)
   539  	assertInCode(t, "m.validateArgs(formats", res)
   540  	assertInCode(t, "err := validate.Required(\"P0\",", res)
   541  	assertInCode(t, "err := validate.MinLength(\"P0\",", res)
   542  	assertInCode(t, "err := validate.MaxLength(\"P0\",", res)
   543  	assertInCode(t, "err := validate.Pattern(\"P0\",", res)
   544  	assertInCode(t, "err := validate.Required(\"P1\",", res)
   545  	assertInCode(t, "err := validate.Minimum(\"P1\",", res)
   546  	assertInCode(t, "err := validate.Maximum(\"P1\",", res)
   547  	assertInCode(t, "err := validate.MultipleOf(\"P1\",", res)
   548  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   549  	assertInCode(t, "m.ArrayAdditionalValidationsArgsTuple0Items[i]", res)
   550  }
   551  
   552  func TestSchemaValidation_NamedMap(t *testing.T) {
   553  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   554  	require.NoError(t, err)
   555  
   556  	k := "NamedMap"
   557  	schema := specDoc.Spec().Definitions[k]
   558  
   559  	opts := opts()
   560  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   561  	require.NoError(t, err)
   562  
   563  	requireValidation(t, "", "m", gm.GenSchema)
   564  
   565  	buf := bytes.NewBuffer(nil)
   566  	err = templates.MustGet("model").Execute(buf, gm)
   567  	require.NoError(t, err)
   568  
   569  	formatted, err := opts.LanguageOpts.FormatContent("named_map.go", buf.Bytes())
   570  	require.NoErrorf(t, err, buf.String())
   571  
   572  	res := string(formatted)
   573  	assertInCode(t, k+") Validate(formats", res)
   574  	assertInCode(t, "for k := range m {", res)
   575  	assertInCode(t, "err := validate.MinimumInt(k,", res)
   576  	assertInCode(t, "err := validate.MaximumInt(k,", res)
   577  	assertInCode(t, "err := validate.MultipleOfInt(k,", res)
   578  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   579  }
   580  
   581  func TestSchemaValidation_MapProps(t *testing.T) {
   582  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   583  	require.NoError(t, err)
   584  
   585  	k := "MapValidations"
   586  	schema := specDoc.Spec().Definitions[k]
   587  
   588  	opts := opts()
   589  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   590  	require.NoError(t, err)
   591  
   592  	prop := gm.Properties[0]
   593  	requireValidation(t, "\"meta\"", "m.Meta", prop)
   594  
   595  	buf := bytes.NewBuffer(nil)
   596  	err = templates.MustGet("model").Execute(buf, gm)
   597  	require.NoError(t, err)
   598  
   599  	formatted, err := opts.LanguageOpts.FormatContent("map_validations.go", buf.Bytes())
   600  	require.NoErrorf(t, err, buf.String())
   601  
   602  	res := string(formatted)
   603  	assertInCode(t, k+") Validate(formats", res)
   604  	assertInCode(t, "m.validateMeta(formats", res)
   605  	assertInCode(t, "for k := range m.Meta {", res)
   606  	assertInCode(t, "err := validate.MinimumInt(\"meta\"+\".\"+k,", res)
   607  	assertInCode(t, "err := validate.MaximumInt(\"meta\"+\".\"+k,", res)
   608  	assertInCode(t, "err := validate.MultipleOfInt(\"meta\"+\".\"+k,", res)
   609  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   610  }
   611  
   612  func TestSchemaValidation_NamedMapComplex(t *testing.T) {
   613  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   614  	require.NoError(t, err)
   615  
   616  	k := "NamedMapComplex"
   617  	schema := specDoc.Spec().Definitions[k]
   618  
   619  	opts := opts()
   620  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   621  	require.NoError(t, err)
   622  
   623  	requireValidation(t, "", "m", gm.GenSchema)
   624  
   625  	buf := bytes.NewBuffer(nil)
   626  	err = templates.MustGet("model").Execute(buf, gm)
   627  	require.NoError(t, err)
   628  
   629  	formatted, err := opts.LanguageOpts.FormatContent("named_map_complex.go", buf.Bytes())
   630  	require.NoErrorf(t, err, buf.String())
   631  
   632  	res := string(formatted)
   633  	assertInCode(t, k+") Validate(formats", res)
   634  	assertInCode(t, "for k := range m {", res)
   635  	assertInCode(t, "val.Validate(formats)", res)
   636  	assertInCode(t, "err := validate.MinLength(\"name\",", res)
   637  	assertInCode(t, "err := validate.MaxLength(\"name\",", res)
   638  	assertInCode(t, "err := validate.Pattern(\"name\",", res)
   639  	assertInCode(t, "err := validate.MinimumInt(\"age\",", res)
   640  	assertInCode(t, "err := validate.MaximumInt(\"age\",", res)
   641  	assertInCode(t, "err := validate.MultipleOfInt(\"age\",", res)
   642  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   643  }
   644  
   645  func TestSchemaValidation_MapComplexProps(t *testing.T) {
   646  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   647  	require.NoError(t, err)
   648  
   649  	k := "MapComplexValidations"
   650  	schema := specDoc.Spec().Definitions[k]
   651  	opts := opts()
   652  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   653  	require.NoError(t, err)
   654  
   655  	prop := gm.Properties[0]
   656  	requireValidation(t, "\"meta\"", "m.Meta", prop)
   657  
   658  	buf := bytes.NewBuffer(nil)
   659  	err = templates.MustGet("model").Execute(buf, gm)
   660  	require.NoError(t, err)
   661  
   662  	formatted, err := opts.LanguageOpts.FormatContent("map_complex_validations.go", buf.Bytes())
   663  	require.NoErrorf(t, err, buf.String())
   664  
   665  	res := string(formatted)
   666  	assertInCode(t, k+") Validate(formats", res)
   667  	assertInCode(t, "for k := range m.Meta {", res)
   668  	assertInCode(t, "val.Validate(formats)", res)
   669  	assertInCode(t, "err := validate.MinLength(\"name\",", res)
   670  	assertInCode(t, "err := validate.MaxLength(\"name\",", res)
   671  	assertInCode(t, "err := validate.Pattern(\"name\",", res)
   672  	assertInCode(t, "err := validate.MinimumInt(\"age\",", res)
   673  	assertInCode(t, "err := validate.MaximumInt(\"age\",", res)
   674  	assertInCode(t, "err := validate.MultipleOfInt(\"age\",", res)
   675  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   676  }
   677  
   678  func TestSchemaValidation_NamedNestedMap(t *testing.T) {
   679  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   680  	require.NoError(t, err)
   681  
   682  	k := "NamedNestedMap"
   683  	schema := specDoc.Spec().Definitions[k]
   684  
   685  	opts := opts()
   686  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   687  	require.NoError(t, err)
   688  
   689  	requireValidation(t, "", "m", gm.GenSchema)
   690  
   691  	buf := bytes.NewBuffer(nil)
   692  	err = templates.MustGet("model").Execute(buf, gm)
   693  	require.NoError(t, err)
   694  
   695  	formatted, err := opts.LanguageOpts.FormatContent("named_nested_map.go", buf.Bytes())
   696  	require.NoErrorf(t, err, buf.String())
   697  
   698  	res := string(formatted)
   699  	assertInCode(t, k+") Validate(formats", res)
   700  	assertInCode(t, "for k := range m {", res)
   701  	assertInCode(t, "for kk := range m[k] {", res)
   702  	assertInCode(t, "for kkk := range m[k][kk] {", res)
   703  	assertInCode(t, "err := validate.MinimumInt(k+\".\"+kk+\".\"+kkk,", res)
   704  	assertInCode(t, "err := validate.MaximumInt(k+\".\"+kk+\".\"+kkk,", res)
   705  	assertInCode(t, "err := validate.MultipleOfInt(k+\".\"+kk+\".\"+kkk,", res)
   706  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   707  }
   708  
   709  func TestSchemaValidation_NestedMapProps(t *testing.T) {
   710  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   711  	require.NoError(t, err)
   712  
   713  	k := "NestedMapValidations"
   714  	schema := specDoc.Spec().Definitions[k]
   715  
   716  	opts := opts()
   717  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   718  	require.NoError(t, err)
   719  
   720  	prop := gm.Properties[0]
   721  	requireValidation(t, "\"meta\"", "m.Meta", prop)
   722  
   723  	buf := bytes.NewBuffer(nil)
   724  	err = templates.MustGet("model").Execute(buf, gm)
   725  	require.NoError(t, err)
   726  
   727  	formatted, err := opts.LanguageOpts.FormatContent("nested_map_validations.go", buf.Bytes())
   728  	require.NoErrorf(t, err, buf.String())
   729  
   730  	res := string(formatted)
   731  	assertInCode(t, k+") Validate(formats", res)
   732  	assertInCode(t, "m.validateMeta(formats", res)
   733  	assertInCode(t, "for k := range m.Meta {", res)
   734  	assertInCode(t, "for kk := range m.Meta[k] {", res)
   735  	assertInCode(t, "for kkk := range m.Meta[k][kk] {", res)
   736  	assertInCode(t, "err := validate.MinimumInt(\"meta\"+\".\"+k+\".\"+kk+\".\"+kkk,", res)
   737  	assertInCode(t, "err := validate.MaximumInt(\"meta\"+\".\"+k+\".\"+kk+\".\"+kkk,", res)
   738  	assertInCode(t, "err := validate.MultipleOfInt(\"meta\"+\".\"+k+\".\"+kk+\".\"+kkk,", res)
   739  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   740  }
   741  
   742  func TestAdditionalProperties_Simple(t *testing.T) {
   743  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   744  	require.NoError(t, err)
   745  
   746  	k := "NamedMapComplex"
   747  	schema := specDoc.Spec().Definitions[k]
   748  	tr := &typeResolver{
   749  		ModelsPackage: "",
   750  		ModelName:     k,
   751  		Doc:           specDoc,
   752  	}
   753  
   754  	sg := schemaGenContext{
   755  		Path:         "",
   756  		Name:         k,
   757  		Receiver:     "m",
   758  		IndexVar:     "i",
   759  		ValueExpr:    "m",
   760  		Schema:       schema,
   761  		Required:     false,
   762  		TypeResolver: tr,
   763  		Named:        true,
   764  		ExtraSchemas: make(map[string]GenSchema),
   765  	}
   766  
   767  	fsm, lsm, err := newMapStack(&sg)
   768  	require.NoError(t, err)
   769  
   770  	assert.NotNil(t, fsm.Type)
   771  	assert.Equal(t, &schema, fsm.Type)
   772  	assert.Equal(t, fsm, lsm)
   773  	assert.NotNil(t, fsm.Type.AdditionalProperties)
   774  	assert.NotNil(t, fsm.Type.AdditionalProperties.Schema)
   775  	assert.NotNil(t, fsm.NewObj)
   776  	assert.Nil(t, fsm.Next)
   777  	assert.Equal(t, "#/definitions/NamedMapComplexAnon", fsm.Type.AdditionalProperties.Schema.Ref.GetURL().String())
   778  
   779  	assert.NoError(t, lsm.Build())
   780  }
   781  
   782  func TestAdditionalProperties_Nested(t *testing.T) {
   783  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   784  	require.NoError(t, err)
   785  
   786  	k := "NamedNestedMapComplex"
   787  	schema := specDoc.Spec().Definitions[k]
   788  	tr := &typeResolver{
   789  		ModelsPackage: "",
   790  		ModelName:     k,
   791  		Doc:           specDoc,
   792  	}
   793  
   794  	sg := schemaGenContext{
   795  		Path:         "",
   796  		Name:         k,
   797  		Receiver:     "m",
   798  		IndexVar:     "i",
   799  		ValueExpr:    "m",
   800  		Schema:       schema,
   801  		Required:     false,
   802  		TypeResolver: tr,
   803  		Named:        true,
   804  		ExtraSchemas: make(map[string]GenSchema),
   805  	}
   806  
   807  	fsm, lsm, err := newMapStack(&sg)
   808  	require.NoError(t, err)
   809  
   810  	assert.NotNil(t, fsm.Type)
   811  	assert.Equal(t, &schema, fsm.Type)
   812  	assert.Equal(t, "", fsm.Context.Path)
   813  	assert.NotNil(t, schema.AdditionalProperties.Schema)
   814  
   815  	require.NotNil(t, fsm.Next)
   816  	require.Nil(t, fsm.Previous)
   817  
   818  	assert.NotNil(t, fsm.Type)
   819  	assert.Equal(t, &schema, fsm.Type)
   820  	assert.NotEqual(t, fsm, lsm)
   821  	assert.NotNil(t, fsm.Type.AdditionalProperties)
   822  	assert.NotNil(t, fsm.Type.AdditionalProperties.Schema)
   823  	assert.Nil(t, fsm.NewObj)
   824  	assert.Nil(t, fsm.Next.NewObj)
   825  	assert.NotNil(t, fsm.Next.Previous)
   826  	assert.NotNil(t, fsm.Next.Next)
   827  	assert.NotNil(t, fsm.Next.Next.NewObj)
   828  	assert.NotNil(t, fsm.Next.Next.ValueRef)
   829  	assert.Nil(t, fsm.Next.Next.Next)
   830  	assert.Equal(t, fsm.Next.Next, lsm)
   831  	assert.NoError(t, lsm.Build())
   832  }
   833  
   834  func TestSchemaValidation_NamedNestedMapComplex(t *testing.T) {
   835  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   836  	require.NoError(t, err)
   837  
   838  	k := "NamedNestedMapComplex"
   839  	schema := specDoc.Spec().Definitions[k]
   840  
   841  	opts := opts()
   842  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   843  	require.NoError(t, err)
   844  
   845  	requireValidation(t, "", "m", gm.GenSchema)
   846  	require.True(t, gm.GenSchema.AdditionalProperties.HasValidations)
   847  	require.True(t, gm.GenSchema.AdditionalProperties.AdditionalProperties.HasValidations)
   848  
   849  	buf := bytes.NewBuffer(nil)
   850  	err = templates.MustGet("model").Execute(buf, gm)
   851  	require.NoError(t, err)
   852  
   853  	formatted, err := opts.LanguageOpts.FormatContent("named_nested_map_complex.go", buf.Bytes())
   854  	require.NoErrorf(t, err, buf.String())
   855  
   856  	res := string(formatted)
   857  	assertInCode(t, k+") Validate(formats", res)
   858  	assertInCode(t, "for k := range m {", res)
   859  	assertInCode(t, "for kk := range m[k] {", res)
   860  	assertInCode(t, "for kkk := range m[k][kk] {", res)
   861  	assertInCode(t, "val.Validate(formats)", res)
   862  	assertInCode(t, "err := validate.MinLength(\"name\",", res)
   863  	assertInCode(t, "err := validate.MaxLength(\"name\",", res)
   864  	assertInCode(t, "err := validate.Pattern(\"name\",", res)
   865  	assertInCode(t, "err := validate.MinimumInt(\"age\",", res)
   866  	assertInCode(t, "err := validate.MaximumInt(\"age\",", res)
   867  	assertInCode(t, "err := validate.MultipleOfInt(\"age\",", res)
   868  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   869  }
   870  
   871  func TestSchemaValidation_NestedMapPropsComplex(t *testing.T) {
   872  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   873  	require.NoError(t, err)
   874  
   875  	k := "NestedMapComplexValidations"
   876  	schema := specDoc.Spec().Definitions[k]
   877  
   878  	opts := opts()
   879  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   880  	require.NoError(t, err)
   881  
   882  	prop := gm.Properties[0]
   883  	requireValidation(t, "\"meta\"", "m.Meta", prop)
   884  
   885  	buf := bytes.NewBuffer(nil)
   886  	err = templates.MustGet("model").Execute(buf, gm)
   887  	require.NoError(t, err)
   888  
   889  	formatted, err := opts.LanguageOpts.FormatContent("nested_map_complex_validations.go", buf.Bytes())
   890  	require.NoErrorf(t, err, buf.String())
   891  
   892  	res := string(formatted)
   893  	assertInCode(t, k+") Validate(formats", res)
   894  	assertInCode(t, "m.validateMeta(formats", res)
   895  	assertInCode(t, "for k := range m.Meta {", res)
   896  	assertInCode(t, "for kk := range m.Meta[k] {", res)
   897  	assertInCode(t, "for kkk := range m.Meta[k][kk] {", res)
   898  	assertInCode(t, "val.Validate(formats)", res)
   899  	assertInCode(t, "err := validate.MinLength(\"name\",", res)
   900  	assertInCode(t, "err := validate.MaxLength(\"name\",", res)
   901  	assertInCode(t, "err := validate.Pattern(\"name\",", res)
   902  	assertInCode(t, "err := validate.MinimumInt(\"age\",", res)
   903  	assertInCode(t, "err := validate.MaximumInt(\"age\",", res)
   904  	assertInCode(t, "err := validate.MultipleOfInt(\"age\",", res)
   905  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   906  }
   907  
   908  func TestSchemaValidation_NamedAllOf(t *testing.T) {
   909  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   910  	require.NoError(t, err)
   911  
   912  	k := "NamedAllOf"
   913  	schema := specDoc.Spec().Definitions[k]
   914  
   915  	opts := opts()
   916  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   917  	require.NoError(t, err)
   918  
   919  	requireValidation(t, "", "m", gm.GenSchema)
   920  
   921  	buf := bytes.NewBuffer(nil)
   922  	err = templates.MustGet("model").Execute(buf, gm)
   923  	require.NoError(t, err)
   924  
   925  	formatted, err := opts.LanguageOpts.FormatContent("named_all_of.go", buf.Bytes())
   926  	require.NoErrorf(t, err, buf.String())
   927  
   928  	res := string(formatted)
   929  	assertInCode(t, k+") Validate(formats", res)
   930  	assertInCode(t, k+") validateName(formats", res)
   931  	assertInCode(t, k+") validateAge(formats", res)
   932  	assertInCode(t, k+") validateArgs(formats", res)
   933  	assertInCode(t, k+") validateAssoc(formats", res)
   934  	assertInCode(t, k+") validateOpts(formats", res)
   935  	assertInCode(t, k+") validateExtOpts(formats", res)
   936  	assertInCode(t, k+") validateCoords(formats", res)
   937  	assertInCode(t, "validate.MinLength(\"name\",", res)
   938  	assertInCode(t, "validate.MinimumInt(\"age\",", res)
   939  	assertInCode(t, "validate.MinItems(\"args\",", res)
   940  	assertInCode(t, "validate.MinItems(\"assoc\",", res)
   941  	assertInCode(t, "validate.MinItems(\"assoc\"+\".\"+strconv.Itoa(i),", res)
   942  	assertInCode(t, "validate.MinItems(\"assoc\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii),", res)
   943  	assertInCode(t, "validate.MinLength(\"assoc\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   944  	assertInCode(t, "validate.Minimum(\"opts\"+\".\"+k,", res)
   945  	assertInCode(t, "validate.MinimumInt(\"extOpts\"+\".\"+k+\".\"+kk+\".\"+kkk,", res)
   946  	assertInCode(t, "validate.MinLength(\"coords\"+\".\"+\"name\",", res)
   947  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   948  }
   949  
   950  func TestSchemaValidation_AllOfProps(t *testing.T) {
   951  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   952  	require.NoError(t, err)
   953  
   954  	k := "AllOfValidations"
   955  	schema := specDoc.Spec().Definitions[k]
   956  
   957  	opts := opts()
   958  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   959  	require.NoError(t, err)
   960  
   961  	prop := gm.Properties[0]
   962  	requireValidation(t, "\"meta\"", "m.Meta", prop)
   963  	buf := bytes.NewBuffer(nil)
   964  	err = templates.MustGet("model").Execute(buf, gm)
   965  	require.NoError(t, err)
   966  
   967  	formatted, err := opts.LanguageOpts.FormatContent("all_of_validations.go", buf.Bytes())
   968  	require.NoErrorf(t, err, buf.String())
   969  
   970  	res := string(formatted)
   971  	assertInCode(t, k+") Validate(formats", res)
   972  	assertInCode(t, "m.validateMeta(formats", res)
   973  	assertInCode(t, "validate.MinLength(\"meta\"+\".\"+\"name\",", res)
   974  	assertInCode(t, "validate.MinimumInt(\"meta\"+\".\"+\"age\",", res)
   975  	assertInCode(t, "validate.MinItems(\"meta\"+\".\"+\"args\",", res)
   976  	assertInCode(t, "validate.MinItems(\"meta\"+\".\"+\"assoc\",", res)
   977  	assertInCode(t, "validate.MinItems(\"meta\"+\".\"+\"assoc\"+\".\"+strconv.Itoa(i),", res)
   978  	assertInCode(t, "validate.MinItems(\"meta\"+\".\"+\"assoc\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii),", res)
   979  	assertInCode(t, "validate.MinLength(\"meta\"+\".\"+\"assoc\"+\".\"+strconv.Itoa(i)+\".\"+strconv.Itoa(ii)+\".\"+strconv.Itoa(iii),", res)
   980  	assertInCode(t, "validate.MinimumInt(\"meta\"+\".\"+\"opts\"+\".\"+k,", res)
   981  	assertInCode(t, "validate.MinimumInt(\"meta\"+\".\"+\"extOpts\"+\".\"+k+\".\"+kk+\".\"+kkk,", res)
   982  	assertInCode(t, "validate.MinLength(\"meta\"+\".\"+\"coords\"+\".\"+\"name\",", res)
   983  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
   984  }
   985  
   986  func TestSchemaValidation_RefedAllOf(t *testing.T) {
   987  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
   988  	require.NoError(t, err)
   989  
   990  	k := "RefedAllOfValidations"
   991  	schema := specDoc.Spec().Definitions[k]
   992  
   993  	opts := opts()
   994  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
   995  	require.NoError(t, err)
   996  	require.Len(t, gm.AllOf, 2)
   997  
   998  	buf := bytes.NewBuffer(nil)
   999  	err = templates.MustGet("model").Execute(buf, gm)
  1000  	require.NoError(t, err)
  1001  
  1002  	formatted, err := opts.LanguageOpts.FormatContent("all_of_validations.go", buf.Bytes())
  1003  	require.NoErrorf(t, err, buf.String())
  1004  
  1005  	res := string(formatted)
  1006  	assertInCode(t, k+") Validate(formats", res)
  1007  	assertInCode(t, "m.NamedString.Validate(formats)", res)
  1008  	assertInCode(t, "m.NamedNumber.Validate(formats)", res)
  1009  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
  1010  }
  1011  
  1012  func TestSchemaValidation_SimpleZeroAllowed(t *testing.T) {
  1013  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
  1014  	require.NoError(t, err)
  1015  
  1016  	k := "SimpleZeroAllowed"
  1017  	schema := specDoc.Spec().Definitions[k]
  1018  
  1019  	opts := opts()
  1020  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
  1021  	require.NoError(t, err)
  1022  
  1023  	buf := bytes.NewBuffer(nil)
  1024  	err = templates.MustGet("model").Execute(buf, gm)
  1025  	require.NoError(t, err)
  1026  
  1027  	formatted, err := opts.LanguageOpts.FormatContent("simple_zero_allowed.go", buf.Bytes())
  1028  	require.NoErrorf(t, err, buf.String())
  1029  
  1030  	res := string(formatted)
  1031  	assertInCode(t, k+") Validate(formats", res)
  1032  	assertInCode(t, "swag.IsZero(m.ID)", res)
  1033  	assertInCode(t, "validate.Required(\"name\", \"body\", m.Name)", res)
  1034  	assertInCode(t, "validate.MinLength(\"id\", \"body\", m.ID, 2)", res)
  1035  	assertInCode(t, "validate.Required(\"urls\", \"body\", m.Urls)", res)
  1036  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
  1037  }
  1038  
  1039  func TestSchemaValidation_Pet(t *testing.T) {
  1040  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
  1041  	require.NoError(t, err)
  1042  
  1043  	k := "Pet"
  1044  	schema := specDoc.Spec().Definitions[k]
  1045  
  1046  	opts := opts()
  1047  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
  1048  	require.NoError(t, err)
  1049  
  1050  	buf := bytes.NewBuffer(nil)
  1051  	err = templates.MustGet("model").Execute(buf, gm)
  1052  	require.NoError(t, err)
  1053  
  1054  	formatted, err := opts.LanguageOpts.FormatContent("pet.go", buf.Bytes())
  1055  	require.NoErrorf(t, err, buf.String())
  1056  
  1057  	res := string(formatted)
  1058  	assertInCode(t, k+") Validate(formats", res)
  1059  	assertInCode(t, "swag.IsZero(m.Status)", res)
  1060  	assertInCode(t, "swag.IsZero(m.Tags)", res)
  1061  	assertInCode(t, "validate.Required(\"name\", \"body\", m.Name)", res)
  1062  	assertInCode(t, "validate.Required(\"photoUrls\", \"body\", m.PhotoUrls)", res)
  1063  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
  1064  }
  1065  
  1066  func TestSchemaValidation_UpdateOrg(t *testing.T) {
  1067  	specDoc, err := loads.Spec("../fixtures/codegen/todolist.schemavalidation.yml")
  1068  	require.NoError(t, err)
  1069  
  1070  	k := "UpdateOrg"
  1071  	schema := specDoc.Spec().Definitions[k]
  1072  
  1073  	opts := opts()
  1074  	gm, err := makeGenDefinition(k, "models", schema, specDoc, opts)
  1075  	require.NoError(t, err)
  1076  
  1077  	buf := bytes.NewBuffer(nil)
  1078  	err = templates.MustGet("model").Execute(buf, gm)
  1079  	require.NoError(t, err)
  1080  
  1081  	formatted, err := opts.LanguageOpts.FormatContent("pet.go", buf.Bytes())
  1082  	require.NoErrorf(t, err, buf.String())
  1083  
  1084  	res := string(formatted)
  1085  	assertInCode(t, k+") Validate(formats", res)
  1086  	assertInCode(t, "swag.IsZero(m.TagExpiration)", res)
  1087  	assertInCode(t, "validate.MinimumInt(\"tag_expiration\", \"body\", *m.TagExpiration", res)
  1088  	assertInCode(t, "validate.MaximumInt(\"tag_expiration\", \"body\", *m.TagExpiration", res)
  1089  	assertInCode(t, "errors.CompositeValidationError(res...)", res)
  1090  }