github.com/System-Glitch/goyave/v2@v2.10.3-0.20200819142921-51011e75d504/validation/rules_test.go (about)

     1  package validation
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  )
     8  
     9  func TestValidateRequired(t *testing.T) {
    10  	assert.True(t, validateRequired("field", "not empty", []string{}, map[string]interface{}{"field": "not empty"}))
    11  	assert.True(t, validateRequired("field", 1, []string{}, map[string]interface{}{"field": 1}))
    12  	assert.True(t, validateRequired("field", 2.5, []string{}, map[string]interface{}{"field": 2.5}))
    13  	assert.True(t, validateRequired("field", []string{}, []string{}, map[string]interface{}{"field": []string{}}))
    14  	assert.True(t, validateRequired("field", []float64{}, []string{}, map[string]interface{}{"field": []float64{}}))
    15  	assert.True(t, validateRequired("field", 0, []string{}, map[string]interface{}{"field": 0}))
    16  	assert.True(t, validateRequired("field", nil, []string{}, map[string]interface{}{"field": nil}))
    17  	assert.False(t, validateRequired("field", "", []string{}, map[string]interface{}{"field": ""}))
    18  }
    19  
    20  func TestValidateMin(t *testing.T) {
    21  	assert.True(t, validateMin("field", "not numeric", []string{"2"}, map[string]interface{}{}))
    22  	assert.False(t, validateMin("field", "not numeric", []string{"20"}, map[string]interface{}{}))
    23  	assert.False(t, validateMin("field", "πŸ‡©πŸ‡ͺ", []string{"2"}, map[string]interface{}{}))
    24  	assert.False(t, validateMin("field", "πŸ‘πŸΌ", []string{"2"}, map[string]interface{}{}))
    25  
    26  	assert.True(t, validateMin("field", 2, []string{"1"}, map[string]interface{}{}))
    27  	assert.False(t, validateMin("field", 10, []string{"20"}, map[string]interface{}{}))
    28  
    29  	assert.True(t, validateMin("field", 2.0, []string{"2"}, map[string]interface{}{}))
    30  	assert.False(t, validateMin("field", 10.0, []string{"20"}, map[string]interface{}{}))
    31  	assert.True(t, validateMin("field", 3.7, []string{"2.5"}, map[string]interface{}{}))
    32  	assert.False(t, validateMin("field", 10.0, []string{"20.4"}, map[string]interface{}{}))
    33  
    34  	assert.True(t, validateMin("field", []int{5, 4}, []string{"2"}, map[string]interface{}{}))
    35  	assert.False(t, validateMin("field", []int{5, 4, 3, 2}, []string{"20"}, map[string]interface{}{}))
    36  
    37  	assert.True(t, validateMin("field", []string{"5", "4"}, []string{"2"}, map[string]interface{}{}))
    38  	assert.False(t, validateMin("field", []string{"5", "4", "3", "2"}, []string{"20"}, map[string]interface{}{}))
    39  
    40  	assert.True(t, validateMin("field", true, []string{"2"}, map[string]interface{}{}))
    41  	assert.Panics(t, func() { validateMin("field", true, []string{"test"}, map[string]interface{}{}) })
    42  
    43  	assert.True(t, validateMin("file", createTestFiles(largeLogoPath), []string{"2"}, map[string]interface{}{}))
    44  	assert.True(t, validateMin("file", createTestFiles(mediumLogoPath, largeLogoPath), []string{"1"}, map[string]interface{}{}))
    45  	assert.False(t, validateMin("file", createTestFiles(logoPath), []string{"1"}, map[string]interface{}{}))
    46  	assert.False(t, validateMin("file", createTestFiles(logoPath, largeLogoPath), []string{"1"}, map[string]interface{}{}))
    47  
    48  	assert.Panics(t, func() {
    49  		field := &Field{
    50  			Rules: []*Rule{
    51  				{Name: "min"},
    52  			},
    53  		}
    54  		field.check()
    55  	})
    56  }
    57  
    58  func TestValidateMax(t *testing.T) {
    59  	assert.True(t, validateMax("field", "not numeric", []string{"12"}, map[string]interface{}{}))
    60  	assert.False(t, validateMax("field", "not numeric", []string{"5"}, map[string]interface{}{}))
    61  	assert.True(t, validateMax("field", "πŸ‡©πŸ‡ͺπŸ‡©πŸ‡ͺπŸ‘πŸΌ", []string{"5"}, map[string]interface{}{}))
    62  	assert.True(t, validateMax("field", "πŸ‡©πŸ‡ͺπŸ‡©πŸ‡ͺπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌ", []string{"5"}, map[string]interface{}{}))
    63  	assert.False(t, validateMax("field", "πŸ‡©πŸ‡ͺπŸ‡©πŸ‡ͺπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌ", []string{"5"}, map[string]interface{}{}))
    64  
    65  	assert.True(t, validateMax("field", 1, []string{"2"}, map[string]interface{}{}))
    66  	assert.False(t, validateMax("field", 20, []string{"10"}, map[string]interface{}{}))
    67  
    68  	assert.True(t, validateMax("field", 2.0, []string{"2"}, map[string]interface{}{}))
    69  	assert.False(t, validateMax("field", 10.0, []string{"5"}, map[string]interface{}{}))
    70  	assert.True(t, validateMax("field", 2.5, []string{"3.7"}, map[string]interface{}{}))
    71  	assert.False(t, validateMax("field", 20.4, []string{"10.0"}, map[string]interface{}{}))
    72  
    73  	assert.True(t, validateMax("field", []int{5, 4}, []string{"2"}, map[string]interface{}{}))
    74  	assert.False(t, validateMax("field", []int{5, 4, 3, 2}, []string{"3"}, map[string]interface{}{}))
    75  
    76  	assert.True(t, validateMax("field", []string{"5", "4"}, []string{"3"}, map[string]interface{}{}))
    77  	assert.False(t, validateMax("field", []string{"5", "4", "3", "2"}, []string{"2"}, map[string]interface{}{}))
    78  
    79  	assert.True(t, validateMax("field", true, []string{"2"}, map[string]interface{}{}))
    80  	assert.Panics(t, func() { validateMax("field", true, []string{"test"}, map[string]interface{}{}) })
    81  
    82  	assert.False(t, validateMax("file", createTestFiles(largeLogoPath), []string{"2"}, map[string]interface{}{}))
    83  	assert.False(t, validateMax("file", createTestFiles(mediumLogoPath, largeLogoPath), []string{"1"}, map[string]interface{}{}))
    84  	assert.True(t, validateMax("file", createTestFiles(logoPath), []string{"1"}, map[string]interface{}{}))
    85  	assert.True(t, validateMax("file", createTestFiles(logoPath, configPath), []string{"1"}, map[string]interface{}{}))
    86  
    87  	assert.Panics(t, func() {
    88  		field := &Field{
    89  			Rules: []*Rule{
    90  				{Name: "max"},
    91  			},
    92  		}
    93  		field.check()
    94  	})
    95  }
    96  
    97  func TestValidateBetween(t *testing.T) {
    98  	assert.True(t, validateBetween("field", "not numeric", []string{"5", "12"}, map[string]interface{}{}))
    99  	assert.False(t, validateBetween("field", "not numeric", []string{"12", "20"}, map[string]interface{}{}))
   100  	assert.False(t, validateBetween("field", "not numeric", []string{"5", "6"}, map[string]interface{}{}))
   101  
   102  	assert.False(t, validateBetween("field", "πŸ‡©πŸ‡ͺ", []string{"2", "5"}, map[string]interface{}{}))
   103  	assert.False(t, validateBetween("field", "πŸ‘πŸΌ", []string{"2", "5"}, map[string]interface{}{}))
   104  	assert.True(t, validateBetween("field", "πŸ‘πŸΌπŸ‡©πŸ‡ͺ", []string{"2", "5"}, map[string]interface{}{}))
   105  	assert.True(t, validateBetween("field", "πŸ‡©πŸ‡ͺπŸ‡©πŸ‡ͺπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌ", []string{"2", "5"}, map[string]interface{}{}))
   106  	assert.False(t, validateBetween("field", "πŸ‡©πŸ‡ͺπŸ‡©πŸ‡ͺπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌ", []string{"2", "5"}, map[string]interface{}{}))
   107  
   108  	assert.True(t, validateBetween("field", 1, []string{"0", "3"}, map[string]interface{}{}))
   109  	assert.False(t, validateBetween("field", 20, []string{"5", "10"}, map[string]interface{}{}))
   110  	assert.False(t, validateBetween("field", 20, []string{"21", "23"}, map[string]interface{}{}))
   111  
   112  	assert.True(t, validateBetween("field", 2.0, []string{"2", "5"}, map[string]interface{}{}))
   113  	assert.True(t, validateBetween("field", 2.0, []string{"1.0", "5.0"}, map[string]interface{}{}))
   114  	assert.False(t, validateBetween("field", 10.0, []string{"5", "7"}, map[string]interface{}{}))
   115  	assert.False(t, validateBetween("field", 10.0, []string{"15", "17"}, map[string]interface{}{}))
   116  	assert.True(t, validateBetween("field", 2.5, []string{"1.7", "3.7"}, map[string]interface{}{}))
   117  	assert.False(t, validateBetween("field", 20.4, []string{"10.0", "14.7"}, map[string]interface{}{}))
   118  	assert.False(t, validateBetween("field", 20.4, []string{"25.0", "54.7"}, map[string]interface{}{}))
   119  
   120  	assert.True(t, validateBetween("field", []int{5, 4}, []string{"1", "5"}, map[string]interface{}{}))
   121  	assert.True(t, validateBetween("field", []int{5, 4}, []string{"2.2", "5.7"}, map[string]interface{}{}))
   122  	assert.False(t, validateBetween("field", []int{5, 4, 3, 2}, []string{"1", "3"}, map[string]interface{}{}))
   123  	assert.False(t, validateBetween("field", []int{5, 4, 3, 2}, []string{"5", "7"}, map[string]interface{}{}))
   124  
   125  	assert.True(t, validateBetween("field", []string{"5", "4"}, []string{"1", "5"}, map[string]interface{}{}))
   126  	assert.True(t, validateBetween("field", []string{"5", "4"}, []string{"2.2", "5.7"}, map[string]interface{}{}))
   127  	assert.False(t, validateBetween("field", []string{"5", "4", "3", "2"}, []string{"1", "3"}, map[string]interface{}{}))
   128  	assert.False(t, validateBetween("field", []string{"5", "4", "3", "2"}, []string{"5", "7"}, map[string]interface{}{}))
   129  
   130  	assert.True(t, validateBetween("field", true, []string{"2", "3"}, map[string]interface{}{}))
   131  	assert.Panics(t, func() { validateBetween("field", true, []string{"test"}, map[string]interface{}{}) })
   132  	assert.Panics(t, func() { validateBetween("field", true, []string{"1"}, map[string]interface{}{}) })
   133  	assert.Panics(t, func() { validateBetween("field", true, []string{"test", "2"}, map[string]interface{}{}) })
   134  	assert.Panics(t, func() { validateBetween("field", true, []string{"2", "test"}, map[string]interface{}{}) })
   135  
   136  	assert.True(t, validateBetween("file", createTestFiles(largeLogoPath), []string{"2", "50"}, map[string]interface{}{}))
   137  	assert.True(t, validateBetween("file", createTestFiles(mediumLogoPath, largeLogoPath), []string{"8", "42"}, map[string]interface{}{}))
   138  	assert.False(t, validateBetween("file", createTestFiles(logoPath), []string{"5", "10"}, map[string]interface{}{}))
   139  	assert.False(t, validateBetween("file", createTestFiles(logoPath, mediumLogoPath), []string{"5", "10"}, map[string]interface{}{}))
   140  
   141  	assert.Panics(t, func() {
   142  		field := &Field{
   143  			Rules: []*Rule{
   144  				{Name: "between"},
   145  			},
   146  		}
   147  		field.check()
   148  	})
   149  
   150  	assert.Panics(t, func() {
   151  		field := &Field{
   152  			Rules: []*Rule{
   153  				{Name: "between", Params: []string{"2"}},
   154  			},
   155  		}
   156  		field.check()
   157  	})
   158  }
   159  
   160  func TestValidateGreaterThan(t *testing.T) {
   161  	assert.True(t, validateGreaterThan("field", 5, []string{"comparison"}, map[string]interface{}{"field": 5, "comparison": 2}))
   162  	assert.False(t, validateGreaterThan("field", 5, []string{"comparison"}, map[string]interface{}{"field": 5, "comparison": 20}))
   163  
   164  	assert.True(t, validateGreaterThan("field", 5.0, []string{"comparison"}, map[string]interface{}{"field": 5.0, "comparison": 2.0}))
   165  	assert.False(t, validateGreaterThan("field", 5.0, []string{"comparison"}, map[string]interface{}{"field": 5.0, "comparison": 5.1}))
   166  
   167  	assert.True(t, validateGreaterThan("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "str"}))
   168  	assert.False(t, validateGreaterThan("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "other string"}))
   169  
   170  	assert.True(t, validateGreaterThan("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "πŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌ"}))
   171  	assert.False(t, validateGreaterThan("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "πŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌ"}))
   172  
   173  	assert.True(t, validateGreaterThan("field", []int{5, 2}, []string{"comparison"}, map[string]interface{}{"field": []int{5, 2}, "comparison": []int{1}}))
   174  	assert.False(t, validateGreaterThan("field", []int{6}, []string{"comparison"}, map[string]interface{}{"field": []int{6}, "comparison": []int{1, 2, 3}}))
   175  
   176  	// Different type
   177  	assert.False(t, validateGreaterThan("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": 2}))
   178  
   179  	// Missing field
   180  	assert.False(t, validateGreaterThan("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string"}))
   181  
   182  	// Unsupported type
   183  	test := "string"
   184  	assert.True(t, validateGreaterThan("field", &test, []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": &test}))
   185  
   186  	files := createTestFiles(largeLogoPath)
   187  	otherFiles := createTestFiles(logoPath)
   188  	assert.True(t, validateGreaterThan("file", files, []string{"otherFiles"}, map[string]interface{}{"file": files, "otherFiles": otherFiles}))
   189  	assert.False(t, validateGreaterThan("file", otherFiles, []string{"file"}, map[string]interface{}{"file": files, "otherFiles": otherFiles}))
   190  
   191  	assert.Panics(t, func() {
   192  		field := &Field{
   193  			Rules: []*Rule{
   194  				{Name: "greater_than"},
   195  			},
   196  		}
   197  		field.check()
   198  	})
   199  }
   200  
   201  func TestValidateGreaterThanEqual(t *testing.T) {
   202  	assert.True(t, validateGreaterThanEqual("field", 5, []string{"comparison"}, map[string]interface{}{"field": 5, "comparison": 2}))
   203  	assert.True(t, validateGreaterThanEqual("field", 5, []string{"comparison"}, map[string]interface{}{"field": 5, "comparison": 5}))
   204  	assert.False(t, validateGreaterThanEqual("field", 5, []string{"comparison"}, map[string]interface{}{"field": 5, "comparison": 20}))
   205  	assert.False(t, validateGreaterThanEqual("field", 5, []string{"comparison"}, map[string]interface{}{"field": 5, "comparison": 5.1}))
   206  
   207  	assert.True(t, validateGreaterThanEqual("field", 5.0, []string{"comparison"}, map[string]interface{}{"field": 5.0, "comparison": 2.0}))
   208  	assert.True(t, validateGreaterThanEqual("field", 5.0, []string{"comparison"}, map[string]interface{}{"field": 5.0, "comparison": 5.0}))
   209  	assert.False(t, validateGreaterThanEqual("field", 5.0, []string{"comparison"}, map[string]interface{}{"field": 5.0, "comparison": 5.1}))
   210  
   211  	assert.True(t, validateGreaterThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "str"}))
   212  	assert.True(t, validateGreaterThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "gnirts"}))
   213  	assert.False(t, validateGreaterThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "other string"}))
   214  
   215  	assert.True(t, validateGreaterThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "πŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌ"}))
   216  	assert.True(t, validateGreaterThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "πŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌ"}))
   217  	assert.False(t, validateGreaterThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "πŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌ"}))
   218  
   219  	assert.True(t, validateGreaterThanEqual("field", []int{5, 2}, []string{"comparison"}, map[string]interface{}{"field": []int{5, 2}, "comparison": []int{1}}))
   220  	assert.True(t, validateGreaterThanEqual("field", []int{5, 2}, []string{"comparison"}, map[string]interface{}{"field": []int{5, 2}, "comparison": []int{1, 2}}))
   221  	assert.False(t, validateGreaterThanEqual("field", []int{6}, []string{"comparison"}, map[string]interface{}{"field": []int{6}, "comparison": []int{1, 2, 3}}))
   222  
   223  	// Different type
   224  	assert.False(t, validateGreaterThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": 2}))
   225  
   226  	// Missing field
   227  	assert.False(t, validateGreaterThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string"}))
   228  
   229  	// Unsupported type
   230  	test := "string"
   231  	assert.True(t, validateGreaterThanEqual("field", &test, []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": &test}))
   232  
   233  	files := createTestFiles(largeLogoPath)
   234  	otherFiles := createTestFiles(logoPath)
   235  	assert.True(t, validateGreaterThanEqual("file", files, []string{"otherFiles"}, map[string]interface{}{"file": files, "otherFiles": otherFiles}))
   236  	assert.False(t, validateGreaterThanEqual("file", otherFiles, []string{"file"}, map[string]interface{}{"file": files, "otherFiles": otherFiles}))
   237  
   238  	files = createTestFiles(logoPath)
   239  	otherFiles = createTestFiles(logoPath)
   240  	assert.True(t, validateGreaterThanEqual("file", files, []string{"otherFiles"}, map[string]interface{}{"file": files, "otherFiles": otherFiles}))
   241  
   242  	assert.Panics(t, func() {
   243  		field := &Field{
   244  			Rules: []*Rule{
   245  				{Name: "greater_than_equal"},
   246  			},
   247  		}
   248  		field.check()
   249  	})
   250  }
   251  
   252  func TestValidateLowerThan(t *testing.T) {
   253  	assert.True(t, validateLowerThan("field", 5, []string{"comparison"}, map[string]interface{}{"field": 5, "comparison": 7}))
   254  	assert.False(t, validateLowerThan("field", 20, []string{"comparison"}, map[string]interface{}{"field": 20, "comparison": 5}))
   255  
   256  	assert.True(t, validateLowerThan("field", 5.0, []string{"comparison"}, map[string]interface{}{"field": 5.0, "comparison": 7.0}))
   257  	assert.False(t, validateLowerThan("field", 5.0, []string{"comparison"}, map[string]interface{}{"field": 5.0, "comparison": 4.9}))
   258  
   259  	assert.True(t, validateLowerThan("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "other string"}))
   260  	assert.False(t, validateLowerThan("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "str"}))
   261  
   262  	assert.True(t, validateLowerThan("field", "πŸ‘πŸΌπŸ‘πŸΌ", []string{"comparison"}, map[string]interface{}{"field": "πŸ‘πŸΌπŸ‘πŸΌ", "comparison": "str"}))
   263  	assert.False(t, validateLowerThan("field", "st", []string{"comparison"}, map[string]interface{}{"field": "st", "comparison": "πŸ‘πŸΌ"}))
   264  
   265  	assert.True(t, validateLowerThan("field", []int{5, 2}, []string{"comparison"}, map[string]interface{}{"field": []int{5, 2}, "comparison": []int{1, 2, 3}}))
   266  	assert.False(t, validateLowerThan("field", []int{6, 7, 8}, []string{"comparison"}, map[string]interface{}{"field": []int{6, 7, 8}, "comparison": []int{1, 2}}))
   267  
   268  	// Different type
   269  	assert.False(t, validateLowerThan("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": 2}))
   270  
   271  	// Missing field
   272  	assert.False(t, validateLowerThan("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string"}))
   273  
   274  	// Unsupported type
   275  	test := "string"
   276  	assert.True(t, validateLowerThan("field", &test, []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": &test}))
   277  
   278  	files := createTestFiles(logoPath)
   279  	otherFiles := createTestFiles(largeLogoPath)
   280  	assert.True(t, validateLowerThan("file", files, []string{"otherFiles"}, map[string]interface{}{"file": files, "otherFiles": otherFiles}))
   281  	assert.False(t, validateLowerThan("file", otherFiles, []string{"file"}, map[string]interface{}{"file": files, "otherFiles": otherFiles}))
   282  
   283  	assert.Panics(t, func() {
   284  		field := &Field{
   285  			Rules: []*Rule{
   286  				{Name: "lower_than"},
   287  			},
   288  		}
   289  		field.check()
   290  	})
   291  }
   292  
   293  func TestValidateLowerThanEqual(t *testing.T) {
   294  	assert.True(t, validateLowerThanEqual("field", 5, []string{"comparison"}, map[string]interface{}{"field": 5, "comparison": 7}))
   295  	assert.True(t, validateLowerThanEqual("field", 5, []string{"comparison"}, map[string]interface{}{"field": 5, "comparison": 5}))
   296  	assert.False(t, validateLowerThanEqual("field", 20, []string{"comparison"}, map[string]interface{}{"field": 20, "comparison": 5}))
   297  	assert.False(t, validateLowerThanEqual("field", 5, []string{"comparison"}, map[string]interface{}{"field": 5, "comparison": 4.9}))
   298  
   299  	assert.True(t, validateLowerThanEqual("field", 5.0, []string{"comparison"}, map[string]interface{}{"field": 5.0, "comparison": 7.0}))
   300  	assert.True(t, validateLowerThanEqual("field", 5.0, []string{"comparison"}, map[string]interface{}{"field": 5.0, "comparison": 5.0}))
   301  	assert.False(t, validateLowerThanEqual("field", 5.0, []string{"comparison"}, map[string]interface{}{"field": 5.0, "comparison": 4.9}))
   302  
   303  	assert.True(t, validateLowerThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "other string"}))
   304  	assert.True(t, validateLowerThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "gnirts"}))
   305  	assert.False(t, validateLowerThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": "str"}))
   306  
   307  	assert.True(t, validateLowerThanEqual("field", "πŸ‘πŸΌπŸ‘πŸΌ", []string{"comparison"}, map[string]interface{}{"field": "πŸ‘πŸΌπŸ‘πŸΌ", "comparison": "str"}))
   308  	assert.True(t, validateLowerThanEqual("field", "πŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌ", []string{"comparison"}, map[string]interface{}{"field": "πŸ‘πŸΌπŸ‘πŸΌπŸ‘πŸΌ", "comparison": "str"}))
   309  	assert.False(t, validateLowerThanEqual("field", "st", []string{"comparison"}, map[string]interface{}{"field": "st", "comparison": "πŸ‘πŸΌ"}))
   310  
   311  	assert.True(t, validateLowerThanEqual("field", []int{5, 2}, []string{"comparison"}, map[string]interface{}{"field": []int{5, 2}, "comparison": []int{1, 2, 3}}))
   312  	assert.True(t, validateLowerThanEqual("field", []int{5, 2}, []string{"comparison"}, map[string]interface{}{"field": []int{5, 2}, "comparison": []int{1, 2}}))
   313  	assert.False(t, validateLowerThanEqual("field", []int{6, 7, 8}, []string{"comparison"}, map[string]interface{}{"field": []int{6, 7, 8}, "comparison": []int{1, 2}}))
   314  
   315  	// Different type
   316  	assert.False(t, validateLowerThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": 2}))
   317  
   318  	// Missing field
   319  	assert.False(t, validateLowerThanEqual("field", "string", []string{"comparison"}, map[string]interface{}{"field": "string"}))
   320  
   321  	// Unsupported type
   322  	test := "string"
   323  	assert.True(t, validateLowerThanEqual("field", &test, []string{"comparison"}, map[string]interface{}{"field": "string", "comparison": &test}))
   324  
   325  	files := createTestFiles(logoPath)
   326  	otherFiles := createTestFiles(largeLogoPath)
   327  	assert.True(t, validateLowerThanEqual("file", files, []string{"otherFiles"}, map[string]interface{}{"file": files, "otherFiles": otherFiles}))
   328  	assert.False(t, validateLowerThanEqual("file", otherFiles, []string{"file"}, map[string]interface{}{"file": files, "otherFiles": otherFiles}))
   329  
   330  	files = createTestFiles(logoPath)
   331  	otherFiles = createTestFiles(logoPath)
   332  	assert.True(t, validateLowerThanEqual("file", files, []string{"otherFiles"}, map[string]interface{}{"file": files, "otherFiles": otherFiles}))
   333  
   334  	assert.Panics(t, func() {
   335  		field := &Field{
   336  			Rules: []*Rule{
   337  				{Name: "lower_than_equal"},
   338  			},
   339  		}
   340  		field.check()
   341  	})
   342  }
   343  
   344  func TestValidateBool(t *testing.T) {
   345  	assert.True(t, validateBool("field", 1, []string{}, map[string]interface{}{}))
   346  	assert.True(t, validateBool("field", 0, []string{}, map[string]interface{}{}))
   347  	assert.True(t, validateBool("field", "on", []string{}, map[string]interface{}{}))
   348  	assert.True(t, validateBool("field", "off", []string{}, map[string]interface{}{}))
   349  	assert.True(t, validateBool("field", "true", []string{}, map[string]interface{}{}))
   350  	assert.True(t, validateBool("field", "false", []string{}, map[string]interface{}{}))
   351  	assert.True(t, validateBool("field", "yes", []string{}, map[string]interface{}{}))
   352  	assert.True(t, validateBool("field", "no", []string{}, map[string]interface{}{}))
   353  	assert.True(t, validateBool("field", true, []string{}, map[string]interface{}{}))
   354  	assert.True(t, validateBool("field", false, []string{}, map[string]interface{}{}))
   355  
   356  	assert.False(t, validateBool("field", 0.0, []string{}, map[string]interface{}{}))
   357  	assert.False(t, validateBool("field", 1.0, []string{}, map[string]interface{}{}))
   358  	assert.False(t, validateBool("field", []string{"true"}, []string{}, map[string]interface{}{}))
   359  	assert.False(t, validateBool("field", -1, []string{}, map[string]interface{}{}))
   360  }
   361  
   362  func TestValidateBoolConvert(t *testing.T) {
   363  	form := map[string]interface{}{"field": "on"}
   364  	assert.True(t, validateBool("field", form["field"], []string{}, form))
   365  	b, ok := form["field"].(bool)
   366  	assert.True(t, ok)
   367  	assert.True(t, b)
   368  
   369  	form = map[string]interface{}{"field": "off"}
   370  	assert.True(t, validateBool("field", form["field"], []string{}, form))
   371  	b, ok = form["field"].(bool)
   372  	assert.True(t, ok)
   373  	assert.False(t, b)
   374  
   375  	form = map[string]interface{}{"field": 1}
   376  	assert.True(t, validateBool("field", form["field"], []string{}, form))
   377  	b, ok = form["field"].(bool)
   378  	assert.True(t, ok)
   379  	assert.True(t, b)
   380  
   381  	form = map[string]interface{}{"field": 0}
   382  	assert.True(t, validateBool("field", form["field"], []string{}, form))
   383  	b, ok = form["field"].(bool)
   384  	assert.True(t, ok)
   385  	assert.False(t, b)
   386  }
   387  
   388  func TestValidateSame(t *testing.T) {
   389  	assert.True(t, validateSame("field", "password", []string{"other"}, map[string]interface{}{"field": "password", "other": "password"}))
   390  	assert.True(t, validateSame("field", 1, []string{"other"}, map[string]interface{}{"field": 1, "other": 1}))
   391  	assert.True(t, validateSame("field", 1.2, []string{"other"}, map[string]interface{}{"field": 1.2, "other": 1.2}))
   392  	assert.True(t, validateSame("field", []string{"one", "two", "three"}, []string{"other"}, map[string]interface{}{"field": []string{"one", "two", "three"}, "other": []string{"one", "two", "three"}}))
   393  
   394  	assert.False(t, validateSame("field", 1, []string{"other"}, map[string]interface{}{"field": 1, "other": 2}))
   395  	assert.False(t, validateSame("field", 1.1, []string{"other"}, map[string]interface{}{"field": 1.1, "other": 1}))
   396  	assert.False(t, validateSame("field", "password", []string{"other"}, map[string]interface{}{"field": "password", "other": "not password"}))
   397  	assert.False(t, validateSame("field", "no other", []string{"other"}, map[string]interface{}{"field": "no other"}))
   398  	assert.False(t, validateSame("field", []string{"one", "two"}, []string{"other"}, map[string]interface{}{"field": []string{"one", "two"}, "other": []string{"one", "two", "three"}}))
   399  
   400  	assert.Panics(t, func() {
   401  		field := &Field{
   402  			Rules: []*Rule{
   403  				{Name: "same"},
   404  			},
   405  		}
   406  		field.check()
   407  	})
   408  }
   409  
   410  func TestValidateDifferent(t *testing.T) {
   411  	assert.False(t, validateDifferent("field", "password", []string{"other"}, map[string]interface{}{"field": "password", "other": "password"}))
   412  	assert.False(t, validateDifferent("field", 1, []string{"other"}, map[string]interface{}{"field": 1, "other": 1}))
   413  	assert.False(t, validateDifferent("field", 1.2, []string{"other"}, map[string]interface{}{"field": 1.2, "other": 1.2}))
   414  	assert.False(t, validateDifferent("field", []string{"one", "two", "three"}, []string{"other"}, map[string]interface{}{"field": []string{"one", "two", "three"}, "other": []string{"one", "two", "three"}}))
   415  
   416  	assert.True(t, validateDifferent("field", 1, []string{"other"}, map[string]interface{}{"field": 1, "other": 2}))
   417  	assert.True(t, validateDifferent("field", 1.1, []string{"other"}, map[string]interface{}{"field": 1.1, "other": 1}))
   418  	assert.True(t, validateDifferent("field", "password", []string{"other"}, map[string]interface{}{"field": "password", "other": "not password"}))
   419  	assert.True(t, validateDifferent("field", "no other", []string{"other"}, map[string]interface{}{"field": "no other"}))
   420  	assert.True(t, validateDifferent("field", []string{"one", "two"}, []string{"other"}, map[string]interface{}{"field": []string{"one", "two"}, "other": []string{"one", "two", "three"}}))
   421  
   422  	assert.Panics(t, func() {
   423  		field := &Field{
   424  			Rules: []*Rule{
   425  				{Name: "different"},
   426  			},
   427  		}
   428  		field.check()
   429  	})
   430  }
   431  
   432  func TestValidateConfirmed(t *testing.T) {
   433  	assert.True(t, validateConfirmed("field", "password", []string{}, map[string]interface{}{"field": "password", "field_confirmation": "password"}))
   434  	assert.True(t, validateConfirmed("field", 1, []string{}, map[string]interface{}{"field": 1, "field_confirmation": 1}))
   435  	assert.True(t, validateConfirmed("field", 1.2, []string{}, map[string]interface{}{"field": 1.2, "field_confirmation": 1.2}))
   436  	assert.True(t, validateConfirmed("field", []string{"one", "two", "three"}, []string{}, map[string]interface{}{"field": []string{"one", "two", "three"}, "field_confirmation": []string{"one", "two", "three"}}))
   437  
   438  	assert.False(t, validateConfirmed("field", 1, []string{}, map[string]interface{}{"field": 1, "field_confirmation": 2}))
   439  	assert.False(t, validateConfirmed("field", 1.1, []string{}, map[string]interface{}{"field": 1.1, "field_confirmation": 1}))
   440  	assert.False(t, validateConfirmed("field", "password", []string{}, map[string]interface{}{"field": "password", "field_confirmation": "not password"}))
   441  	assert.False(t, validateConfirmed("field", "no confirm", []string{}, map[string]interface{}{"field": "no confirm"}))
   442  	assert.False(t, validateConfirmed("field", []string{"one", "two"}, []string{}, map[string]interface{}{"field": []string{"one", "two"}, "field_confirmation": []string{"one", "two", "three"}}))
   443  }
   444  
   445  func TestValidateSize(t *testing.T) {
   446  	assert.True(t, validateSize("field", "123", []string{"3"}, map[string]interface{}{}))
   447  	assert.True(t, validateSize("field", "", []string{"0"}, map[string]interface{}{}))
   448  	assert.False(t, validateSize("field", "4567", []string{"5"}, map[string]interface{}{}))
   449  	assert.False(t, validateSize("field", "4567", []string{"2"}, map[string]interface{}{}))
   450  
   451  	assert.True(t, validateSize("field", "πŸ‡©πŸ‡ͺπŸ‘πŸΌ", []string{"2"}, map[string]interface{}{}))
   452  	assert.True(t, validateSize("field", "πŸ‘πŸΌ!", []string{"2"}, map[string]interface{}{}))
   453  	assert.False(t, validateSize("field", "πŸ‘πŸΌ", []string{"2"}, map[string]interface{}{}))
   454  
   455  	assert.False(t, validateSize("field", 4567, []string{"2"}, map[string]interface{}{}))
   456  	assert.False(t, validateSize("field", 4567.8, []string{"2"}, map[string]interface{}{}))
   457  
   458  	// Unsupported type
   459  	assert.True(t, validateSize("field", true, []string{"2"}, map[string]interface{}{}))
   460  
   461  	assert.Panics(t, func() { validateSize("field", "123", []string{"test"}, map[string]interface{}{}) })
   462  
   463  	assert.True(t, validateSize("field", []string{"a", "b", "c"}, []string{"3"}, map[string]interface{}{}))
   464  	assert.False(t, validateSize("field", []string{"a", "b", "c", "d"}, []string{"3"}, map[string]interface{}{}))
   465  
   466  	assert.True(t, validateSize("field", 5, []string{"5"}, map[string]interface{}{}))
   467  	assert.False(t, validateSize("field", 3, []string{"5"}, map[string]interface{}{}))
   468  
   469  	assert.True(t, validateSize("file", createTestFiles(logoPath), []string{"1"}, map[string]interface{}{}))
   470  	assert.True(t, validateSize("file", createTestFiles(largeLogoPath), []string{"42"}, map[string]interface{}{}))
   471  	assert.False(t, validateSize("file", createTestFiles(logoPath), []string{"3"}, map[string]interface{}{}))
   472  
   473  	assert.Panics(t, func() {
   474  		field := &Field{
   475  			Rules: []*Rule{
   476  				{Name: "size"},
   477  			},
   478  		}
   479  		field.check()
   480  	})
   481  }