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

     1  package validation
     2  
     3  import (
     4  	"net"
     5  	"net/url"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/google/uuid"
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestValidateString(t *testing.T) {
    14  	assert.True(t, validateString("field", "string", []string{}, map[string]interface{}{}))
    15  	assert.False(t, validateString("field", 2, []string{}, map[string]interface{}{}))
    16  	assert.False(t, validateString("field", 2.5, []string{}, map[string]interface{}{}))
    17  	assert.False(t, validateString("field", []byte{}, []string{}, map[string]interface{}{}))
    18  	assert.False(t, validateString("field", []string{}, []string{}, map[string]interface{}{}))
    19  }
    20  
    21  func TestValidateDigits(t *testing.T) {
    22  	assert.True(t, validateDigits("field", "123", []string{}, map[string]interface{}{}))
    23  	assert.True(t, validateDigits("field", "0123456789", []string{}, map[string]interface{}{}))
    24  	assert.False(t, validateDigits("field", "2.3", []string{}, map[string]interface{}{}))
    25  	assert.False(t, validateDigits("field", "-123", []string{}, map[string]interface{}{}))
    26  	assert.False(t, validateDigits("field", "abcd", []string{}, map[string]interface{}{}))
    27  	assert.False(t, validateDigits("field", "/*-&é\"'(-è_ç", []string{}, map[string]interface{}{}))
    28  
    29  	// Not string
    30  	assert.False(t, validateDigits("field", 1, []string{}, map[string]interface{}{}))
    31  	assert.False(t, validateDigits("field", 1.2, []string{}, map[string]interface{}{}))
    32  	assert.False(t, validateDigits("field", true, []string{}, map[string]interface{}{}))
    33  }
    34  
    35  func TestValidateRegex(t *testing.T) {
    36  	assert.True(t, validateRegex("field", "sghtyhg", []string{"t"}, map[string]interface{}{}))
    37  	assert.True(t, validateRegex("field", "sghtyhg", []string{"[^\\s]"}, map[string]interface{}{}))
    38  	assert.False(t, validateRegex("field", "sgh tyhg", []string{"^[^\\s]+$"}, map[string]interface{}{}))
    39  	assert.False(t, validateRegex("field", "48s9", []string{"^[^0-9]+$"}, map[string]interface{}{}))
    40  	assert.True(t, validateRegex("field", "489", []string{"^[0-9]+$"}, map[string]interface{}{}))
    41  	assert.False(t, validateRegex("field", 489, []string{"^[^0-9]+$"}, map[string]interface{}{}))
    42  
    43  	assert.Panics(t, func() { validateRegex("field", "", []string{"doesn't compile \\"}, map[string]interface{}{}) })
    44  
    45  	assert.Panics(t, func() {
    46  		field := &Field{
    47  			Rules: []*Rule{
    48  				{Name: "regex"},
    49  			},
    50  		}
    51  		field.check()
    52  	})
    53  }
    54  
    55  func TestValidateEmail(t *testing.T) {
    56  	assert.True(t, validateEmail("field", "simple@example.com", []string{}, map[string]interface{}{}))
    57  	assert.True(t, validateEmail("field", "very.common@example.com", []string{}, map[string]interface{}{}))
    58  	assert.True(t, validateEmail("field", "disposable.style.email.with+symbol@example.com", []string{}, map[string]interface{}{}))
    59  	assert.True(t, validateEmail("field", "other.email-with-hyphen@example.com", []string{}, map[string]interface{}{}))
    60  	assert.True(t, validateEmail("field", "fully-qualified-domain@example.com", []string{}, map[string]interface{}{}))
    61  	assert.True(t, validateEmail("field", "user.name+tag+sorting@example.com", []string{}, map[string]interface{}{}))
    62  	assert.True(t, validateEmail("field", "x@example.com", []string{}, map[string]interface{}{}))
    63  	assert.True(t, validateEmail("field", "example-indeed@strange-example.com", []string{}, map[string]interface{}{}))
    64  	assert.True(t, validateEmail("field", "admin@mailserver1", []string{}, map[string]interface{}{}))
    65  	assert.True(t, validateEmail("field", "example@s.example", []string{}, map[string]interface{}{}))
    66  	assert.True(t, validateEmail("field", "\" \"@example.org", []string{}, map[string]interface{}{}))
    67  	assert.True(t, validateEmail("field", "\"john..doe\"@example.org", []string{}, map[string]interface{}{}))
    68  	assert.True(t, validateEmail("field", "mailhost!username@example.org", []string{}, map[string]interface{}{}))
    69  	assert.True(t, validateEmail("field", "user%example.com@example.org", []string{}, map[string]interface{}{}))
    70  	assert.False(t, validateEmail("field", "Abc.example.com", []string{}, map[string]interface{}{}))
    71  	assert.False(t, validateEmail("field", "1234567890123456789012345678901234567890123456789012345678901234+x@example.com", []string{}, map[string]interface{}{}))
    72  }
    73  
    74  func TestValidateAlpha(t *testing.T) {
    75  	assert.True(t, validateAlpha("field", "helloworld", []string{}, map[string]interface{}{}))
    76  	assert.True(t, validateAlpha("field", "éèçàû", []string{}, map[string]interface{}{}))
    77  	assert.False(t, validateAlpha("field", "hello world", []string{}, map[string]interface{}{}))
    78  	assert.False(t, validateAlpha("field", "/+*(@)={}\"'", []string{}, map[string]interface{}{}))
    79  	assert.False(t, validateAlpha("field", "helloworld2", []string{}, map[string]interface{}{}))
    80  	assert.False(t, validateAlpha("field", 2, []string{}, map[string]interface{}{}))
    81  }
    82  
    83  func TestValidateAlphaDash(t *testing.T) {
    84  	assert.True(t, validateAlphaDash("field", "helloworld", []string{}, map[string]interface{}{}))
    85  	assert.True(t, validateAlphaDash("field", "éèçàû_-", []string{}, map[string]interface{}{}))
    86  	assert.True(t, validateAlphaDash("field", "hello-world", []string{}, map[string]interface{}{}))
    87  	assert.True(t, validateAlphaDash("field", "hello-world_2", []string{}, map[string]interface{}{}))
    88  	assert.False(t, validateAlphaDash("field", "hello world", []string{}, map[string]interface{}{}))
    89  	assert.False(t, validateAlphaDash("field", "/+*(@)={}\"'", []string{}, map[string]interface{}{}))
    90  	assert.False(t, validateAlphaDash("field", 2, []string{}, map[string]interface{}{}))
    91  }
    92  
    93  func TestValidateAlphaNumeric(t *testing.T) {
    94  	assert.True(t, validateAlphaNumeric("field", "helloworld2", []string{}, map[string]interface{}{}))
    95  	assert.True(t, validateAlphaNumeric("field", "éèçàû2", []string{}, map[string]interface{}{}))
    96  	assert.True(t, validateAlphaNumeric("field", "helloworld2", []string{}, map[string]interface{}{}))
    97  	assert.False(t, validateAlphaNumeric("field", "hello world", []string{}, map[string]interface{}{}))
    98  	assert.False(t, validateAlphaNumeric("field", "/+*(@)={}\"'", []string{}, map[string]interface{}{}))
    99  	assert.False(t, validateAlphaNumeric("field", 2, []string{}, map[string]interface{}{}))
   100  }
   101  
   102  func TestValidateStartsWith(t *testing.T) {
   103  	assert.True(t, validateStartsWith("field", "hello world", []string{"hello"}, map[string]interface{}{}))
   104  	assert.True(t, validateStartsWith("field", "hi", []string{"hello", "hi", "hey"}, map[string]interface{}{}))
   105  	assert.False(t, validateStartsWith("field", "sup'!", []string{"hello", "hi", "hey"}, map[string]interface{}{}))
   106  
   107  	assert.Panics(t, func() {
   108  		field := &Field{
   109  			Rules: []*Rule{
   110  				{Name: "starts_with"},
   111  			},
   112  		}
   113  		field.check()
   114  	})
   115  }
   116  
   117  func TestValidateEndsWith(t *testing.T) {
   118  	assert.True(t, validateEndsWith("field", "hello world", []string{"world"}, map[string]interface{}{}))
   119  	assert.True(t, validateEndsWith("field", "oh hi mark", []string{"ross", "mark", "bruce"}, map[string]interface{}{}))
   120  	assert.False(t, validateEndsWith("field", "sup' bro!", []string{"ross", "mark", "bruce"}, map[string]interface{}{}))
   121  
   122  	assert.Panics(t, func() {
   123  		field := &Field{
   124  			Rules: []*Rule{
   125  				{Name: "ends_with"},
   126  			},
   127  		}
   128  		field.check()
   129  	})
   130  }
   131  
   132  func TestValidateTimezone(t *testing.T) {
   133  	assert.True(t, validateTimezone("field", "UTC", []string{}, map[string]interface{}{}))
   134  	assert.True(t, validateTimezone("field", "Europe/Paris", []string{}, map[string]interface{}{}))
   135  	assert.True(t, validateTimezone("field", "America/St_Thomas", []string{}, map[string]interface{}{}))
   136  	assert.True(t, validateTimezone("field", "GMT", []string{}, map[string]interface{}{}))
   137  	assert.False(t, validateTimezone("field", "GMT+2", []string{}, map[string]interface{}{}))
   138  	assert.False(t, validateTimezone("field", "UTC+2", []string{}, map[string]interface{}{}))
   139  	assert.False(t, validateTimezone("field", "here", []string{}, map[string]interface{}{}))
   140  	assert.False(t, validateTimezone("field", 1, []string{}, map[string]interface{}{}))
   141  	assert.False(t, validateTimezone("field", 1.5, []string{}, map[string]interface{}{}))
   142  	assert.False(t, validateTimezone("field", true, []string{}, map[string]interface{}{}))
   143  	assert.False(t, validateTimezone("field", []string{"UTC"}, []string{}, map[string]interface{}{}))
   144  }
   145  
   146  func TestValidateTimezoneConvert(t *testing.T) {
   147  	form := map[string]interface{}{"field": "UTC"}
   148  	assert.True(t, validateTimezone("field", form["field"], []string{}, form))
   149  
   150  	_, ok := form["field"].(*time.Location)
   151  	assert.True(t, ok)
   152  }
   153  
   154  func TestValidateIP(t *testing.T) {
   155  	assert.True(t, validateIP("field", "127.0.0.1", []string{}, map[string]interface{}{}))
   156  	assert.True(t, validateIP("field", "192.168.0.1", []string{}, map[string]interface{}{}))
   157  	assert.True(t, validateIP("field", "88.88.88.88", []string{}, map[string]interface{}{}))
   158  	assert.True(t, validateIP("field", "2001:0db8:85a3:0000:0000:8a2e:0370:7334", []string{}, map[string]interface{}{}))
   159  	assert.True(t, validateIP("field", "2001:db8:85a3::8a2e:370:7334", []string{}, map[string]interface{}{}))
   160  	assert.True(t, validateIP("field", "2001:db8:85a3:0:0:8a2e:370:7334", []string{}, map[string]interface{}{}))
   161  	assert.True(t, validateIP("field", "2001:db8:85a3:8d3:1319:8a2e:370:7348", []string{}, map[string]interface{}{}))
   162  	assert.True(t, validateIP("field", "::1", []string{}, map[string]interface{}{}))
   163  
   164  	assert.False(t, validateIP("field", "1", []string{}, map[string]interface{}{}))
   165  	assert.False(t, validateIP("field", 1, []string{}, map[string]interface{}{}))
   166  	assert.False(t, validateIP("field", 1.2, []string{}, map[string]interface{}{}))
   167  	assert.False(t, validateIP("field", true, []string{}, map[string]interface{}{}))
   168  	assert.False(t, validateIP("field", []byte{}, []string{}, map[string]interface{}{}))
   169  }
   170  
   171  func TestValidateIPConvert(t *testing.T) {
   172  	form := map[string]interface{}{"field": "127.0.0.1"}
   173  	assert.True(t, validateIP("field", form["field"], []string{}, form))
   174  
   175  	_, ok := form["field"].(net.IP)
   176  	assert.True(t, ok)
   177  }
   178  
   179  func TestValidateIPv4(t *testing.T) {
   180  	assert.True(t, validateIPv4("field", "127.0.0.1", []string{}, map[string]interface{}{}))
   181  	assert.True(t, validateIPv4("field", "192.168.0.1", []string{}, map[string]interface{}{}))
   182  	assert.True(t, validateIPv4("field", "88.88.88.88", []string{}, map[string]interface{}{}))
   183  	assert.False(t, validateIPv4("field", "2001:0db8:85a3:0000:0000:8a2e:0370:7334", []string{}, map[string]interface{}{}))
   184  	assert.False(t, validateIPv4("field", "2001:db8:85a3::8a2e:370:7334", []string{}, map[string]interface{}{}))
   185  	assert.False(t, validateIPv4("field", "2001:db8:85a3:0:0:8a2e:370:7334", []string{}, map[string]interface{}{}))
   186  	assert.False(t, validateIPv4("field", "2001:db8:85a3:8d3:1319:8a2e:370:7348", []string{}, map[string]interface{}{}))
   187  	assert.False(t, validateIPv4("field", "::1", []string{}, map[string]interface{}{}))
   188  	assert.False(t, validateIPv4("field", 1, []string{}, map[string]interface{}{}))
   189  	assert.False(t, validateIPv4("field", 1.2, []string{}, map[string]interface{}{}))
   190  	assert.False(t, validateIPv4("field", true, []string{}, map[string]interface{}{}))
   191  	assert.False(t, validateIPv4("field", []byte{}, []string{}, map[string]interface{}{}))
   192  }
   193  
   194  func TestValidateIPv6(t *testing.T) {
   195  	assert.False(t, validateIPv6("field", "127.0.0.1", []string{}, map[string]interface{}{}))
   196  	assert.False(t, validateIPv6("field", "192.168.0.1", []string{}, map[string]interface{}{}))
   197  	assert.False(t, validateIPv6("field", "88.88.88.88", []string{}, map[string]interface{}{}))
   198  	assert.True(t, validateIPv6("field", "2001:0db8:85a3:0000:0000:8a2e:0370:7334", []string{}, map[string]interface{}{}))
   199  	assert.True(t, validateIPv6("field", "2001:db8:85a3::8a2e:370:7334", []string{}, map[string]interface{}{}))
   200  	assert.True(t, validateIPv6("field", "2001:db8:85a3:0:0:8a2e:370:7334", []string{}, map[string]interface{}{}))
   201  	assert.True(t, validateIPv6("field", "2001:db8:85a3:8d3:1319:8a2e:370:7348", []string{}, map[string]interface{}{}))
   202  	assert.True(t, validateIPv6("field", "::1", []string{}, map[string]interface{}{}))
   203  	assert.False(t, validateIPv6("field", 1, []string{}, map[string]interface{}{}))
   204  	assert.False(t, validateIPv6("field", 1.2, []string{}, map[string]interface{}{}))
   205  	assert.False(t, validateIPv6("field", true, []string{}, map[string]interface{}{}))
   206  	assert.False(t, validateIPv6("field", []byte{}, []string{}, map[string]interface{}{}))
   207  }
   208  
   209  func TestValidateJSON(t *testing.T) {
   210  	assert.True(t, validateJSON("field", "2", []string{}, map[string]interface{}{}))
   211  	assert.True(t, validateJSON("field", "2.5", []string{}, map[string]interface{}{}))
   212  	assert.True(t, validateJSON("field", "\"str\"", []string{}, map[string]interface{}{}))
   213  	assert.True(t, validateJSON("field", "[\"str\",\"array\"]", []string{}, map[string]interface{}{}))
   214  	assert.True(t, validateJSON("field", "{\"str\":\"object\"}", []string{}, map[string]interface{}{}))
   215  	assert.True(t, validateJSON("field", "{\"str\":[\"object\",\"array\"]}", []string{}, map[string]interface{}{}))
   216  
   217  	assert.False(t, validateJSON("field", "{str:[\"object\",\"array\"]}", []string{}, map[string]interface{}{}))
   218  	assert.False(t, validateJSON("field", "", []string{}, map[string]interface{}{}))
   219  	assert.False(t, validateJSON("field", "\"d", []string{}, map[string]interface{}{}))
   220  	assert.False(t, validateJSON("field", 1, []string{}, map[string]interface{}{}))
   221  	assert.False(t, validateJSON("field", 1.2, []string{}, map[string]interface{}{}))
   222  	assert.False(t, validateJSON("field", map[string]string{}, []string{}, map[string]interface{}{}))
   223  }
   224  
   225  func TestValidateJSONConvert(t *testing.T) {
   226  	form := map[string]interface{}{"field": "2"}
   227  	assert.True(t, validateJSON("field", form["field"], []string{}, form))
   228  	_, ok := form["field"].(float64)
   229  	assert.True(t, ok)
   230  
   231  	form = map[string]interface{}{"field": "\"str\""}
   232  	assert.True(t, validateJSON("field", form["field"], []string{}, form))
   233  	_, ok = form["field"].(string)
   234  	assert.True(t, ok)
   235  
   236  	form = map[string]interface{}{"field": "[\"str\",\"array\"]"}
   237  	assert.True(t, validateJSON("field", form["field"], []string{}, form))
   238  	_, ok = form["field"].([]interface{})
   239  	assert.True(t, ok)
   240  
   241  	form = map[string]interface{}{"field": "{\"str\":\"object\"}"}
   242  	assert.True(t, validateJSON("field", form["field"], []string{}, form))
   243  	_, ok = form["field"].(map[string]interface{})
   244  	assert.True(t, ok)
   245  }
   246  
   247  func TestValidateURL(t *testing.T) {
   248  	assert.True(t, validateURL("field", "http://www.google.com", []string{}, map[string]interface{}{}))
   249  	assert.True(t, validateURL("field", "https://www.google.com", []string{}, map[string]interface{}{}))
   250  	assert.True(t, validateURL("field", "https://www.google.com?q=a%20surprise%20to%20be%20sure", []string{}, map[string]interface{}{}))
   251  	assert.True(t, validateURL("field", "https://www.google.com/#anchor", []string{}, map[string]interface{}{}))
   252  	assert.True(t, validateURL("field", "https://www.google.com?q=hmm#anchor", []string{}, map[string]interface{}{}))
   253  
   254  	assert.False(t, validateURL("field", "https://www.google.com#anchor", []string{}, map[string]interface{}{}))
   255  	assert.False(t, validateURL("field", "www.google.com", []string{}, map[string]interface{}{}))
   256  	assert.False(t, validateURL("field", "w-w.google.com", []string{}, map[string]interface{}{}))
   257  	assert.False(t, validateURL("field", 1, []string{}, map[string]interface{}{}))
   258  	assert.False(t, validateURL("field", 1.2, []string{}, map[string]interface{}{}))
   259  	assert.False(t, validateURL("field", []string{}, []string{}, map[string]interface{}{}))
   260  }
   261  
   262  func TestValidateURLConvert(t *testing.T) {
   263  	form := map[string]interface{}{"field": "http://www.google.com"}
   264  	assert.True(t, validateURL("field", form["field"], []string{}, form))
   265  	_, ok := form["field"].(*url.URL)
   266  	assert.True(t, ok)
   267  }
   268  
   269  func TestValidateUUID(t *testing.T) {
   270  	assert.True(t, validateUUID("field", "123e4567-e89b-12d3-a456-426655440000", []string{}, map[string]interface{}{})) // V1
   271  	assert.True(t, validateUUID("field", "9125a8dc-52ee-365b-a5aa-81b0b3681cf6", []string{}, map[string]interface{}{})) // V3
   272  	assert.True(t, validateUUID("field", "9125a8dc52ee365ba5aa81b0b3681cf6", []string{}, map[string]interface{}{}))     // V3 no hyphen
   273  	assert.True(t, validateUUID("field", "11bf5b37-e0b8-42e0-8dcf-dc8c4aefc000", []string{}, map[string]interface{}{})) // V4
   274  	assert.True(t, validateUUID("field", "11bf5b37e0b842e08dcfdc8c4aefc000", []string{}, map[string]interface{}{}))     // V4 no hyphen
   275  	assert.True(t, validateUUID("field", "fdda765f-fc57-5604-a269-52a7df8164ec", []string{}, map[string]interface{}{})) // V5
   276  	assert.True(t, validateUUID("field", "3bbcee75-cecc-5b56-8031-b6641c1ed1f1", []string{}, map[string]interface{}{})) // V5
   277  	assert.True(t, validateUUID("field", "3bbcee75cecc5b568031b6641c1ed1f1", []string{}, map[string]interface{}{}))     // V5 no hypen
   278  
   279  	assert.False(t, validateUUID("field", "hello", []string{}, map[string]interface{}{}))
   280  	assert.False(t, validateUUID("field", 1, []string{}, map[string]interface{}{}))
   281  	assert.False(t, validateUUID("field", 1.2, []string{}, map[string]interface{}{}))
   282  	assert.False(t, validateUUID("field", true, []string{}, map[string]interface{}{}))
   283  	assert.False(t, validateUUID("field", []byte{}, []string{}, map[string]interface{}{}))
   284  }
   285  
   286  func TestValidateUUIDConvert(t *testing.T) {
   287  	form := map[string]interface{}{"field": "123e4567-e89b-12d3-a456-426655440000"}
   288  	assert.True(t, validateUUID("field", form["field"], []string{}, form))
   289  	_, ok := form["field"].(uuid.UUID)
   290  	assert.True(t, ok)
   291  }
   292  
   293  func TestValidateUUIDv3(t *testing.T) {
   294  	assert.True(t, validateUUID("field", "9125a8dc-52ee-365b-a5aa-81b0b3681cf6", []string{"3"}, map[string]interface{}{}))  // V3
   295  	assert.False(t, validateUUID("field", "11bf5b37-e0b8-42e0-8dcf-dc8c4aefc000", []string{"3"}, map[string]interface{}{})) // V4
   296  	assert.False(t, validateUUID("field", "fdda765f-fc57-5604-a269-52a7df8164ec", []string{"3"}, map[string]interface{}{})) // V5
   297  }
   298  
   299  func TestValidateUUIDv4(t *testing.T) {
   300  	assert.False(t, validateUUID("field", "9125a8dc-52ee-365b-a5aa-81b0b3681cf6", []string{"4"}, map[string]interface{}{})) // V3
   301  	assert.True(t, validateUUID("field", "11bf5b37-e0b8-42e0-8dcf-dc8c4aefc000", []string{"4"}, map[string]interface{}{}))  // V4
   302  	assert.False(t, validateUUID("field", "fdda765f-fc57-5604-a269-52a7df8164ec", []string{"4"}, map[string]interface{}{})) // V5
   303  }
   304  
   305  func TestValidateUUIDv5(t *testing.T) {
   306  	assert.False(t, validateUUID("field", "9125a8dc-52ee-365b-a5aa-81b0b3681cf6", []string{"5"}, map[string]interface{}{})) // V3
   307  	assert.False(t, validateUUID("field", "11bf5b37-e0b8-42e0-8dcf-dc8c4aefc000", []string{"5"}, map[string]interface{}{})) // V4
   308  	assert.True(t, validateUUID("field", "fdda765f-fc57-5604-a269-52a7df8164ec", []string{"5"}, map[string]interface{}{}))  // V5
   309  }