github.com/System-Glitch/goyave/v2@v2.10.3-0.20200819142921-51011e75d504/validation/arrays_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 TestValidateArray(t *testing.T) {
    14  	assert.True(t, validateArray("field", []string{"test"}, []string{}, map[string]interface{}{}))
    15  	assert.True(t, validateArray("field", []int{5}, []string{}, map[string]interface{}{}))
    16  	assert.True(t, validateArray("field", []float64{5.5}, []string{}, map[string]interface{}{}))
    17  	assert.True(t, validateArray("field", []bool{true}, []string{}, map[string]interface{}{}))
    18  	assert.False(t, validateArray("field", map[string]string{}, []string{}, map[string]interface{}{}))
    19  	assert.False(t, validateArray("field", "test", []string{}, map[string]interface{}{}))
    20  	assert.False(t, validateArray("field", 5, []string{}, map[string]interface{}{}))
    21  	assert.False(t, validateArray("field", 5.0, []string{}, map[string]interface{}{}))
    22  	assert.False(t, validateArray("field", true, []string{}, map[string]interface{}{}))
    23  
    24  	// With type validation
    25  	assert.Panics(t, func() {
    26  		validateArray("field", []float64{5.5}, []string{"file"}, map[string]interface{}{})
    27  	})
    28  	assert.Panics(t, func() {
    29  		validateArray("field", []float64{5.5}, []string{"array"}, map[string]interface{}{})
    30  	})
    31  	assert.Panics(t, func() {
    32  		validateArray("field", []float64{5.5}, []string{"not a type"}, map[string]interface{}{})
    33  	})
    34  	assert.False(t, validateArray("field", []string{"0.5", "not numeric"}, []string{"numeric"}, map[string]interface{}{}))
    35  
    36  	data := map[string]interface{}{}
    37  	assert.True(t, validateArray("field", []string{"0.5", "1.42"}, []string{"numeric"}, data))
    38  	arr, ok := data["field"].([]float64)
    39  	assert.True(t, ok)
    40  	if ok {
    41  		assert.Equal(t, 0.5, arr[0])
    42  		assert.Equal(t, 1.42, arr[1])
    43  	}
    44  
    45  	data = map[string]interface{}{}
    46  	assert.True(t, validateArray("field", []float64{0.5, 1.42}, []string{"numeric"}, data))
    47  	arr, ok = data["field"].([]float64)
    48  	assert.True(t, ok)
    49  	if ok {
    50  		assert.Equal(t, 0.5, arr[0])
    51  		assert.Equal(t, 1.42, arr[1])
    52  	}
    53  
    54  	data = map[string]interface{}{}
    55  	assert.True(t, validateArray("field", []string{"12", "42"}, []string{"integer"}, data))
    56  	arrInt, ok := data["field"].([]int)
    57  	assert.True(t, ok)
    58  	if ok {
    59  		assert.Equal(t, 12, arrInt[0])
    60  		assert.Equal(t, 42, arrInt[1])
    61  	}
    62  
    63  	data = map[string]interface{}{}
    64  	assert.True(t, validateArray("field", []string{"UTC", "America/New_York"}, []string{"timezone"}, data))
    65  	arrLoc, ok := data["field"].([]*time.Location)
    66  	assert.True(t, ok)
    67  	if ok {
    68  		assert.Equal(t, time.UTC, arrLoc[0])
    69  	}
    70  
    71  	data = map[string]interface{}{}
    72  	assert.True(t, validateArray("field", []string{"127.0.0.1", "::1"}, []string{"ip"}, data))
    73  	arrIP, ok := data["field"].([]net.IP)
    74  	assert.True(t, ok)
    75  	if ok {
    76  		assert.Equal(t, "127.0.0.1", arrIP[0].String())
    77  	}
    78  
    79  	data = map[string]interface{}{}
    80  	assert.True(t, validateArray("field", []string{"5", "{\"test\":\"string\"}"}, []string{"json"}, data))
    81  	arrJSON, ok := data["field"].([]interface{})
    82  	assert.True(t, ok)
    83  	if ok {
    84  		assert.Equal(t, 5.0, arrJSON[0])
    85  		mp, okMap := arrJSON[1].(map[string]interface{})
    86  		assert.True(t, okMap)
    87  		assert.Equal(t, "string", mp["test"])
    88  	}
    89  
    90  	data = map[string]interface{}{}
    91  	assert.True(t, validateArray("field", []string{"http://google.com", "https://systemglitch.me"}, []string{"url"}, data))
    92  	arrURL, ok := data["field"].([]*url.URL)
    93  	assert.True(t, ok)
    94  	if ok {
    95  		assert.Equal(t, "http://google.com", arrURL[0].String())
    96  		assert.Equal(t, "https://systemglitch.me", arrURL[1].String())
    97  	}
    98  
    99  	data = map[string]interface{}{}
   100  	assert.True(t, validateArray("field", []string{"fdda765f-fc57-5604-a269-52a7df8164ec"}, []string{"uuid", "5"}, data))
   101  	arrUUID, ok := data["field"].([]uuid.UUID)
   102  	assert.True(t, ok)
   103  	if ok {
   104  		assert.Equal(t, "fdda765f-fc57-5604-a269-52a7df8164ec", arrUUID[0].String())
   105  	}
   106  
   107  	data = map[string]interface{}{}
   108  	assert.True(t, validateArray("field", []interface{}{"yes", true, false}, []string{"bool"}, data))
   109  	arrBool, ok := data["field"].([]bool)
   110  	assert.True(t, ok)
   111  	if ok {
   112  		assert.True(t, arrBool[0])
   113  		assert.True(t, arrBool[1])
   114  		assert.False(t, arrBool[2])
   115  	}
   116  
   117  	data = map[string]interface{}{}
   118  	assert.True(t, validateArray("field", []string{"2019-12-05"}, []string{"date"}, data))
   119  	arrDate, ok := data["field"].([]time.Time)
   120  	assert.True(t, ok)
   121  	if ok {
   122  		assert.Equal(t, "2019-12-05 00:00:00 +0000 UTC", arrDate[0].String())
   123  	}
   124  
   125  	data = map[string]interface{}{}
   126  	assert.True(t, validateArray("field", []string{"test"}, []string{"string"}, data))
   127  	arrStr, ok := data["field"].([]string)
   128  	assert.True(t, ok)
   129  	if ok {
   130  		assert.Equal(t, "test", arrStr[0])
   131  	}
   132  }
   133  
   134  func TestValidateDistinct(t *testing.T) {
   135  	assert.True(t, validateDistinct("field", []string{"test", "test2", "test3"}, []string{}, map[string]interface{}{}))
   136  	assert.True(t, validateDistinct("field", []int{1, 2, 3}, []string{}, map[string]interface{}{}))
   137  	assert.True(t, validateDistinct("field", []float64{1.2, 4.3, 2.4, 3.5, 4.5, 4.30001}, []string{}, map[string]interface{}{}))
   138  	assert.True(t, validateDistinct("field", []bool{true, false}, []string{}, map[string]interface{}{}))
   139  
   140  	assert.False(t, validateDistinct("field", []string{"test", "test2", "test3", "test2"}, []string{}, map[string]interface{}{}))
   141  	assert.False(t, validateDistinct("field", []int{1, 4, 2, 3, 4}, []string{}, map[string]interface{}{}))
   142  	assert.False(t, validateDistinct("field", []float64{1.2, 4.3, 2.4, 3.5, 4.5, 4.30001, 4.3}, []string{}, map[string]interface{}{}))
   143  
   144  	// Not array
   145  	assert.False(t, validateDistinct("field", 8, []string{}, map[string]interface{}{}))
   146  	assert.False(t, validateDistinct("field", 8.0, []string{}, map[string]interface{}{}))
   147  	assert.False(t, validateDistinct("field", "string", []string{}, map[string]interface{}{}))
   148  }
   149  
   150  func TestValidateIn(t *testing.T) {
   151  	assert.True(t, validateIn("field", "dolor", []string{"lorem", "ipsum", "sit", "dolor", "amet"}, map[string]interface{}{}))
   152  	assert.False(t, validateIn("field", "dolors", []string{"lorem", "ipsum", "sit", "dolor", "amet"}, map[string]interface{}{}))
   153  	assert.False(t, validateIn("field", "hello world", []string{"lorem", "ipsum", "sit", "dolor", "amet"}, map[string]interface{}{}))
   154  
   155  	assert.True(t, validateIn("field", 2.5, []string{"1", "2.4", "2.65", "87", "2.5"}, map[string]interface{}{}))
   156  	assert.False(t, validateIn("field", 2.51, []string{"1", "2.4", "2.65", "87", "2.5"}, map[string]interface{}{}))
   157  
   158  	assert.False(t, validateIn("field", []string{"1"}, []string{"1", "2.4", "2.65", "87", "2.5"}, map[string]interface{}{}))
   159  
   160  	assert.Panics(t, func() {
   161  		field := &Field{
   162  			Rules: []*Rule{
   163  				{Name: "in"},
   164  			},
   165  		}
   166  		field.check()
   167  	})
   168  }
   169  
   170  func TestValidateNotIn(t *testing.T) {
   171  	assert.False(t, validateNotIn("field", "dolor", []string{"lorem", "ipsum", "sit", "dolor", "amet"}, map[string]interface{}{}))
   172  	assert.True(t, validateNotIn("field", "dolors", []string{"lorem", "ipsum", "sit", "dolor", "amet"}, map[string]interface{}{}))
   173  	assert.True(t, validateNotIn("field", "hello world", []string{"lorem", "ipsum", "sit", "dolor", "amet"}, map[string]interface{}{}))
   174  
   175  	assert.False(t, validateNotIn("field", 2.5, []string{"1", "2.4", "2.65", "87", "2.5"}, map[string]interface{}{}))
   176  	assert.True(t, validateNotIn("field", 2.51, []string{"1", "2.4", "2.65", "87", "2.5"}, map[string]interface{}{}))
   177  
   178  	assert.False(t, validateNotIn("field", []string{"1"}, []string{"1", "2.4", "2.65", "87", "2.5"}, map[string]interface{}{}))
   179  
   180  	assert.Panics(t, func() {
   181  		field := &Field{
   182  			Rules: []*Rule{
   183  				{Name: "not_in"},
   184  			},
   185  		}
   186  		field.check()
   187  	})
   188  }
   189  
   190  func TestValidateInArray(t *testing.T) {
   191  	assert.True(t, validateInArray("field", "dolor", []string{"other"}, map[string]interface{}{"field": "dolors", "other": []string{"lorem", "ipsum", "sit", "dolor", "amet"}}))
   192  	assert.True(t, validateInArray("field", 4, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []int{1, 2, 3, 4, 5}}))
   193  	assert.True(t, validateInArray("field", 2.2, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []float64{1.1, 2.2, 3.3, 4.4, 5.5}}))
   194  	assert.True(t, validateInArray("field", false, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []bool{true, false}}))
   195  
   196  	assert.False(t, validateInArray("field", "dolors", []string{"other"}, map[string]interface{}{"field": "dolors", "other": []string{"lorem", "ipsum", "sit", "dolor", "amet"}}))
   197  	assert.False(t, validateInArray("field", 1, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []string{"lorem", "ipsum", "sit", "dolor", "amet"}}))
   198  	assert.False(t, validateInArray("field", 6, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []int{1, 2, 3, 4, 5}}))
   199  	assert.False(t, validateInArray("field", 2.3, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []float64{1.1, 2.2, 3.3, 4.4, 5.5}}))
   200  	assert.False(t, validateInArray("field", false, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []bool{true}}))
   201  	assert.False(t, validateInArray("field", []string{"test"}, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []bool{true}}))
   202  	assert.False(t, validateInArray("field", []string{"test"}, []string{"other"}, map[string]interface{}{"field": "dolors", "other": 1}))
   203  
   204  	assert.Panics(t, func() {
   205  		field := &Field{
   206  			Rules: []*Rule{
   207  				{Name: "in_array"},
   208  			},
   209  		}
   210  		field.check()
   211  	})
   212  }
   213  
   214  func TestValidateNotInArray(t *testing.T) {
   215  	assert.False(t, validateNotInArray("field", "dolor", []string{"other"}, map[string]interface{}{"field": "dolors", "other": []string{"lorem", "ipsum", "sit", "dolor", "amet"}}))
   216  	assert.False(t, validateNotInArray("field", 4, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []int{1, 2, 3, 4, 5}}))
   217  	assert.False(t, validateNotInArray("field", 2.2, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []float64{1.1, 2.2, 3.3, 4.4, 5.5}}))
   218  	assert.False(t, validateNotInArray("field", false, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []bool{true, false}}))
   219  	assert.False(t, validateNotInArray("field", []string{"test"}, []string{"other"}, map[string]interface{}{"field": "dolors", "other": 1}))
   220  
   221  	assert.True(t, validateNotInArray("field", "dolors", []string{"other"}, map[string]interface{}{"field": "dolors", "other": []string{"lorem", "ipsum", "sit", "dolor", "amet"}}))
   222  	assert.True(t, validateNotInArray("field", 1, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []string{"lorem", "ipsum", "sit", "dolor", "amet"}}))
   223  	assert.True(t, validateNotInArray("field", 6, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []int{1, 2, 3, 4, 5}}))
   224  	assert.True(t, validateNotInArray("field", 2.3, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []float64{1.1, 2.2, 3.3, 4.4, 5.5}}))
   225  	assert.True(t, validateNotInArray("field", false, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []bool{true}}))
   226  	assert.True(t, validateNotInArray("field", []string{"test"}, []string{"other"}, map[string]interface{}{"field": "dolors", "other": []bool{true}}))
   227  
   228  	assert.Panics(t, func() {
   229  		field := &Field{
   230  			Rules: []*Rule{
   231  				{Name: "not_in_array"},
   232  			},
   233  		}
   234  		field.check()
   235  	})
   236  }