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 }