Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(162)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: third_party/pkg/angular/test/directive/ng_model_validators_spec.dart

Issue 256553002: Revert "Update all Angular libs (run update_all.sh)." (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 6 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « third_party/pkg/angular/test/directive/ng_model_spec.dart ('k') | third_party/pkg/angular/test/directive/ng_non_bindable_spec.dart » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 library ng_model_validators; 1 library ng_model_validators;
2 2
3 import '../_specs.dart'; 3 import '../_specs.dart';
4 4
5 void main() { 5 main() =>
6 they(should, tokens, callback, [exclusive=false]) { 6 describe('ngModel validators', () {
7 tokens.forEach((token) { 7 TestBed _;
8 describe(token, () { 8
9 (exclusive ? iit : it)(should, () => callback(token)); 9 beforeEach(inject((TestBed tb) => _ = tb));
10 }); 10
11 }); 11 describe('required', () {
12 } 12 it('should validate the input field if the required attribute is set', injec t((RootScope scope) {
13 13 _.compile('<input type="text" ng-model="val" probe="i" required />');
14 tthey(should, tokens, callback) => 14 Probe probe = _.rootScope.context['i'];
15 they(should, tokens, callback, true); 15 var model = probe.directive(NgModel);
16 16
17 describe('ngModel validators', () { 17 model.validate();
18 TestBed _; 18 expect(model.valid).toEqual(false);
19 19 expect(model.invalid).toEqual(true);
20 beforeEach((TestBed tb) => _ = tb); 20
21 21 _.rootScope.context['val'] = 'value';
22 describe('required', () { 22 model.validate();
23 it('should validate the input field if the required attribute is set', (Ro otScope scope) { 23
24 _.compile('<input type="text" ng-model="val" probe="i" required />'); 24 expect(model.valid).toEqual(true);
25 Probe probe = _.rootScope.context['i']; 25 expect(model.invalid).toEqual(false);
26 var model = probe.directive(NgModel); 26 }));
27 27
28 model.validate(); 28
29 expect(model.valid).toEqual(false); 29 it('should validate a number input field if the required attribute is set', inject((RootScope scope) {
30 expect(model.invalid).toEqual(true); 30 _.compile('<input type="number" ng-model="val" probe="i" required="true" / >');
31 31 Probe probe = _.rootScope.context['i'];
32 _.rootScope.apply(() { 32 var model = probe.directive(NgModel);
33 _.rootScope.context['val'] = 'value'; 33
34 }); 34 model.validate();
35 35 expect(model.valid).toEqual(false);
36 expect(model.valid).toEqual(true); 36 expect(model.invalid).toEqual(true);
37 expect(model.invalid).toEqual(false); 37
38 }); 38 _.rootScope.context['val'] = 5;
39 39 model.validate();
40 40
41 it('should validate a number input field if the required attribute is set' , (RootScope scope) { 41 expect(model.valid).toEqual(true);
42 _.compile('<input type="number" ng-model="val" probe="i" required="true" />'); 42 expect(model.invalid).toEqual(false);
43 Probe probe = _.rootScope.context['i']; 43 }));
44 var model = probe.directive(NgModel); 44
45 45
46 _.rootScope.apply(); 46 it('should validate the input field depending on if ng-required is true', in ject((RootScope scope) {
47 47 _.compile('<input type="text" ng-model="val" probe="i" ng-required="requir eMe" />');
48 expect(model.valid).toEqual(false); 48 Probe probe = _.rootScope.context['i'];
49 expect(model.invalid).toEqual(true); 49 var model = probe.directive(NgModel);
50 50
51 _.rootScope.apply(() { 51 _.rootScope.apply();
52 _.rootScope.context['val'] = 5; 52
53 }); 53 model.validate();
54 54 expect(model.valid).toEqual(true);
55 expect(model.valid).toEqual(true); 55 expect(model.invalid).toEqual(false);
56 expect(model.invalid).toEqual(false); 56
57 }); 57 _.rootScope.apply(() {
58 58 _.rootScope.context['requireMe'] = true;
59 59 });
60 it('should validate the input field depending on if ng-required is true', (RootScope scope) { 60
61 _.compile('<input type="text" ng-model="val" probe="i" ng-required="requ ireMe" />'); 61 model.validate();
62 Probe probe = _.rootScope.context['i']; 62 expect(model.valid).toEqual(false);
63 var model = probe.directive(NgModel); 63 expect(model.invalid).toEqual(true);
64 64
65 _.rootScope.apply(); 65 _.rootScope.apply(() {
66 66 _.rootScope.context['requireMe'] = false;
67 model.validate(); 67 });
68 expect(model.valid).toEqual(true); 68
69 expect(model.invalid).toEqual(false); 69 model.validate();
70 70 expect(model.valid).toEqual(true);
71 _.rootScope.apply(() { 71 expect(model.invalid).toEqual(false);
72 _.rootScope.context['requireMe'] = true; 72 }));
73 }); 73 });
74 74
75 model.validate(); 75 describe('[type="url"]', () {
76 expect(model.valid).toEqual(false); 76 it('should validate the input field given a valid or invalid URL', inject((R ootScope scope) {
77 expect(model.invalid).toEqual(true); 77 _.compile('<input type="url" ng-model="val" probe="i" />');
78 78 Probe probe = _.rootScope.context['i'];
79 _.rootScope.apply(() { 79 var model = probe.directive(NgModel);
80 _.rootScope.context['requireMe'] = false; 80
81 }); 81 model.validate();
82 82 expect(model.valid).toEqual(true);
83 model.validate(); 83 expect(model.invalid).toEqual(false);
84 expect(model.valid).toEqual(true); 84
85 expect(model.invalid).toEqual(false); 85 _.rootScope.apply(() {
86 }); 86 _.rootScope.context['val'] = 'googledotcom';
87 }); 87 });
88 88
89 describe('[type="url"]', () { 89 model.validate();
90 it('should validate the input field given a valid or invalid URL', (RootSc ope scope) { 90 expect(model.valid).toEqual(false);
91 _.compile('<input type="url" ng-model="val" probe="i" />'); 91 expect(model.invalid).toEqual(true);
92 Probe probe = _.rootScope.context['i']; 92
93 var model = probe.directive(NgModel); 93 _.rootScope.apply(() {
94 94 _.rootScope.context['val'] = 'http://www.google.com';
95 expect(model.valid).toEqual(true); 95 });
96 expect(model.invalid).toEqual(false); 96
97 97 model.validate();
98 _.rootScope.apply(() { 98 expect(model.valid).toEqual(true);
99 _.rootScope.context['val'] = 'googledotcom'; 99 expect(model.invalid).toEqual(false);
100 }); 100 }));
101 101 });
102 expect(model.valid).toEqual(false); 102
103 expect(model.invalid).toEqual(true); 103 describe('[type="email"]', () {
104 104 it('should validate the input field given a valid or invalid email address', inject((RootScope scope) {
105 _.rootScope.apply(() { 105 _.compile('<input type="email" ng-model="val" probe="i" />');
106 _.rootScope.context['val'] = 'http://www.google.com'; 106 Probe probe = _.rootScope.context['i'];
107 }); 107 var model = probe.directive(NgModel);
108 108
109 expect(model.valid).toEqual(true); 109 model.validate();
110 expect(model.invalid).toEqual(false); 110 expect(model.valid).toEqual(true);
111 }); 111 expect(model.invalid).toEqual(false);
112 }); 112
113 113 _.rootScope.apply(() {
114 describe('[type="email"]', () { 114 _.rootScope.context['val'] = 'matiasatemail.com';
115 it('should validate the input field given a valid or invalid email address ', (RootScope scope) { 115 });
116 _.compile('<input type="email" ng-model="val" probe="i" />'); 116
117 Probe probe = _.rootScope.context['i']; 117 model.validate();
118 var model = probe.directive(NgModel); 118 expect(model.valid).toEqual(false);
119 119 expect(model.invalid).toEqual(true);
120 model.validate(); 120
121 expect(model.valid).toEqual(true); 121 _.rootScope.apply(() {
122 expect(model.invalid).toEqual(false); 122 _.rootScope.context['val'] = 'matias@gmail.com';
123 123 });
124 _.rootScope.apply(() { 124
125 _.rootScope.context['val'] = 'matiasatemail.com'; 125 model.validate();
126 }); 126 expect(model.valid).toEqual(true);
127 127 expect(model.invalid).toEqual(false);
128 model.validate(); 128 }));
129 expect(model.valid).toEqual(false); 129 });
130 expect(model.invalid).toEqual(true); 130
131 131 describe('[type="number"]', () {
132 _.rootScope.apply(() { 132 it('should validate the input field given a valid or invalid number', inject ((RootScope scope) {
133 _.rootScope.context['val'] = 'matias@gmail.com'; 133 _.compile('<input type="number" ng-model="val" probe="i" />');
134 }); 134 Probe probe = _.rootScope.context['i'];
135 135 var model = probe.directive(NgModel);
136 model.validate(); 136
137 expect(model.valid).toEqual(true); 137 model.validate();
138 expect(model.invalid).toEqual(false); 138 expect(model.valid).toEqual(true);
139 }); 139 expect(model.invalid).toEqual(false);
140 }); 140
141 141 _.rootScope.apply(() {
142 describe('[type="number|range"]', () { 142 _.rootScope.context['val'] = '11';
143 they('should validate the input field given a valid or invalid number', 143 });
144 ['range', 'number'], 144
145 (type) { 145 model.validate();
146 146 expect(model.valid).toEqual(true);
147 _.compile('<input type="$type" ng-model="val" probe="i" />'); 147 expect(model.invalid).toEqual(false);
148 Probe probe = _.rootScope.context['i']; 148
149 var model = probe.directive(NgModel); 149
150 150 _.rootScope.apply(() {
151 model.validate(); 151 _.rootScope.context['val'] = 10;
152 expect(model.valid).toEqual(true); 152 });
153 expect(model.invalid).toEqual(false); 153
154 154 model.validate();
155 _.rootScope.apply(() { 155 expect(model.valid).toEqual(true);
156 _.rootScope.context['val'] = '11'; 156 expect(model.invalid).toEqual(false);
157 }); 157
158 158 _.rootScope.apply(() {
159 model.validate(); 159 _.rootScope.context['val'] = 'twelve';
160 expect(model.valid).toEqual(true); 160 });
161 expect(model.invalid).toEqual(false); 161
162 162 model.validate();
163 163 expect(model.valid).toEqual(false);
164 _.rootScope.apply(() { 164 expect(model.invalid).toEqual(true);
165 _.rootScope.context['val'] = 10; 165 }));
166 }); 166 });
167 167
168 model.validate(); 168 describe('pattern', () {
169 expect(model.valid).toEqual(true); 169 it('should validate the input field if a ng-pattern attribute is provided', inject((RootScope scope) {
170 expect(model.invalid).toEqual(false); 170 _.compile('<input type="text" ng-pattern="myPattern" ng-model="val" probe= "i" />');
171 171 Probe probe = _.rootScope.context['i'];
172 _.rootScope.apply(() { 172 var model = probe.directive(NgModel);
173 _.rootScope.context['val'] = 'twelve'; 173
174 }); 174 model.validate();
175 175 expect(model.valid).toEqual(true);
176 model.validate(); 176 expect(model.invalid).toEqual(false);
177 expect(model.valid).toEqual(false); 177
178 expect(model.invalid).toEqual(true); 178 _.rootScope.apply(() {
179 }); 179 _.rootScope.context['val'] = "abc";
180 180 _.rootScope.context['myPattern'] = "[a-z]+";
181 they('should perform a max number validation if a max attribute value is p resent', 181 });
182 ['range', 'number'], 182
183 (type) { 183 model.validate();
184 184 expect(model.valid).toEqual(true);
185 _.compile('<input type="$type" ng-model="val" max="10" probe="i" />'); 185 expect(model.invalid).toEqual(false);
186 Probe probe = _.rootScope.context['i']; 186
187 var model = probe.directive(NgModel); 187 _.rootScope.apply(() {
188 188 _.rootScope.context['val'] = "abc";
189 _.rootScope.apply(() { 189 _.rootScope.context['myPattern'] = "[0-9]+";
190 _.rootScope.context['val'] = "8"; 190 });
191 }); 191
192 192 model.validate();
193 model.validate(); 193 expect(model.valid).toEqual(false);
194 expect(model.valid).toEqual(true); 194 expect(model.invalid).toEqual(true);
195 expect(model.invalid).toEqual(false); 195
196 expect(model.hasErrorState('ng-max')).toBe(false); 196 _.rootScope.apply(() {
197 197 _.rootScope.context['val'] = "123";
198 _.rootScope.apply(() { 198 _.rootScope.context['myPattern'] = "123";
199 _.rootScope.context['val'] = "99"; 199 });
200 }); 200
201 201 model.validate();
202 model.validate(); 202 expect(model.valid).toEqual(true);
203 expect(model.valid).toEqual(false); 203 expect(model.invalid).toEqual(false);
204 expect(model.invalid).toEqual(true); 204 }));
205 expect(model.hasErrorState('ng-max')).toBe(true); 205
206 206 it('should validate the input field if a pattern attribute is provided', inj ect((RootScope scope) {
207 _.rootScope.apply(() { 207 _.compile('<input type="text" pattern="[0-5]+" ng-model="val" probe="i" /> ');
208 _.rootScope.context['val'] = "a"; 208 Probe probe = _.rootScope.context['i'];
209 }); 209 var model = probe.directive(NgModel);
210 210
211 model.validate(); 211 model.validate();
212 expect(model.valid).toEqual(false); 212 expect(model.valid).toEqual(true);
213 expect(model.invalid).toEqual(true); 213 expect(model.invalid).toEqual(false);
214 expect(model.hasErrorState('ng-max')).toBe(false); 214
215 expect(model.hasErrorState('ng-number')).toBe(true); 215 _.rootScope.apply(() {
216 }); 216 _.rootScope.context['val'] = "abc";
217 217 });
218 they('should perform a max number validation if a ng-max attribute value i s present and/or changed', 218
219 ['range', 'number'], 219 model.validate();
220 (type) { 220 expect(model.valid).toEqual(false);
221 221 expect(model.invalid).toEqual(true);
222 _.compile('<input type="$type" ng-model="val" ng-max="maxVal" probe="i" />'); 222
223 Probe probe = _.rootScope.context['i']; 223 _.rootScope.apply(() {
224 var model = probe.directive(NgModel); 224 _.rootScope.context['val'] = "012345";
225 225 });
226 //should be valid even when no number is present 226
227 model.validate(); 227 model.validate();
228 expect(model.valid).toEqual(true); 228 expect(model.valid).toEqual(true);
229 expect(model.invalid).toEqual(false); 229 expect(model.invalid).toEqual(false);
230 expect(model.hasErrorState('ng-max')).toBe(false); 230
231 231 _.rootScope.apply(() {
232 _.rootScope.apply(() { 232 _.rootScope.context['val'] = "6789";
233 _.rootScope.context['val'] = "20"; 233 });
234 }); 234
235 235 model.validate();
236 model.validate(); 236 expect(model.valid).toEqual(false);
237 expect(model.valid).toEqual(true); 237 expect(model.invalid).toEqual(true);
238 expect(model.invalid).toEqual(false); 238 }));
239 expect(model.hasErrorState('ng-max')).toBe(false); 239 });
240 240
241 _.rootScope.apply(() { 241 describe('minlength', () {
242 _.rootScope.context['maxVal'] = "19"; 242 it('should validate the input field if a minlength attribute is provided', i nject((RootScope scope) {
243 }); 243 _.compile('<input type="text" minlength="5" ng-model="val" probe="i" />');
244 244 Probe probe = _.rootScope.context['i'];
245 model.validate(); 245 var model = probe.directive(NgModel);
246 expect(model.valid).toEqual(false); 246
247 expect(model.invalid).toEqual(true); 247 model.validate();
248 expect(model.hasErrorState('ng-max')).toBe(true); 248 expect(model.valid).toEqual(true);
249 249 expect(model.invalid).toEqual(false);
250 _.rootScope.apply(() { 250
251 _.rootScope.context['maxVal'] = "22"; 251 _.rootScope.apply(() {
252 }); 252 _.rootScope.context['val'] = "abc";
253 253 });
254 model.validate(); 254
255 expect(model.valid).toEqual(true); 255 model.validate();
256 expect(model.invalid).toEqual(false); 256 expect(model.valid).toEqual(false);
257 expect(model.hasErrorState('ng-max')).toBe(false); 257 expect(model.invalid).toEqual(true);
258 }); 258
259 259 _.rootScope.apply(() {
260 they('should perform a min number validation if a min attribute value is p resent', 260 _.rootScope.context['val'] = "abcdef";
261 ['range', 'number'], 261 });
262 (type) { 262
263 263 model.validate();
264 _.compile('<input type="$type" ng-model="val" min="-10" probe="i" />'); 264 expect(model.valid).toEqual(true);
265 Probe probe = _.rootScope.context['i']; 265 expect(model.invalid).toEqual(false);
266 var model = probe.directive(NgModel); 266 }));
267 267
268 _.rootScope.apply(() { 268 it('should validate the input field if a ng-minlength attribute is provided' , inject((RootScope scope) {
269 _.rootScope.context['val'] = "8"; 269 _.compile('<input type="text" ng-minlength="len" ng-model="val" probe="i" />');
270 }); 270 Probe probe = _.rootScope.context['i'];
271 271 var model = probe.directive(NgModel);
272 model.validate(); 272
273 expect(model.valid).toEqual(true); 273 model.validate();
274 expect(model.invalid).toEqual(false); 274 expect(model.valid).toEqual(true);
275 expect(model.hasErrorState('ng-min')).toBe(false); 275 expect(model.invalid).toEqual(false);
276 276
277 _.rootScope.apply(() { 277 _.rootScope.apply(() {
278 _.rootScope.context['val'] = "-20"; 278 _.rootScope.context['val'] = "abcdef";
279 }); 279 _.rootScope.context['len'] = 3;
280 280 });
281 model.validate(); 281
282 expect(model.valid).toEqual(false); 282 model.validate();
283 expect(model.invalid).toEqual(true); 283 expect(model.valid).toEqual(true);
284 expect(model.hasErrorState('ng-min')).toBe(true); 284 expect(model.invalid).toEqual(false);
285 285
286 _.rootScope.apply(() { 286 _.rootScope.apply(() {
287 _.rootScope.context['val'] = "x"; 287 _.rootScope.context['val'] = "abc";
288 }); 288 _.rootScope.context['len'] = 5;
289 289 });
290 model.validate(); 290
291 expect(model.valid).toEqual(false); 291 model.validate();
292 expect(model.invalid).toEqual(true); 292 expect(model.valid).toEqual(false);
293 expect(model.hasErrorState('ng-min')).toBe(false); 293 expect(model.invalid).toEqual(true);
294 expect(model.hasErrorState('ng-number')).toBe(true); 294 }));
295 }); 295 });
296 296
297 they('should perform a min number validation if a ng-min attribute value i s present and/or changed', 297 describe('maxlength', () {
298 ['range', 'number'], 298 it('should validate the input field if a maxlength attribute is provided', i nject((RootScope scope) {
299 (type) { 299 _.compile('<input type="text" maxlength="5" ng-model="val" probe="i" />');
300 300 Probe probe = _.rootScope.context['i'];
301 _.compile('<input type="$type" ng-model="val" ng-min="minVal" probe="i" />'); 301 var model = probe.directive(NgModel);
302 Probe probe = _.rootScope.context['i']; 302
303 var model = probe.directive(NgModel); 303 model.validate();
304 304 expect(model.valid).toEqual(true);
305 //should be valid even when no number is present 305 expect(model.invalid).toEqual(false);
306 model.validate(); 306
307 expect(model.valid).toEqual(true); 307 _.rootScope.apply(() {
308 expect(model.invalid).toEqual(false); 308 _.rootScope.context['val'] = "abcdef";
309 expect(model.hasErrorState('ng-min')).toBe(false); 309 });
310 310
311 _.rootScope.apply(() { 311 model.validate();
312 _.rootScope.context['val'] = "5"; 312 expect(model.valid).toEqual(false);
313 }); 313 expect(model.invalid).toEqual(true);
314 314
315 model.validate(); 315 _.rootScope.apply(() {
316 expect(model.valid).toEqual(true); 316 _.rootScope.context['val'] = "abc";
317 expect(model.invalid).toEqual(false); 317 });
318 expect(model.hasErrorState('ng-min')).toBe(false); 318
319 319 model.validate();
320 _.rootScope.apply(() { 320 expect(model.valid).toEqual(true);
321 _.rootScope.context['minVal'] = "5.5"; 321 expect(model.invalid).toEqual(false);
322 }); 322 }));
323 323
324 model.validate(); 324 it('should validate the input field if a ng-maxlength attribute is provided' , inject((RootScope scope) {
325 expect(model.valid).toEqual(false); 325 _.compile('<input type="text" ng-maxlength="len" ng-model="val" probe="i" />');
326 expect(model.invalid).toEqual(true); 326 Probe probe = _.rootScope.context['i'];
327 expect(model.hasErrorState('ng-min')).toBe(true); 327 var model = probe.directive(NgModel);
328 328
329 _.rootScope.apply(() { 329 model.validate();
330 _.rootScope.context['val'] = "5.6"; 330 expect(model.valid).toEqual(true);
331 }); 331 expect(model.invalid).toEqual(false);
332 332
333 model.validate(); 333 _.rootScope.apply(() {
334 expect(model.valid).toEqual(true); 334 _.rootScope.context['val'] = "abcdef";
335 expect(model.invalid).toEqual(false); 335 _.rootScope.context['len'] = 6;
336 expect(model.hasErrorState('ng-min')).toBe(false); 336 });
337 }); 337
338 }); 338 model.validate();
339 339 expect(model.valid).toEqual(true);
340 describe('pattern', () { 340 expect(model.invalid).toEqual(false);
341 it('should validate the input field if a ng-pattern attribute is provided' , (RootScope scope) { 341
342 _.compile('<input type="text" ng-pattern="myPattern" ng-model="val" prob e="i" />'); 342 _.rootScope.apply(() {
343 Probe probe = _.rootScope.context['i']; 343 _.rootScope.context['val'] = "abc";
344 var model = probe.directive(NgModel); 344 _.rootScope.context['len'] = 1;
345 345 });
346 model.validate(); 346
347 expect(model.valid).toEqual(true); 347 model.validate();
348 expect(model.invalid).toEqual(false); 348 expect(model.valid).toEqual(false);
349 349 expect(model.invalid).toEqual(true);
350 _.rootScope.apply(() { 350 }));
351 _.rootScope.context['val'] = "abc"; 351 });
352 _.rootScope.context['myPattern'] = "[a-z]+"; 352 });
353 });
354
355 model.validate();
356 expect(model.valid).toEqual(true);
357 expect(model.invalid).toEqual(false);
358
359 _.rootScope.apply(() {
360 _.rootScope.context['val'] = "abc";
361 _.rootScope.context['myPattern'] = "[0-9]+";
362 });
363
364 model.validate();
365 expect(model.valid).toEqual(false);
366 expect(model.invalid).toEqual(true);
367
368 _.rootScope.apply(() {
369 _.rootScope.context['val'] = "123";
370 _.rootScope.context['myPattern'] = "123";
371 });
372
373 model.validate();
374 expect(model.valid).toEqual(true);
375 expect(model.invalid).toEqual(false);
376 });
377
378 it('should validate the input field if a pattern attribute is provided', ( RootScope scope) {
379 _.compile('<input type="text" pattern="[0-5]+" ng-model="val" probe="i" />');
380 Probe probe = _.rootScope.context['i'];
381 var model = probe.directive(NgModel);
382
383 model.validate();
384 expect(model.valid).toEqual(true);
385 expect(model.invalid).toEqual(false);
386
387 _.rootScope.apply(() {
388 _.rootScope.context['val'] = "abc";
389 });
390
391 model.validate();
392 expect(model.valid).toEqual(false);
393 expect(model.invalid).toEqual(true);
394
395 _.rootScope.apply(() {
396 _.rootScope.context['val'] = "012345";
397 });
398
399 model.validate();
400 expect(model.valid).toEqual(true);
401 expect(model.invalid).toEqual(false);
402
403 _.rootScope.apply(() {
404 _.rootScope.context['val'] = "6789";
405 });
406
407 model.validate();
408 expect(model.valid).toEqual(false);
409 expect(model.invalid).toEqual(true);
410 });
411 });
412
413 describe('minlength', () {
414 it('should validate the input field if a minlength attribute is provided', (RootScope scope) {
415 _.compile('<input type="text" minlength="5" ng-model="val" probe="i" />' );
416 Probe probe = _.rootScope.context['i'];
417 var model = probe.directive(NgModel);
418
419 model.validate();
420 expect(model.valid).toEqual(true);
421 expect(model.invalid).toEqual(false);
422
423 _.rootScope.apply(() {
424 _.rootScope.context['val'] = "abc";
425 });
426
427 model.validate();
428 expect(model.valid).toEqual(false);
429 expect(model.invalid).toEqual(true);
430
431 _.rootScope.apply(() {
432 _.rootScope.context['val'] = "abcdef";
433 });
434
435 model.validate();
436 expect(model.valid).toEqual(true);
437 expect(model.invalid).toEqual(false);
438 });
439
440 it('should validate the input field if a ng-minlength attribute is provide d', (RootScope scope) {
441 _.compile('<input type="text" ng-minlength="len" ng-model="val" probe="i " />');
442 Probe probe = _.rootScope.context['i'];
443 var model = probe.directive(NgModel);
444
445 model.validate();
446 expect(model.valid).toEqual(true);
447 expect(model.invalid).toEqual(false);
448
449 _.rootScope.apply(() {
450 _.rootScope.context['val'] = "abcdef";
451 _.rootScope.context['len'] = 3;
452 });
453
454 model.validate();
455 expect(model.valid).toEqual(true);
456 expect(model.invalid).toEqual(false);
457
458 _.rootScope.apply(() {
459 _.rootScope.context['val'] = "abc";
460 _.rootScope.context['len'] = 5;
461 });
462
463 model.validate();
464 expect(model.valid).toEqual(false);
465 expect(model.invalid).toEqual(true);
466 });
467 });
468
469 describe('maxlength', () {
470 it('should validate the input field if a maxlength attribute is provided', (RootScope scope) {
471 _.compile('<input type="text" maxlength="5" ng-model="val" probe="i" />' );
472 Probe probe = _.rootScope.context['i'];
473 var model = probe.directive(NgModel);
474
475 model.validate();
476 expect(model.valid).toEqual(true);
477 expect(model.invalid).toEqual(false);
478
479 _.rootScope.apply(() {
480 _.rootScope.context['val'] = "abcdef";
481 });
482
483 model.validate();
484 expect(model.valid).toEqual(false);
485 expect(model.invalid).toEqual(true);
486
487 _.rootScope.apply(() {
488 _.rootScope.context['val'] = "abc";
489 });
490
491 model.validate();
492 expect(model.valid).toEqual(true);
493 expect(model.invalid).toEqual(false);
494 });
495
496 it('should validate the input field if a ng-maxlength attribute is provide d', (RootScope scope) {
497 _.compile('<input type="text" ng-maxlength="len" ng-model="val" probe="i " />');
498 Probe probe = _.rootScope.context['i'];
499 var model = probe.directive(NgModel);
500
501 model.validate();
502 expect(model.valid).toEqual(true);
503 expect(model.invalid).toEqual(false);
504
505 _.rootScope.apply(() {
506 _.rootScope.context['val'] = "abcdef";
507 _.rootScope.context['len'] = 6;
508 });
509
510 model.validate();
511 expect(model.valid).toEqual(true);
512 expect(model.invalid).toEqual(false);
513
514 _.rootScope.apply(() {
515 _.rootScope.context['val'] = "abc";
516 _.rootScope.context['len'] = 1;
517 });
518
519 model.validate();
520 expect(model.valid).toEqual(false);
521 expect(model.invalid).toEqual(true);
522 });
523 });
524
525 describe('when toggled it should properly validate', () {
526 var build, input, scope, model;
527 beforeEach(() {
528 scope = _.rootScope;
529 build = (attr, type) {
530 input = _.compile('<input type="$type" probe="p" ng-model="value" $att r="attr" />');
531 model = scope.context['p'].directive(NgModel);
532 };
533 });
534
535 it('ng-required', () {
536 var input = build('ng-required', 'text');
537 scope.apply(() {
538 scope.context['attr'] = true;
539 scope.context['value'] = '';
540 });
541
542 expect(model.valid).toBe(false);
543
544 scope.apply(() {
545 scope.context['attr'] = false;
546 });
547
548 expect(model.valid).toBe(true);
549 });
550
551 it('ng-pattern', () {
552 var input = build('ng-pattern', 'text');
553 scope.apply(() {
554 scope.context['attr'] = '^\d+\$';
555 scope.context['value'] = 'abc';
556 });
557
558 expect(model.valid).toBe(false);
559
560 scope.apply(() {
561 scope.context['attr'] = null;
562 });
563
564 expect(model.valid).toBe(true);
565 });
566
567 it('ng-minlength', () {
568 var input = build('ng-minlength', 'text');
569 scope.apply(() {
570 scope.context['attr'] = '10';
571 scope.context['value'] = 'abc';
572 });
573
574 expect(model.valid).toBe(false);
575
576 scope.apply(() {
577 scope.context['attr'] = null;
578 });
579
580 expect(model.valid).toBe(true);
581 });
582
583 it('ng-minlength', () {
584 var input = build('ng-maxlength', 'text');
585 scope.apply(() {
586 scope.context['attr'] = '3';
587 scope.context['value'] = 'abcd';
588 });
589
590 expect(model.valid).toBe(false);
591
592 scope.apply(() {
593 scope.context['attr'] = null;
594 });
595
596 expect(model.valid).toBe(true);
597 });
598
599 it('ng-min', () {
600 var input = build('ng-min', 'number');
601 scope.apply(() {
602 scope.context['attr'] = '5.0';
603 scope.context['value'] = 3;
604 });
605
606 expect(model.valid).toBe(false);
607
608 scope.apply(() {
609 scope.context['attr'] = null;
610 });
611
612 expect(model.valid).toBe(true);
613 });
614
615 it('ng-max', () {
616 var input = build('ng-max', 'number');
617 scope.apply(() {
618 scope.context['attr'] = '5.0';
619 scope.context['value'] = 8;
620 });
621
622 expect(model.valid).toBe(false);
623
624 scope.apply(() {
625 scope.context['attr'] = null;
626 });
627
628 expect(model.valid).toBe(true);
629 });
630 });
631 });
632 }
OLDNEW
« no previous file with comments | « third_party/pkg/angular/test/directive/ng_model_spec.dart ('k') | third_party/pkg/angular/test/directive/ng_non_bindable_spec.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698