Source file src/github.com/go-openapi/errors/schema_test.go

Documentation: github.com/go-openapi/errors

     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 errors
    16  
    17  import (
    18  	"errors"
    19  	"testing"
    20  
    21  	"github.com/stretchr/testify/assert"
    22  	"github.com/stretchr/testify/require"
    23  )
    24  
    25  //nolint:maintidx
    26  func TestSchemaErrors(t *testing.T) {
    27  	t.Run("with InvalidType", func(t *testing.T) {
    28  		err := InvalidType("confirmed", "query", "boolean", nil)
    29  		require.Error(t, err)
    30  		assert.EqualValues(t, InvalidTypeCode, err.Code())
    31  		assert.Equal(t, "confirmed in query must be of type boolean", err.Error())
    32  
    33  		err = InvalidType("confirmed", "", "boolean", nil)
    34  		require.Error(t, err)
    35  		assert.EqualValues(t, InvalidTypeCode, err.Code())
    36  		assert.Equal(t, "confirmed must be of type boolean", err.Error())
    37  
    38  		err = InvalidType("confirmed", "query", "boolean", "hello")
    39  		require.Error(t, err)
    40  		assert.EqualValues(t, InvalidTypeCode, err.Code())
    41  		assert.Equal(t, "confirmed in query must be of type boolean: \"hello\"", err.Error())
    42  
    43  		err = InvalidType("confirmed", "query", "boolean", errors.New("hello"))
    44  		require.Error(t, err)
    45  		assert.EqualValues(t, InvalidTypeCode, err.Code())
    46  		assert.Equal(t, "confirmed in query must be of type boolean, because: hello", err.Error())
    47  
    48  		err = InvalidType("confirmed", "", "boolean", "hello")
    49  		require.Error(t, err)
    50  		assert.EqualValues(t, InvalidTypeCode, err.Code())
    51  		assert.Equal(t, "confirmed must be of type boolean: \"hello\"", err.Error())
    52  
    53  		err = InvalidType("confirmed", "", "boolean", errors.New("hello"))
    54  		require.Error(t, err)
    55  		assert.EqualValues(t, InvalidTypeCode, err.Code())
    56  		assert.Equal(t, "confirmed must be of type boolean, because: hello", err.Error())
    57  	})
    58  
    59  	t.Run("with DuplicateItems", func(t *testing.T) {
    60  		err := DuplicateItems("uniques", "query")
    61  		require.Error(t, err)
    62  		assert.EqualValues(t, UniqueFailCode, err.Code())
    63  		assert.Equal(t, "uniques in query shouldn't contain duplicates", err.Error())
    64  
    65  		err = DuplicateItems("uniques", "")
    66  		require.Error(t, err)
    67  		assert.EqualValues(t, UniqueFailCode, err.Code())
    68  		assert.Equal(t, "uniques shouldn't contain duplicates", err.Error())
    69  	})
    70  
    71  	t.Run("with TooMany/TooFew Items", func(t *testing.T) {
    72  		err := TooManyItems("something", "query", 5, 6)
    73  		require.Error(t, err)
    74  		assert.EqualValues(t, MaxItemsFailCode, err.Code())
    75  		assert.Equal(t, "something in query should have at most 5 items", err.Error())
    76  		assert.Equal(t, 6, err.Value)
    77  
    78  		err = TooManyItems("something", "", 5, 6)
    79  		require.Error(t, err)
    80  		assert.EqualValues(t, MaxItemsFailCode, err.Code())
    81  		assert.Equal(t, "something should have at most 5 items", err.Error())
    82  		assert.Equal(t, 6, err.Value)
    83  
    84  		err = TooFewItems("something", "", 5, 4)
    85  		require.Error(t, err)
    86  		assert.EqualValues(t, MinItemsFailCode, err.Code())
    87  		assert.Equal(t, "something should have at least 5 items", err.Error())
    88  		assert.Equal(t, 4, err.Value)
    89  	})
    90  
    91  	t.Run("with ExceedsMaximum", func(t *testing.T) {
    92  		err := ExceedsMaximumInt("something", "query", 5, false, 6)
    93  		require.Error(t, err)
    94  		assert.EqualValues(t, MaxFailCode, err.Code())
    95  		assert.Equal(t, "something in query should be less than or equal to 5", err.Error())
    96  		assert.Equal(t, 6, err.Value)
    97  
    98  		err = ExceedsMaximumInt("something", "", 5, false, 6)
    99  		require.Error(t, err)
   100  		assert.EqualValues(t, MaxFailCode, err.Code())
   101  		assert.Equal(t, "something should be less than or equal to 5", err.Error())
   102  		assert.Equal(t, 6, err.Value)
   103  
   104  		err = ExceedsMaximumInt("something", "query", 5, true, 6)
   105  		require.Error(t, err)
   106  		assert.EqualValues(t, MaxFailCode, err.Code())
   107  		assert.Equal(t, "something in query should be less than 5", err.Error())
   108  		assert.Equal(t, 6, err.Value)
   109  
   110  		err = ExceedsMaximumInt("something", "", 5, true, 6)
   111  		require.Error(t, err)
   112  		assert.EqualValues(t, MaxFailCode, err.Code())
   113  		assert.Equal(t, "something should be less than 5", err.Error())
   114  		assert.Equal(t, 6, err.Value)
   115  
   116  		err = ExceedsMaximumUint("something", "query", 5, false, 6)
   117  		require.Error(t, err)
   118  		assert.EqualValues(t, MaxFailCode, err.Code())
   119  		assert.Equal(t, "something in query should be less than or equal to 5", err.Error())
   120  		assert.Equal(t, 6, err.Value)
   121  
   122  		err = ExceedsMaximumUint("something", "", 5, false, 6)
   123  		require.Error(t, err)
   124  		assert.EqualValues(t, MaxFailCode, err.Code())
   125  		assert.Equal(t, "something should be less than or equal to 5", err.Error())
   126  		assert.Equal(t, 6, err.Value)
   127  
   128  		err = ExceedsMaximumUint("something", "query", 5, true, 6)
   129  		require.Error(t, err)
   130  		assert.EqualValues(t, MaxFailCode, err.Code())
   131  		assert.Equal(t, "something in query should be less than 5", err.Error())
   132  		assert.Equal(t, 6, err.Value)
   133  
   134  		err = ExceedsMaximumUint("something", "", 5, true, 6)
   135  		require.Error(t, err)
   136  		assert.EqualValues(t, MaxFailCode, err.Code())
   137  		assert.Equal(t, "something should be less than 5", err.Error())
   138  		assert.Equal(t, 6, err.Value)
   139  
   140  		err = ExceedsMaximum("something", "query", 5, false, 6)
   141  		require.Error(t, err)
   142  		assert.EqualValues(t, MaxFailCode, err.Code())
   143  		assert.Equal(t, "something in query should be less than or equal to 5", err.Error())
   144  		assert.Equal(t, 6, err.Value)
   145  
   146  		err = ExceedsMaximum("something", "", 5, false, 6)
   147  		require.Error(t, err)
   148  		assert.EqualValues(t, MaxFailCode, err.Code())
   149  		assert.Equal(t, "something should be less than or equal to 5", err.Error())
   150  		assert.Equal(t, 6, err.Value)
   151  
   152  		err = ExceedsMaximum("something", "query", 5, true, 6)
   153  		require.Error(t, err)
   154  		assert.EqualValues(t, MaxFailCode, err.Code())
   155  		assert.Equal(t, "something in query should be less than 5", err.Error())
   156  		assert.Equal(t, 6, err.Value)
   157  
   158  		err = ExceedsMaximum("something", "", 5, true, 6)
   159  		require.Error(t, err)
   160  		assert.EqualValues(t, MaxFailCode, err.Code())
   161  		assert.Equal(t, "something should be less than 5", err.Error())
   162  		assert.Equal(t, 6, err.Value)
   163  	})
   164  
   165  	t.Run("with ExceedsMinimum", func(t *testing.T) {
   166  		err := ExceedsMinimumInt("something", "query", 5, false, 4)
   167  		require.Error(t, err)
   168  		assert.EqualValues(t, MinFailCode, err.Code())
   169  		assert.Equal(t, "something in query should be greater than or equal to 5", err.Error())
   170  		assert.Equal(t, 4, err.Value)
   171  
   172  		err = ExceedsMinimumInt("something", "", 5, false, 4)
   173  		require.Error(t, err)
   174  		assert.EqualValues(t, MinFailCode, err.Code())
   175  		assert.Equal(t, "something should be greater than or equal to 5", err.Error())
   176  		assert.Equal(t, 4, err.Value)
   177  
   178  		err = ExceedsMinimumInt("something", "query", 5, true, 4)
   179  		require.Error(t, err)
   180  		assert.EqualValues(t, MinFailCode, err.Code())
   181  		assert.Equal(t, "something in query should be greater than 5", err.Error())
   182  		assert.Equal(t, 4, err.Value)
   183  
   184  		err = ExceedsMinimumInt("something", "", 5, true, 4)
   185  		require.Error(t, err)
   186  		assert.EqualValues(t, MinFailCode, err.Code())
   187  		assert.Equal(t, "something should be greater than 5", err.Error())
   188  		assert.Equal(t, 4, err.Value)
   189  
   190  		err = ExceedsMinimumUint("something", "query", 5, false, 4)
   191  		require.Error(t, err)
   192  		assert.EqualValues(t, MinFailCode, err.Code())
   193  		assert.Equal(t, "something in query should be greater than or equal to 5", err.Error())
   194  		assert.Equal(t, 4, err.Value)
   195  
   196  		err = ExceedsMinimumUint("something", "", 5, false, 4)
   197  		require.Error(t, err)
   198  		assert.EqualValues(t, MinFailCode, err.Code())
   199  		assert.Equal(t, "something should be greater than or equal to 5", err.Error())
   200  		assert.Equal(t, 4, err.Value)
   201  
   202  		err = ExceedsMinimumUint("something", "query", 5, true, 4)
   203  		require.Error(t, err)
   204  		assert.EqualValues(t, MinFailCode, err.Code())
   205  		assert.Equal(t, "something in query should be greater than 5", err.Error())
   206  		assert.Equal(t, 4, err.Value)
   207  
   208  		err = ExceedsMinimumUint("something", "", 5, true, 4)
   209  		require.Error(t, err)
   210  		assert.EqualValues(t, MinFailCode, err.Code())
   211  		assert.Equal(t, "something should be greater than 5", err.Error())
   212  		assert.Equal(t, 4, err.Value)
   213  
   214  		err = ExceedsMinimum("something", "query", 5, false, 4)
   215  		require.Error(t, err)
   216  		assert.EqualValues(t, MinFailCode, err.Code())
   217  		assert.Equal(t, "something in query should be greater than or equal to 5", err.Error())
   218  		assert.Equal(t, 4, err.Value)
   219  
   220  		err = ExceedsMinimum("something", "", 5, false, 4)
   221  		require.Error(t, err)
   222  		assert.EqualValues(t, MinFailCode, err.Code())
   223  		assert.Equal(t, "something should be greater than or equal to 5", err.Error())
   224  		assert.Equal(t, 4, err.Value)
   225  
   226  		err = ExceedsMinimum("something", "query", 5, true, 4)
   227  		require.Error(t, err)
   228  		assert.EqualValues(t, MinFailCode, err.Code())
   229  		assert.Equal(t, "something in query should be greater than 5", err.Error())
   230  		assert.Equal(t, 4, err.Value)
   231  
   232  		err = ExceedsMinimum("something", "", 5, true, 4)
   233  		require.Error(t, err)
   234  		assert.EqualValues(t, MinFailCode, err.Code())
   235  		assert.Equal(t, "something should be greater than 5", err.Error())
   236  		assert.Equal(t, 4, err.Value)
   237  
   238  		err = NotMultipleOf("something", "query", 5, 1)
   239  		require.Error(t, err)
   240  		assert.EqualValues(t, MultipleOfFailCode, err.Code())
   241  		assert.Equal(t, "something in query should be a multiple of 5", err.Error())
   242  		assert.Equal(t, 1, err.Value)
   243  	})
   244  
   245  	t.Run("with MultipleOf", func(t *testing.T) {
   246  		err := NotMultipleOf("something", "query", float64(5), float64(1))
   247  		require.Error(t, err)
   248  		assert.EqualValues(t, MultipleOfFailCode, err.Code())
   249  		assert.Equal(t, "something in query should be a multiple of 5", err.Error())
   250  		assert.InDelta(t, float64(1), err.Value, 1e-6)
   251  
   252  		err = NotMultipleOf("something", "query", uint64(5), uint64(1))
   253  		require.Error(t, err)
   254  		assert.EqualValues(t, MultipleOfFailCode, err.Code())
   255  		assert.Equal(t, "something in query should be a multiple of 5", err.Error())
   256  		assert.Equal(t, uint64(1), err.Value)
   257  
   258  		err = NotMultipleOf("something", "", 5, 1)
   259  		require.Error(t, err)
   260  		assert.EqualValues(t, MultipleOfFailCode, err.Code())
   261  		assert.Equal(t, "something should be a multiple of 5", err.Error())
   262  		assert.Equal(t, 1, err.Value)
   263  
   264  		err = MultipleOfMustBePositive("path", "body", float64(-10))
   265  		require.Error(t, err)
   266  		assert.EqualValues(t, MultipleOfMustBePositiveCode, err.Code())
   267  		assert.Equal(t, `factor MultipleOf declared for path must be positive: -10`, err.Error())
   268  		assert.InDelta(t, float64(-10), err.Value, 1e-6)
   269  
   270  		err = MultipleOfMustBePositive("path", "body", int64(-10))
   271  		require.Error(t, err)
   272  		assert.EqualValues(t, MultipleOfMustBePositiveCode, err.Code())
   273  		assert.Equal(t, `factor MultipleOf declared for path must be positive: -10`, err.Error())
   274  		assert.Equal(t, int64(-10), err.Value)
   275  	})
   276  
   277  	t.Run("with EnumFail", func(t *testing.T) {
   278  		err := EnumFail("something", "query", "yada", []interface{}{"hello", "world"})
   279  		require.Error(t, err)
   280  		assert.EqualValues(t, EnumFailCode, err.Code())
   281  		assert.Equal(t, "something in query should be one of [hello world]", err.Error())
   282  		assert.Equal(t, "yada", err.Value)
   283  
   284  		err = EnumFail("something", "", "yada", []interface{}{"hello", "world"})
   285  		require.Error(t, err)
   286  		assert.EqualValues(t, EnumFailCode, err.Code())
   287  		assert.Equal(t, "something should be one of [hello world]", err.Error())
   288  		assert.Equal(t, "yada", err.Value)
   289  	})
   290  
   291  	t.Run("with Required", func(t *testing.T) {
   292  		err := Required("something", "query", nil)
   293  		require.Error(t, err)
   294  		assert.EqualValues(t, RequiredFailCode, err.Code())
   295  		assert.Equal(t, "something in query is required", err.Error())
   296  		assert.Nil(t, err.Value)
   297  
   298  		err = Required("something", "", nil)
   299  		require.Error(t, err)
   300  		assert.EqualValues(t, RequiredFailCode, err.Code())
   301  		assert.Equal(t, "something is required", err.Error())
   302  		assert.Nil(t, err.Value)
   303  	})
   304  
   305  	t.Run("with ReadOnly", func(t *testing.T) {
   306  		err := ReadOnly("something", "query", nil)
   307  		require.Error(t, err)
   308  		assert.EqualValues(t, ReadOnlyFailCode, err.Code())
   309  		assert.Equal(t, "something in query is readOnly", err.Error())
   310  		assert.Nil(t, err.Value)
   311  
   312  		err = ReadOnly("something", "", nil)
   313  		require.Error(t, err)
   314  		assert.EqualValues(t, ReadOnlyFailCode, err.Code())
   315  		assert.Equal(t, "something is readOnly", err.Error())
   316  		assert.Nil(t, err.Value)
   317  	})
   318  
   319  	t.Run("with TooLong/TooShort", func(t *testing.T) {
   320  		err := TooLong("something", "query", 5, "abcdef")
   321  		require.Error(t, err)
   322  		assert.EqualValues(t, TooLongFailCode, err.Code())
   323  		assert.Equal(t, "something in query should be at most 5 chars long", err.Error())
   324  		assert.Equal(t, "abcdef", err.Value)
   325  
   326  		err = TooLong("something", "", 5, "abcdef")
   327  		require.Error(t, err)
   328  		assert.EqualValues(t, TooLongFailCode, err.Code())
   329  		assert.Equal(t, "something should be at most 5 chars long", err.Error())
   330  		assert.Equal(t, "abcdef", err.Value)
   331  
   332  		err = TooShort("something", "query", 5, "a")
   333  		require.Error(t, err)
   334  		assert.EqualValues(t, TooShortFailCode, err.Code())
   335  		assert.Equal(t, "something in query should be at least 5 chars long", err.Error())
   336  		assert.Equal(t, "a", err.Value)
   337  
   338  		err = TooShort("something", "", 5, "a")
   339  		require.Error(t, err)
   340  		assert.EqualValues(t, TooShortFailCode, err.Code())
   341  		assert.Equal(t, "something should be at least 5 chars long", err.Error())
   342  		assert.Equal(t, "a", err.Value)
   343  	})
   344  
   345  	t.Run("with FailedPattern", func(t *testing.T) {
   346  		err := FailedPattern("something", "query", "\\d+", "a")
   347  		require.Error(t, err)
   348  		assert.EqualValues(t, PatternFailCode, err.Code())
   349  		assert.Equal(t, "something in query should match '\\d+'", err.Error())
   350  		assert.Equal(t, "a", err.Value)
   351  
   352  		err = FailedPattern("something", "", "\\d+", "a")
   353  		require.Error(t, err)
   354  		assert.EqualValues(t, PatternFailCode, err.Code())
   355  		assert.Equal(t, "something should match '\\d+'", err.Error())
   356  		assert.Equal(t, "a", err.Value)
   357  	})
   358  
   359  	t.Run("with InvalidType", func(t *testing.T) {
   360  		err := InvalidTypeName("something")
   361  		require.Error(t, err)
   362  		assert.EqualValues(t, InvalidTypeCode, err.Code())
   363  		assert.Equal(t, "something is an invalid type name", err.Error())
   364  	})
   365  
   366  	t.Run("with AdditionalItemsNotAllowed", func(t *testing.T) {
   367  		err := AdditionalItemsNotAllowed("something", "query")
   368  		require.Error(t, err)
   369  		assert.EqualValues(t, NoAdditionalItemsCode, err.Code())
   370  		assert.Equal(t, "something in query can't have additional items", err.Error())
   371  
   372  		err = AdditionalItemsNotAllowed("something", "")
   373  		require.Error(t, err)
   374  		assert.EqualValues(t, NoAdditionalItemsCode, err.Code())
   375  		assert.Equal(t, "something can't have additional items", err.Error())
   376  	})
   377  
   378  	err := InvalidCollectionFormat("something", "query", "yada")
   379  	require.Error(t, err)
   380  	assert.EqualValues(t, InvalidTypeCode, err.Code())
   381  	assert.Equal(t, "the collection format \"yada\" is not supported for the query param \"something\"", err.Error())
   382  
   383  	t.Run("with CompositeValidationError", func(t *testing.T) {
   384  		err := CompositeValidationError()
   385  		require.Error(t, err)
   386  		assert.EqualValues(t, CompositeErrorCode, err.Code())
   387  		assert.Equal(t, "validation failure list", err.Error())
   388  
   389  		testErr1 := errors.New("first error")
   390  		testErr2 := errors.New("second error")
   391  		err = CompositeValidationError(testErr1, testErr2)
   392  		require.Error(t, err)
   393  		assert.EqualValues(t, CompositeErrorCode, err.Code())
   394  		assert.Equal(t, "validation failure list:\nfirst error\nsecond error", err.Error())
   395  
   396  		require.ErrorIs(t, err, testErr1)
   397  		require.ErrorIs(t, err, testErr2)
   398  	})
   399  
   400  	t.Run("should set validation name in CompositeValidation error", func(t *testing.T) {
   401  		err := CompositeValidationError(
   402  			InvalidContentType("text/html", []string{"application/json"}),
   403  			CompositeValidationError(
   404  				InvalidTypeName("y"),
   405  			),
   406  		)
   407  		_ = err.ValidateName("new-name")
   408  		const expectedMessage = `validation failure list:
   409  new-name.unsupported media type "text/html", only [application/json] are allowed
   410  validation failure list:
   411  new-namey is an invalid type name`
   412  		assert.Equal(t, expectedMessage, err.Error())
   413  	})
   414  
   415  	t.Run("with PropertyNotAllowed", func(t *testing.T) {
   416  		err = PropertyNotAllowed("path", "body", "key")
   417  		require.Error(t, err)
   418  		assert.EqualValues(t, UnallowedPropertyCode, err.Code())
   419  		// unallowedProperty         = "%s.%s in %s is a forbidden property"
   420  		assert.Equal(t, "path.key in body is a forbidden property", err.Error())
   421  
   422  		err = PropertyNotAllowed("path", "", "key")
   423  		require.Error(t, err)
   424  		assert.EqualValues(t, UnallowedPropertyCode, err.Code())
   425  		// unallowedPropertyNoIn     = "%s.%s is a forbidden property"
   426  		assert.Equal(t, "path.key is a forbidden property", err.Error())
   427  	})
   428  
   429  	t.Run("with TooMany/TooFew properties", func(t *testing.T) {
   430  		err := TooManyProperties("path", "body", 10)
   431  		require.Error(t, err)
   432  		assert.EqualValues(t, TooManyPropertiesCode, err.Code())
   433  		// tooManyProperties         = "%s in %s should have at most %d properties"
   434  		assert.Equal(t, "path in body should have at most 10 properties", err.Error())
   435  
   436  		err = TooManyProperties("path", "", 10)
   437  		require.Error(t, err)
   438  		assert.EqualValues(t, TooManyPropertiesCode, err.Code())
   439  		// tooManyPropertiesNoIn     = "%s should have at most %d properties"
   440  		assert.Equal(t, "path should have at most 10 properties", err.Error())
   441  
   442  		err = TooFewProperties("path", "body", 10)
   443  		require.Error(t, err)
   444  		assert.EqualValues(t, TooFewPropertiesCode, err.Code())
   445  		// tooFewProperties          = "%s in %s should have at least %d properties"
   446  		assert.Equal(t, "path in body should have at least 10 properties", err.Error())
   447  
   448  		err = TooFewProperties("path", "", 10)
   449  		require.Error(t, err)
   450  		assert.EqualValues(t, TooFewPropertiesCode, err.Code())
   451  		// tooFewPropertiesNoIn      = "%s should have at least %d properties"
   452  		assert.Equal(t, "path should have at least 10 properties", err.Error())
   453  	})
   454  
   455  	t.Run("with PatternProperties", func(t *testing.T) {
   456  		err := FailedAllPatternProperties("path", "body", "key")
   457  		require.Error(t, err)
   458  		assert.EqualValues(t, FailedAllPatternPropsCode, err.Code())
   459  		// failedAllPatternProps     = "%s.%s in %s failed all pattern properties"
   460  		assert.Equal(t, "path.key in body failed all pattern properties", err.Error())
   461  
   462  		err = FailedAllPatternProperties("path", "", "key")
   463  		require.Error(t, err)
   464  		assert.EqualValues(t, FailedAllPatternPropsCode, err.Code())
   465  		// failedAllPatternPropsNoIn = "%s.%s failed all pattern properties"
   466  		assert.Equal(t, "path.key failed all pattern properties", err.Error())
   467  	})
   468  }
   469  

View as plain text