| OLD | NEW |
|---|
| (Empty) |
| 1 library input_select_spec; | |
| 2 | |
| 3 import '../_specs.dart'; | |
| 4 | |
| 5 //TODO(misko): re-enabled disabled tests once we have forms. | |
| 6 | |
| 7 main() { | |
| 8 describe('input-select', () { | |
| 9 | |
| 10 describe('ng-value', () { | |
| 11 TestBed _; | |
| 12 beforeEach((TestBed tb) => _ = tb); | |
| 13 | |
| 14 it('should retrieve using ng-value', () { | |
| 15 _.compile( | |
| 16 '<select ng-model="robot" probe="p">' | |
| 17 '<option ng-repeat="r in robots" ng-value="r">{{r.name}}</option>' | |
| 18 '</select>'); | |
| 19 var r2d2 = {"name":"r2d2"}; | |
| 20 var c3p0 = {"name":"c3p0"}; | |
| 21 _.rootScope.context['robots'] = [ r2d2, c3p0 ]; | |
| 22 _.rootScope.apply(); | |
| 23 _.selectOption(_.rootElement, 'c3p0'); | |
| 24 expect(_.rootScope.context['robot']).toEqual(c3p0); | |
| 25 | |
| 26 _.rootScope.context['robot'] = r2d2; | |
| 27 _.rootScope.apply(); | |
| 28 expect(_.rootScope.context['robot']).toEqual(r2d2); | |
| 29 expect(_.rootElement).toEqualSelect([['r2d2'], 'c3p0']); | |
| 30 }); | |
| 31 | |
| 32 it('should retrieve using ng-value', () { | |
| 33 _.compile( | |
| 34 '<select ng-model="robot" probe="p" multiple>' | |
| 35 '<option ng-repeat="r in robots" ng-value="r">{{r.name}}</option>' | |
| 36 '</select>'); | |
| 37 var r2d2 = { "name":"r2d2"}; | |
| 38 var c3p0 = {"name":"c3p0"}; | |
| 39 _.rootScope.context['robots'] = [ r2d2, c3p0 ]; | |
| 40 _.rootScope.apply(); | |
| 41 _.selectOption(_.rootElement, 'c3p0'); | |
| 42 expect(_.rootScope.context['robot']).toEqual([c3p0]); | |
| 43 | |
| 44 _.rootScope.context['robot'] = [r2d2]; | |
| 45 _.rootScope.apply(); | |
| 46 expect(_.rootScope.context['robot']).toEqual([r2d2]); | |
| 47 expect(_.rootElement).toEqualSelect([['r2d2'], 'c3p0']); | |
| 48 }); | |
| 49 }); | |
| 50 | |
| 51 TestBed _; | |
| 52 | |
| 53 beforeEach((TestBed tb) => _ = tb); | |
| 54 | |
| 55 describe('select-one', () { | |
| 56 it('should compile children of a select without a ngModel, but not create
a model for it', | |
| 57 () { | |
| 58 _.compile( | |
| 59 '<select>' | |
| 60 '<option selected="true">{{a}}</option>' | |
| 61 '<option value="">{{b}}</option>' | |
| 62 '<option>C</option>' | |
| 63 '</select>'); | |
| 64 _.rootScope.apply(() { | |
| 65 _.rootScope.context['a'] = 'foo'; | |
| 66 _.rootScope.context['b'] = 'bar'; | |
| 67 }); | |
| 68 | |
| 69 expect(_.rootElement.text).toEqual('foobarC'); | |
| 70 }); | |
| 71 | |
| 72 it('should not interfere with selection via selected attr if ngModel direc
tive is not present', | |
| 73 () { | |
| 74 _.compile( | |
| 75 '<select>' | |
| 76 '<option>not me</option>' | |
| 77 '<option selected>me!</option>' | |
| 78 '<option>nah</option>' | |
| 79 '</select>'); | |
| 80 _.rootScope.apply(); | |
| 81 | |
| 82 expect(_.rootElement).toEqualSelect(['not me', ['me!'], 'nah']); | |
| 83 }); | |
| 84 | |
| 85 it('should work with repeated value options', () { | |
| 86 _.compile( | |
| 87 '<select ng-model="robot" probe="p">' | |
| 88 '<option ng-repeat="r in robots">{{r}}</option>' | |
| 89 '</select>'); | |
| 90 | |
| 91 _.rootScope.context['robots'] = ['c3p0', 'r2d2']; | |
| 92 _.rootScope.context['robot'] = 'r2d2'; | |
| 93 _.rootScope.apply(); | |
| 94 | |
| 95 var select = _.rootScope.context['p'].directive(InputSelect); | |
| 96 expect(_.rootElement).toEqualSelect(['c3p0', ['r2d2']]); | |
| 97 | |
| 98 _.rootElement.querySelectorAll('option')[0].selected = true; | |
| 99 _.triggerEvent(_.rootElement, 'change'); | |
| 100 | |
| 101 | |
| 102 expect(_.rootElement).toEqualSelect([['c3p0'], 'r2d2']); | |
| 103 expect(_.rootScope.context['robot']).toEqual('c3p0'); | |
| 104 | |
| 105 _.rootScope.apply(() { | |
| 106 _.rootScope.context['robots'].insert(0, 'wallee'); | |
| 107 }); | |
| 108 expect(_.rootElement).toEqualSelect(['wallee', ['c3p0'], 'r2d2']); | |
| 109 expect(_.rootScope.context['robot']).toEqual('c3p0'); | |
| 110 | |
| 111 _.rootScope.apply(() { | |
| 112 _.rootScope.context['robots'] = ['c3p0+', 'r2d2+']; | |
| 113 _.rootScope.context['robot'] = 'r2d2+'; | |
| 114 }); | |
| 115 | |
| 116 expect(_.rootElement).toEqualSelect(['c3p0+', ['r2d2+']]); | |
| 117 expect(_.rootScope.context['robot']).toEqual('r2d2+'); | |
| 118 }); | |
| 119 | |
| 120 describe('empty option', () { | |
| 121 it('should select the empty option when model is undefined', () { | |
| 122 _.compile( | |
| 123 '<select ng-model="robot">' + | |
| 124 '<option value="">--select--</option>' + | |
| 125 '<option value="x">robot x</option>' + | |
| 126 '<option value="y">robot y</option>' + | |
| 127 '</select>'); | |
| 128 _.rootScope.apply(); | |
| 129 | |
| 130 expect(_.rootElement).toEqualSelect([[''], 'x', 'y']); | |
| 131 }); | |
| 132 | |
| 133 it('should support defining an empty option anywhere in the option list'
, () { | |
| 134 _.compile( | |
| 135 '<select ng-model="robot">' + | |
| 136 '<option value="x">robot x</option>' + | |
| 137 '<option value="">--select--</option>' + | |
| 138 '<option value="y">robot y</option>' + | |
| 139 '</select>'); | |
| 140 _.rootScope.apply(); | |
| 141 | |
| 142 expect(_.rootElement).toEqualSelect(['x', [''], 'y']); | |
| 143 }); | |
| 144 | |
| 145 it('should set the model to empty string when empty option is selected',
() { | |
| 146 _.rootScope.context['robot'] = 'x'; | |
| 147 _.compile( | |
| 148 '<select ng-model="robot" probe="p">' + | |
| 149 '<option value="">--select--</option>' + | |
| 150 '<option value="x">robot x</option>' + | |
| 151 '<option value="y">robot y</option>' + | |
| 152 '</select>'); | |
| 153 _.rootScope.apply(); | |
| 154 | |
| 155 var select = _.rootScope.context['p'].directive(InputSelect); | |
| 156 | |
| 157 expect(_.rootElement).toEqualSelect(['', ['x'], 'y']); | |
| 158 | |
| 159 _.selectOption(_.rootElement, '--select--'); | |
| 160 | |
| 161 expect(_.rootElement).toEqualSelect([[''], 'x', 'y']); | |
| 162 expect(_.rootScope.context['robot']).toEqual(null); | |
| 163 }); | |
| 164 | |
| 165 describe('interactions with repeated options', () { | |
| 166 it('should select empty option when model is undefined', () { | |
| 167 _.rootScope.context['robots'] = ['c3p0', 'r2d2']; | |
| 168 _.compile( | |
| 169 '<select ng-model="robot">' + | |
| 170 '<option value="">--select--</option>' + | |
| 171 '<option ng-repeat="r in robots">{{r}}</option>' + | |
| 172 '</select>'); | |
| 173 _.rootScope.apply(); | |
| 174 expect(_.rootElement).toEqualSelect([[''], 'c3p0', 'r2d2']); | |
| 175 }); | |
| 176 | |
| 177 it('should set model to empty string when selected', () { | |
| 178 _.rootScope.context['robots'] = ['c3p0', 'r2d2']; | |
| 179 _.compile( | |
| 180 '<select ng-model="robot" probe="p">' + | |
| 181 '<option value="">--select--</option>' + | |
| 182 '<option ng-repeat="r in robots">{{r}}</option>' + | |
| 183 '</select>'); | |
| 184 _.rootScope.apply(); | |
| 185 var select = _.rootScope.context['p'].directive(InputSelect); | |
| 186 | |
| 187 _.selectOption(_.rootElement, 'c3p0'); | |
| 188 expect(_.rootElement).toEqualSelect(['', ['c3p0'], 'r2d2']); | |
| 189 expect( _.rootScope.context['robot']).toEqual('c3p0'); | |
| 190 | |
| 191 _.selectOption(_.rootElement, '--select--'); | |
| 192 | |
| 193 expect(_.rootElement).toEqualSelect([[''], 'c3p0', 'r2d2']); | |
| 194 expect( _.rootScope.context['robot']).toEqual(null); | |
| 195 }); | |
| 196 | |
| 197 it('should not break if both the select and repeater models change at
once', () { | |
| 198 _.compile( | |
| 199 '<select ng-model="robot">' + | |
| 200 '<option value="">--select--</option>' + | |
| 201 '<option ng-repeat="r in robots">{{r}}</option>' + | |
| 202 '</select>'); | |
| 203 _.rootScope.apply(() { | |
| 204 _.rootScope.context['robots'] = ['c3p0', 'r2d2']; | |
| 205 _.rootScope.context['robot'] = 'c3p0'; | |
| 206 }); | |
| 207 | |
| 208 expect(_.rootElement).toEqualSelect(['', ['c3p0'], 'r2d2']); | |
| 209 | |
| 210 _.rootScope.apply(() { | |
| 211 _.rootScope.context['robots'] = ['wallee']; | |
| 212 _.rootScope.context['robot'] = ''; | |
| 213 }); | |
| 214 | |
| 215 expect(_.rootElement).toEqualSelect([[''], 'wallee']); | |
| 216 }); | |
| 217 }); | |
| 218 | |
| 219 describe('unknown option', () { | |
| 220 | |
| 221 it("should insert&select temporary unknown option when no options-mode
l match", () { | |
| 222 _.compile( | |
| 223 '<select ng-model="robot">' + | |
| 224 '<option>c3p0</option>' + | |
| 225 '<option>r2d2</option>' + | |
| 226 '</select>'); | |
| 227 _.rootScope.apply(); | |
| 228 expect(_.rootElement).toEqualSelect([['?'], 'c3p0', 'r2d2']); | |
| 229 | |
| 230 _.rootScope.apply(() { | |
| 231 _.rootScope.context['robot'] = 'r2d2'; | |
| 232 }); | |
| 233 expect(_.rootElement).toEqualSelect(['c3p0', ['r2d2']]); | |
| 234 | |
| 235 | |
| 236 _.rootScope.apply(() { | |
| 237 _.rootScope.context['robot'] = "wallee"; | |
| 238 }); | |
| 239 expect(_.rootElement).toEqualSelect([['?'], 'c3p0', 'r2d2']); | |
| 240 }); | |
| 241 | |
| 242 it("should NOT insert temporary unknown option when model is undefined
and empty " + | |
| 243 "options is present", () { | |
| 244 _.compile( | |
| 245 '<select ng-model="robot">' + | |
| 246 '<option value="">--select--</option>' + | |
| 247 '<option>c3p0</option>' + | |
| 248 '<option>r2d2</option>' + | |
| 249 '</select>'); | |
| 250 _.rootScope.apply(); | |
| 251 | |
| 252 expect(_.rootElement).toEqualSelect([[''], 'c3p0', 'r2d2']); | |
| 253 expect(_.rootScope.context['robot']).toEqual(null); | |
| 254 | |
| 255 _.rootScope.apply(() { | |
| 256 _.rootScope.context['robot'] = 'wallee'; | |
| 257 }); | |
| 258 expect(_.rootElement).toEqualSelect([['?'], '', 'c3p0', 'r2d2']); | |
| 259 | |
| 260 _.rootScope.apply(() { | |
| 261 _.rootScope.context['robot'] = 'r2d2'; | |
| 262 }); | |
| 263 expect(_.rootElement).toEqualSelect(['', 'c3p0', ['r2d2']]); | |
| 264 | |
| 265 _.rootScope.apply(() { | |
| 266 _.rootScope.context['robot'] = null; | |
| 267 }); | |
| 268 expect(_.rootElement).toEqualSelect([[''], 'c3p0', 'r2d2']); | |
| 269 }); | |
| 270 | |
| 271 it("should insert&select temporary unknown option when no options-mode
l match, empty " + | |
| 272 "option is present and model is defined", () { | |
| 273 _.rootScope.context['robot'] = 'wallee'; | |
| 274 _.compile( | |
| 275 '<select ng-model="robot">' + | |
| 276 '<option value="">--select--</option>' + | |
| 277 '<option>c3p0</option>' + | |
| 278 '<option>r2d2</option>' + | |
| 279 '</select>'); | |
| 280 _.rootScope.apply(); | |
| 281 | |
| 282 expect(_.rootElement).toEqualSelect([['?'], '', 'c3p0', 'r2d2']); | |
| 283 | |
| 284 _.rootScope.apply(() { | |
| 285 _.rootScope.context['robot'] = 'r2d2'; | |
| 286 }); | |
| 287 expect(_.rootElement).toEqualSelect(['', 'c3p0', ['r2d2']]); | |
| 288 }); | |
| 289 | |
| 290 describe('interactions with repeated options', () { | |
| 291 it('should work with repeated options', () { | |
| 292 _.rootScope.context['robots'] = []; | |
| 293 _.compile( | |
| 294 '<select ng-model="robot">' + | |
| 295 '<option ng-repeat="r in robots">{{r}}</option>' + | |
| 296 '</select>'); | |
| 297 _.rootScope.apply(() { | |
| 298 _.rootScope.context['robots'] = []; | |
| 299 }); | |
| 300 | |
| 301 expect(_.rootElement).toEqualSelect([['?']]); | |
| 302 expect(_.rootScope.context['robot']).toEqual(null); | |
| 303 | |
| 304 _.rootScope.apply(() { | |
| 305 _.rootScope.context['robot'] = 'r2d2'; | |
| 306 }); | |
| 307 expect(_.rootElement).toEqualSelect([['?']]); | |
| 308 expect(_.rootScope.context['robot']).toEqual('r2d2'); | |
| 309 | |
| 310 _.rootScope.apply(() { | |
| 311 _.rootScope.context['robots'] = ['c3p0', 'r2d2']; | |
| 312 }); | |
| 313 expect(_.rootElement).toEqualSelect(['c3p0', ['r2d2']]); | |
| 314 expect(_.rootScope.context['robot']).toEqual('r2d2'); | |
| 315 }); | |
| 316 | |
| 317 it('should work with empty option and repeated options', () { | |
| 318 _.compile( | |
| 319 '<select ng-model="robot">' + | |
| 320 '<option value="">--select--</option>' + | |
| 321 '<option ng-repeat="r in robots">{{r}}</option>' + | |
| 322 '</select>'); | |
| 323 _.rootScope.apply(() { | |
| 324 _.rootScope.context['robots'] = []; | |
| 325 }); | |
| 326 | |
| 327 expect(_.rootElement).toEqualSelect([['']]); | |
| 328 expect(_.rootScope.context['robot']).toEqual(null); | |
| 329 | |
| 330 _.rootScope.apply(() { | |
| 331 _.rootScope.context['robot'] = 'r2d2'; | |
| 332 }); | |
| 333 expect(_.rootElement).toEqualSelect([['?'], '']); | |
| 334 expect(_.rootScope.context['robot']).toEqual('r2d2'); | |
| 335 | |
| 336 _.rootScope.apply(() { | |
| 337 _.rootScope.context['robots'] = ['c3p0', 'r2d2']; | |
| 338 }); | |
| 339 expect(_.rootElement).toEqualSelect(['', 'c3p0', ['r2d2']]); | |
| 340 expect(_.rootScope.context['robot']).toEqual('r2d2'); | |
| 341 }); | |
| 342 | |
| 343 it('should insert unknown element when repeater shrinks and selected
option is ' + | |
| 344 'unavailable', () { | |
| 345 | |
| 346 _.compile( | |
| 347 '<select ng-model="robot">' + | |
| 348 '<option ng-repeat="r in robots">{{r}}</option>' + | |
| 349 '</select>'); | |
| 350 _.rootScope.apply(() { | |
| 351 _.rootScope.context['robots'] = ['c3p0', 'r2d2']; | |
| 352 _.rootScope.context['robot'] = 'r2d2'; | |
| 353 }); | |
| 354 expect(_.rootElement).toEqualSelect(['c3p0', ['r2d2']]); | |
| 355 expect(_.rootScope.context['robot']).toEqual('r2d2'); | |
| 356 | |
| 357 _.rootScope.apply(() { | |
| 358 _.rootScope.context['robots'].remove('r2d2'); | |
| 359 }); | |
| 360 expect(_.rootScope.context['robot']).toEqual('r2d2'); | |
| 361 expect(_.rootElement).toEqualSelect([['?'], 'c3p0']); | |
| 362 | |
| 363 _.rootScope.apply(() { | |
| 364 _.rootScope.context['robots'].insert(0, 'r2d2'); | |
| 365 }); | |
| 366 expect(_.rootElement).toEqualSelect([['r2d2'], 'c3p0']); | |
| 367 expect(_.rootScope.context['robot']).toEqual('r2d2'); | |
| 368 | |
| 369 _.rootScope.apply(() { | |
| 370 _.rootScope.context['robots'].clear(); | |
| 371 }); | |
| 372 | |
| 373 expect(_.rootElement).toEqualSelect([['?']]); | |
| 374 expect(_.rootScope.context['robot']).toEqual('r2d2'); | |
| 375 }); | |
| 376 }); | |
| 377 }); | |
| 378 }); | |
| 379 | |
| 380 it('issue #392', () { | |
| 381 _.compile( | |
| 382 '<div>' + | |
| 383 '<div ng-if="attached">' + | |
| 384 '<select ng-model="model">' + | |
| 385 '<option value="a">foo</option>' + | |
| 386 '<option value="b">bar</option>' + | |
| 387 '</select>' + | |
| 388 '</div>' + | |
| 389 '</div>'); | |
| 390 _.rootScope.context['model'] = 'b'; | |
| 391 _.rootScope.context['attached'] = true; | |
| 392 _.rootScope.apply(); | |
| 393 expect(_.rootElement).toEqualSelect(['a', ['b']]); | |
| 394 _.rootScope.context['attached'] = false; | |
| 395 _.rootScope.apply(); | |
| 396 expect(_.rootElement).toEqualSelect([]); | |
| 397 _.rootScope.context['attached'] = true; | |
| 398 _.rootScope.apply(); | |
| 399 expect(_.rootElement).toEqualSelect(['a', ['b']]); | |
| 400 }); | |
| 401 | |
| 402 | |
| 403 it('issue #428', () { | |
| 404 _.compile( | |
| 405 '<div>' + | |
| 406 '<div ng-if="attached">' + | |
| 407 '<select ng-model="model" multiple>' + | |
| 408 '<option value="a">foo</option>' + | |
| 409 '<option value="b">bar</option>' + | |
| 410 '</select>' + | |
| 411 '</div>' + | |
| 412 '</div>'); | |
| 413 _.rootScope.context['model'] = ['b']; | |
| 414 _.rootScope.context['attached'] = true; | |
| 415 _.rootScope.apply(); | |
| 416 expect(_.rootElement).toEqualSelect(['a', ['b']]); | |
| 417 _.rootScope.context['attached'] = false; | |
| 418 _.rootScope.apply(); | |
| 419 expect(_.rootElement).toEqualSelect([]); | |
| 420 _.rootScope.context['attached'] = true; | |
| 421 _.rootScope.apply(); | |
| 422 expect(_.rootElement).toEqualSelect(['a', ['b']]); | |
| 423 }); | |
| 424 }); | |
| 425 | |
| 426 | |
| 427 describe('select from angular.js', () { | |
| 428 TestBed _; | |
| 429 beforeEach((TestBed tb) => _ = tb); | |
| 430 | |
| 431 var scope, formElement, element; | |
| 432 | |
| 433 compile(html) { | |
| 434 _.compile('<form name="form">' + html + '</form>'); | |
| 435 element = _.rootElement.querySelector('select'); | |
| 436 scope.apply(); | |
| 437 } | |
| 438 | |
| 439 beforeEach((Scope rootScope) { | |
| 440 scope = rootScope; | |
| 441 formElement = element = null; | |
| 442 }); | |
| 443 | |
| 444 | |
| 445 afterEach(() { | |
| 446 scope.destroy(); //disables unknown option work during destruction | |
| 447 }); | |
| 448 | |
| 449 | |
| 450 describe('select-one', () { | |
| 451 | |
| 452 it('should compile children of a select without a ngModel, but not creat
e a model for it', | |
| 453 () { | |
| 454 compile('<select>' + | |
| 455 '<option selected="true">{{a}}</option>' + | |
| 456 '<option value="">{{b}}</option>' + | |
| 457 '<option>C</option>' + | |
| 458 '</select>'); | |
| 459 scope.apply(() { | |
| 460 scope.context['a'] = 'foo'; | |
| 461 scope.context['b'] = 'bar'; | |
| 462 }); | |
| 463 | |
| 464 expect(element.text).toEqual('foobarC'); | |
| 465 }); | |
| 466 | |
| 467 | |
| 468 it('should not interfere with selection via selected attr if ngModel dir
ective is not present', | |
| 469 () { | |
| 470 compile('<select>' + | |
| 471 '<option>not me</option>' + | |
| 472 '<option selected>me!</option>' + | |
| 473 '<option>nah</option>' + | |
| 474 '</select>'); | |
| 475 expect(element).toEqualSelect(['not me', ['me!'], 'nah']); | |
| 476 }); | |
| 477 | |
| 478 it('should fire ng-change event.', () { | |
| 479 var log = ''; | |
| 480 compile( | |
| 481 '<select name="select" ng-model="selection" ng-change="change()">'
+ | |
| 482 '<option value=""></option>' + | |
| 483 '<option value="c">C</option>' + | |
| 484 '</select>'); | |
| 485 | |
| 486 scope.context['change'] = () { | |
| 487 log += 'change:${scope.context['selection']};'; | |
| 488 }; | |
| 489 | |
| 490 scope.apply(() { | |
| 491 scope.context['selection'] = 'c'; | |
| 492 }); | |
| 493 | |
| 494 element.value = 'c'; | |
| 495 _.triggerEvent(element, 'change'); | |
| 496 expect(log).toEqual('change:c;'); | |
| 497 }); | |
| 498 | |
| 499 | |
| 500 it('should require', () { | |
| 501 compile( | |
| 502 '<select name="select" ng-model="selection" probe="i" required ng-ch
ange="change()">' + | |
| 503 '<option value=""></option>' + | |
| 504 '<option value="c">C</option>' + | |
| 505 '</select>'); | |
| 506 | |
| 507 var element = scope.context['i'].element; | |
| 508 | |
| 509 scope.context['log'] = ''; | |
| 510 scope.context['change'] = () { | |
| 511 scope.context['log'] += 'change;'; | |
| 512 }; | |
| 513 | |
| 514 scope.apply(() { | |
| 515 scope.context['log'] = ''; | |
| 516 scope.context['selection'] = 'c'; | |
| 517 }); | |
| 518 | |
| 519 expect(scope.context['form']['select'].hasErrorState('ng-required')).t
oEqual(false); | |
| 520 expect(scope.context['form']['select'].valid).toEqual(true); | |
| 521 expect(scope.context['form']['select'].pristine).toEqual(true); | |
| 522 | |
| 523 scope.apply(() { | |
| 524 scope.context['selection'] = ''; | |
| 525 }); | |
| 526 | |
| 527 expect(scope.context['form']['select'].hasErrorState('ng-required')).t
oEqual(true); | |
| 528 expect(scope.context['form']['select'].invalid).toEqual(true); | |
| 529 expect(scope.context['form']['select'].pristine).toEqual(true); | |
| 530 expect(scope.context['log']).toEqual(''); | |
| 531 | |
| 532 element.value = 'c'; | |
| 533 _.triggerEvent(element, 'change'); | |
| 534 scope.apply(); | |
| 535 | |
| 536 expect(scope.context['form']['select'].valid).toEqual(true); | |
| 537 expect(scope.context['form']['select'].dirty).toEqual(true); | |
| 538 expect(scope.context['log']).toEqual('change;'); | |
| 539 }); | |
| 540 | |
| 541 | |
| 542 it('should not be invalid if no require', () { | |
| 543 compile( | |
| 544 '<select name="select" ng-model="selection">' + | |
| 545 '<option value=""></option>' + | |
| 546 '<option value="c">C</option>' + | |
| 547 '</select>'); | |
| 548 | |
| 549 expect(scope.context['form']['select'].valid).toEqual(true); | |
| 550 expect(scope.context['form']['select'].pristine).toEqual(true); | |
| 551 }); | |
| 552 | |
| 553 | |
| 554 describe('empty option', () { | |
| 555 | |
| 556 it('should select the empty option when model is undefined', () { | |
| 557 compile('<select ng-model="robot">' + | |
| 558 '<option value="">--select--</option>' + | |
| 559 '<option value="x">robot x</option>' + | |
| 560 '<option value="y">robot y</option>' + | |
| 561 '</select>'); | |
| 562 | |
| 563 expect(element).toEqualSelect([[''], 'x', 'y']); | |
| 564 }); | |
| 565 | |
| 566 | |
| 567 it('should support defining an empty option anywhere in the option lis
t', () { | |
| 568 compile('<select ng-model="robot">' + | |
| 569 '<option value="x">robot x</option>' + | |
| 570 '<option value="">--select--</option>' + | |
| 571 '<option value="y">robot y</option>' + | |
| 572 '</select>'); | |
| 573 | |
| 574 expect(element).toEqualSelect(['x', [''], 'y']); | |
| 575 }); | |
| 576 }); | |
| 577 }); | |
| 578 | |
| 579 | |
| 580 describe('select-multiple', () { | |
| 581 | |
| 582 it('should support type="select-multiple"', () { | |
| 583 compile( | |
| 584 '<select ng-model="selection" multiple>' + | |
| 585 '<option>A</option>' + | |
| 586 '<option>B</option>' + | |
| 587 '</select>'); | |
| 588 | |
| 589 scope.apply(() { | |
| 590 scope.context['selection'] = ['A']; | |
| 591 }); | |
| 592 | |
| 593 expect(element).toEqualSelect([['A'], 'B']); | |
| 594 | |
| 595 scope.apply(() { | |
| 596 scope.context['selection'].add('B'); | |
| 597 }); | |
| 598 | |
| 599 expect(element).toEqualSelect([['A'], ['B']]); | |
| 600 }); | |
| 601 | |
| 602 it('should work with optgroups', () { | |
| 603 compile('<select ng-model="selection" multiple>' + | |
| 604 '<optgroup label="group1">' + | |
| 605 '<option>A</option>' + | |
| 606 '<option>B</option>' + | |
| 607 '</optgroup>' + | |
| 608 '</select>'); | |
| 609 | |
| 610 expect(element).toEqualSelect(['A', 'B']); | |
| 611 expect(scope.context['selection']).toEqual(null); | |
| 612 | |
| 613 scope.apply(() { | |
| 614 scope.context['selection'] = ['A']; | |
| 615 }); | |
| 616 expect(element).toEqualSelect([['A'], 'B']); | |
| 617 | |
| 618 scope.apply(() { | |
| 619 scope.context['selection'].add('B'); | |
| 620 }); | |
| 621 expect(element).toEqualSelect([['A'], ['B']]); | |
| 622 }); | |
| 623 | |
| 624 it('should require', () { | |
| 625 compile( | |
| 626 '<select name="select" probe="i" ng-model="selection" multiple requi
red>' + | |
| 627 '<option>A</option>' + | |
| 628 '<option>B</option>' + | |
| 629 '</select>'); | |
| 630 | |
| 631 var element = scope.context['i'].element; | |
| 632 scope.apply(() { | |
| 633 scope.context['selection'] = []; | |
| 634 }); | |
| 635 | |
| 636 expect(scope.context['form']['select'].hasErrorState('ng-required')).t
oEqual(true); | |
| 637 expect(scope.context['form']['select'].invalid).toEqual(true); | |
| 638 expect(scope.context['form']['select'].pristine).toEqual(true); | |
| 639 | |
| 640 scope.apply(() { | |
| 641 scope.context['selection'] = ['A']; | |
| 642 }); | |
| 643 | |
| 644 expect(scope.context['form']['select'].valid).toEqual(true); | |
| 645 expect(scope.context['form']['select'].pristine).toEqual(true); | |
| 646 | |
| 647 element.value = 'B'; | |
| 648 _.triggerEvent(element, 'change'); | |
| 649 | |
| 650 expect(scope.context['form']['select'].valid).toEqual(true); | |
| 651 expect(scope.context['form']['select'].dirty).toEqual(true); | |
| 652 }); | |
| 653 }); | |
| 654 | |
| 655 | |
| 656 describe('ngOptions', () { | |
| 657 createSelect(attrs, [blank, unknown, ngRepeat, text, ngValue]) { | |
| 658 var html = '<select'; | |
| 659 attrs.forEach((key, value) { | |
| 660 if (value is bool) { | |
| 661 if (value != null) html += ' $key'; | |
| 662 } else { | |
| 663 html += ' $key="$value"'; | |
| 664 } | |
| 665 }); | |
| 666 html += '>' + | |
| 667 (blank != null ? (blank is String ? blank : '<option value="">blank<
/option>') : '') + | |
| 668 (unknown != null ? (unknown is String ? unknown : '<option value="?"
>unknown</option>') : '') + | |
| 669 (ngRepeat != null ? '<option ng-repeat="$ngRepeat" ng-value="$ngValu
e">{{$text}}</option>' : '') + | |
| 670 '</select>'; | |
| 671 | |
| 672 compile(html); | |
| 673 } | |
| 674 | |
| 675 createSingleSelect([blank, unknown]) { | |
| 676 createSelect({ | |
| 677 'ng-model':'selected' | |
| 678 }, blank, unknown, 'value in values', 'value.name', 'value'); | |
| 679 } | |
| 680 | |
| 681 createMultiSelect([blank, unknown]) { | |
| 682 createSelect({ | |
| 683 'ng-model':'selected', | |
| 684 'multiple':true | |
| 685 }, blank, unknown, 'value in values', 'value.name', 'value'); | |
| 686 } | |
| 687 | |
| 688 | |
| 689 it('should render a list', () { | |
| 690 createSingleSelect(); | |
| 691 | |
| 692 scope.apply(() { | |
| 693 scope.context['values'] = [{'name': 'A'}, {'name': 'B'}, {'name': 'C
'}]; | |
| 694 scope.context['selected'] = scope.context['values'][0]; | |
| 695 }); | |
| 696 | |
| 697 var options = element.querySelectorAll('option'); | |
| 698 expect(options.length).toEqual(3); | |
| 699 expect(element).toEqualSelect([['A'], 'B', 'C']); | |
| 700 }); | |
| 701 | |
| 702 it('should render zero as a valid display value', () { | |
| 703 createSingleSelect(); | |
| 704 | |
| 705 scope.apply(() { | |
| 706 scope.context['values'] = [{'name': '0'}, {'name': '1'}, {'name': '2
'}]; | |
| 707 scope.context['selected'] = scope.context['values'][0]; | |
| 708 }); | |
| 709 | |
| 710 var options = element.querySelectorAll('option'); | |
| 711 expect(options.length).toEqual(3); | |
| 712 expect(element).toEqualSelect([['0'], '1', '2']); | |
| 713 }); | |
| 714 | |
| 715 it('should grow list', () { | |
| 716 createSingleSelect(); | |
| 717 | |
| 718 scope.apply(() { | |
| 719 scope.context['values'] = []; | |
| 720 }); | |
| 721 | |
| 722 expect(element.querySelectorAll('option').length).toEqual(1); // becau
se we add special empty option | |
| 723 expect(element.querySelectorAll('option')[0].text).toEqual(''); | |
| 724 expect(element.querySelectorAll('option')[0].value).toEqual('?'); | |
| 725 | |
| 726 scope.apply(() { | |
| 727 scope.context['values'].add({'name':'A'}); | |
| 728 scope.context['selected'] = scope.context['values'][0]; | |
| 729 }); | |
| 730 | |
| 731 expect(element.querySelectorAll('option').length).toEqual(1); | |
| 732 expect(element).toEqualSelect([['A']]); | |
| 733 | |
| 734 scope.apply(() { | |
| 735 scope.context['values'].add({'name':'B'}); | |
| 736 }); | |
| 737 | |
| 738 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 739 expect(element).toEqualSelect([['A'], 'B']); | |
| 740 }); | |
| 741 | |
| 742 | |
| 743 it('should shrink list', () { | |
| 744 createSingleSelect(); | |
| 745 | |
| 746 scope.apply(() { | |
| 747 scope.context['values'] = [{'name':'A'}, {'name':'B'}, {'name':'C'}]
; | |
| 748 scope.context['selected'] = scope.context['values'][0]; | |
| 749 }); | |
| 750 | |
| 751 expect(element.querySelectorAll('option').length).toEqual(3); | |
| 752 | |
| 753 scope.apply(() { | |
| 754 scope.context['values'].removeLast(); | |
| 755 }); | |
| 756 | |
| 757 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 758 expect(element).toEqualSelect([['A'], 'B']); | |
| 759 | |
| 760 scope.apply(() { | |
| 761 scope.context['values'].removeLast(); | |
| 762 }); | |
| 763 | |
| 764 expect(element.querySelectorAll('option').length).toEqual(1); | |
| 765 expect(element).toEqualSelect([['A']]); | |
| 766 | |
| 767 scope.apply(() { | |
| 768 scope.context['values'].removeLast(); | |
| 769 scope.context['selected'] = null; | |
| 770 }); | |
| 771 | |
| 772 expect(element.querySelectorAll('option').length).toEqual(1); // we ad
d back the special empty option | |
| 773 }); | |
| 774 | |
| 775 | |
| 776 it('should shrink and then grow list', () { | |
| 777 createSingleSelect(); | |
| 778 | |
| 779 scope.apply(() { | |
| 780 scope.context['values'] = [{'name':'A'}, {'name':'B'}, {'name':'C'}]
; | |
| 781 scope.context['selected'] = scope.context['values'][0]; | |
| 782 }); | |
| 783 | |
| 784 expect(element.querySelectorAll('option').length).toEqual(3); | |
| 785 | |
| 786 scope.apply(() { | |
| 787 scope.context['values'] = [{'name': '1'}, {'name': '2'}]; | |
| 788 scope.context['selected'] = scope.context['values'][0]; | |
| 789 }); | |
| 790 | |
| 791 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 792 | |
| 793 scope.apply(() { | |
| 794 scope.context['values'] = [{'name': 'A'}, {'name': 'B'}, {'name': 'C
'}]; | |
| 795 scope.context['selected'] = scope.context['values'][0]; | |
| 796 }); | |
| 797 | |
| 798 expect(element.querySelectorAll('option').length).toEqual(3); | |
| 799 }); | |
| 800 | |
| 801 | |
| 802 it('should update list', () { | |
| 803 createSingleSelect(); | |
| 804 | |
| 805 scope.apply(() { | |
| 806 scope.context['values'] = [{'name': 'A'}, {'name': 'B'}, {'name': 'C
'}]; | |
| 807 scope.context['selected'] = scope.context['values'][0]; | |
| 808 }); | |
| 809 expect(element).toEqualSelect([['A'], 'B', 'C']); | |
| 810 scope.apply(() { | |
| 811 scope.context['values'] = [{'name': 'B'}, {'name': 'C'}, {'name': 'D
'}]; | |
| 812 scope.context['selected'] = scope.context['values'][0]; | |
| 813 }); | |
| 814 | |
| 815 var options = element.querySelectorAll('option'); | |
| 816 expect(options.length).toEqual(3); | |
| 817 expect(element).toEqualSelect([['B'], 'C', 'D']); | |
| 818 }); | |
| 819 | |
| 820 | |
| 821 it('should preserve existing options', () { | |
| 822 createSingleSelect(true); | |
| 823 | |
| 824 scope.apply(() { | |
| 825 scope.context['values'] = []; | |
| 826 }); | |
| 827 | |
| 828 expect(element.querySelectorAll('option').length).toEqual(1); | |
| 829 | |
| 830 scope.apply(() { | |
| 831 scope.context['values'] = [{'name': 'A'}]; | |
| 832 scope.context['selected'] = scope.context['values'][0]; | |
| 833 }); | |
| 834 | |
| 835 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 836 expect(element.querySelectorAll('option')[0].text).toEqual('blank'); | |
| 837 expect(element.querySelectorAll('option')[1].text).toEqual('A'); | |
| 838 | |
| 839 scope.apply(() { | |
| 840 scope.context['values'] = []; | |
| 841 scope.context['selected'] = null; | |
| 842 }); | |
| 843 | |
| 844 expect(element.querySelectorAll('option').length).toEqual(1); | |
| 845 expect(element.querySelectorAll('option')[0].text).toEqual('blank'); | |
| 846 }); | |
| 847 | |
| 848 describe('binding', () { | |
| 849 | |
| 850 it('should bind to scope value', () { | |
| 851 createSingleSelect(); | |
| 852 | |
| 853 scope.apply(() { | |
| 854 scope.context['values'] = [{'name': 'A'}, {'name': 'B'}]; | |
| 855 scope.context['selected'] = scope.context['values'][0]; | |
| 856 }); | |
| 857 | |
| 858 expect(element).toEqualSelect([['A'], 'B']); | |
| 859 | |
| 860 scope.apply(() { | |
| 861 scope.context['selected'] = scope.context['values'][1]; | |
| 862 }); | |
| 863 | |
| 864 expect(element).toEqualSelect(['A', ['B']]); | |
| 865 }); | |
| 866 | |
| 867 | |
| 868 it('should bind to scope value and group', () { | |
| 869 var element = _.compile( | |
| 870 '<select ng-model="selected" probe="p">' | |
| 871 '<optgroup label=\'{{ group["title"] }}\' ng-repeat="group in
values">' | |
| 872 '<option value=\'{{ item["val"] }}\' ' | |
| 873 'ng-repeat=\'item in group["items"]\'>{{ item["name"
] }}</option>' | |
| 874 '</optgroup>' | |
| 875 '</select>'); | |
| 876 | |
| 877 scope.apply(() { | |
| 878 scope.context['values'] = [ | |
| 879 { 'title': 'first', 'items': | |
| 880 [{ 'val':'a', 'name' : 'A' }, { 'val':'c', 'name' : 'C' } ]}, | |
| 881 { 'title': 'second', 'items': | |
| 882 [{ 'val':'b', 'name' : 'B' }, { 'val':'d', 'name' : 'D' } ]} | |
| 883 ]; | |
| 884 scope.context['selected'] = scope.context['values'][1]['items'][0]
['val']; | |
| 885 }); | |
| 886 | |
| 887 expect(element).toEqualSelect(['a', 'c', ['b'], 'd']); | |
| 888 | |
| 889 var first = element.querySelectorAll('optgroup')[0]; | |
| 890 var b = first.querySelectorAll('option')[0]; | |
| 891 var d = first.querySelectorAll('option')[1]; | |
| 892 expect(first.getAttribute('label')).toEqual('first'); | |
| 893 expect(b.text).toEqual('A'); | |
| 894 expect(d.text).toEqual('C'); | |
| 895 | |
| 896 var second = element.querySelectorAll('optgroup')[1]; | |
| 897 var c = second.querySelectorAll('option')[0]; | |
| 898 var e = second.querySelectorAll('option')[1]; | |
| 899 expect(second.getAttribute('label')).toEqual('second'); | |
| 900 expect(c.text).toEqual('B'); | |
| 901 expect(e.text).toEqual('D'); | |
| 902 | |
| 903 scope.apply(() { | |
| 904 scope.context['selected'] = scope.context['values'][0]['items'][1]
['val']; | |
| 905 }); | |
| 906 | |
| 907 expect(element.value).toEqual('c'); | |
| 908 }); | |
| 909 | |
| 910 | |
| 911 it('should bind to scope value through experession', () { | |
| 912 createSelect({'ng-model': 'selected'}, null, null, 'item in values',
'item.name', 'item.id'); | |
| 913 | |
| 914 scope.apply(() { | |
| 915 scope.context['values'] = [{'id': 10, 'name': 'A'}, {'id': 20, 'na
me': 'B'}]; | |
| 916 scope.context['selected'] = scope.context['values'][0]['id']; | |
| 917 }); | |
| 918 | |
| 919 expect(element).toEqualSelect([['A'], 'B']); | |
| 920 | |
| 921 scope.apply(() { | |
| 922 scope.context['selected'] = scope.context['values'][1]['id']; | |
| 923 }); | |
| 924 | |
| 925 expect(element).toEqualSelect(['A', ['B']]); | |
| 926 }); | |
| 927 | |
| 928 | |
| 929 it('should insert a blank option if bound to null', () { | |
| 930 createSingleSelect(); | |
| 931 | |
| 932 scope.apply(() { | |
| 933 scope.context['values'] = [{'name': 'A'}]; | |
| 934 scope.context['selected'] = null; | |
| 935 }); | |
| 936 | |
| 937 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 938 expect(element).toEqualSelect([['?'], 'A']); | |
| 939 expect(element.querySelectorAll('option')[0].value).toEqual('?'); | |
| 940 | |
| 941 scope.apply(() { | |
| 942 scope.context['selected'] = scope.context['values'][0]; | |
| 943 }); | |
| 944 | |
| 945 expect(element).toEqualSelect([['A']]); | |
| 946 expect(element.querySelectorAll('option').length).toEqual(1); | |
| 947 }); | |
| 948 | |
| 949 | |
| 950 it('should reuse blank option if bound to null', () { | |
| 951 createSingleSelect(true); | |
| 952 | |
| 953 scope.apply(() { | |
| 954 scope.context['values'] = [{'name': 'A'}]; | |
| 955 scope.context['selected'] = null; | |
| 956 }); | |
| 957 | |
| 958 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 959 expect(element.value).toEqual(''); | |
| 960 expect(element.querySelectorAll('option')[0].value).toEqual(''); | |
| 961 | |
| 962 scope.apply(() { | |
| 963 scope.context['selected'] = scope.context['values'][0]; | |
| 964 }); | |
| 965 | |
| 966 expect(element).toEqualSelect(['', ['A']]); | |
| 967 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 968 }); | |
| 969 | |
| 970 | |
| 971 it('should insert a unknown option if bound to something not in the li
st', () { | |
| 972 createSingleSelect(); | |
| 973 | |
| 974 scope.apply(() { | |
| 975 scope.context['values'] = [{'name': 'A'}]; | |
| 976 scope.context['selected'] = {}; | |
| 977 }); | |
| 978 | |
| 979 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 980 expect(element.value).toEqual('?'); | |
| 981 expect(element.querySelectorAll('option')[0].value).toEqual('?'); | |
| 982 | |
| 983 scope.apply(() { | |
| 984 scope.context['selected'] = scope.context['values'][0]; | |
| 985 }); | |
| 986 | |
| 987 expect(element).toEqualSelect([['A']]); | |
| 988 expect(element.querySelectorAll('option').length).toEqual(1); | |
| 989 }); | |
| 990 | |
| 991 | |
| 992 it('should select correct input if previously selected option was "?"'
, () { | |
| 993 createSingleSelect(); | |
| 994 | |
| 995 scope.apply(() { | |
| 996 scope.context['values'] = [{'name': 'A'}, {'name': 'B'}]; | |
| 997 scope.context['selected'] = {}; | |
| 998 }); | |
| 999 | |
| 1000 expect(element.querySelectorAll('option').length).toEqual(3); | |
| 1001 expect(element.value).toEqual('?'); | |
| 1002 expect(element.querySelectorAll('option')[0].value).toEqual('?'); | |
| 1003 | |
| 1004 _.selectOption(element, 'A'); | |
| 1005 expect(scope.context['selected']).toBe(scope.context['values'][0]); | |
| 1006 expect(element.querySelectorAll('option')[0].selected).toEqual(true)
; | |
| 1007 expect(element.querySelectorAll('option')[0].selected).toEqual(true)
;; | |
| 1008 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 1009 }); | |
| 1010 }); | |
| 1011 | |
| 1012 | |
| 1013 describe('blank option', () { | |
| 1014 | |
| 1015 it('should be compiled as template, be watched and updated', () { | |
| 1016 var option; | |
| 1017 createSingleSelect('<option value="">blank is {{blankVal}}</option>'
); | |
| 1018 | |
| 1019 scope.apply(() { | |
| 1020 scope.context['blankVal'] = 'so blank'; | |
| 1021 scope.context['values'] = [{'name': 'A'}]; | |
| 1022 }); | |
| 1023 | |
| 1024 // check blank option is first and is compiled | |
| 1025 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 1026 option = element.querySelectorAll('option')[0]; | |
| 1027 expect(option.value).toEqual(''); | |
| 1028 expect(option.text).toEqual('blank is so blank'); | |
| 1029 | |
| 1030 scope.apply(() { | |
| 1031 scope.context['blankVal'] = 'not so blank'; | |
| 1032 }); | |
| 1033 | |
| 1034 // check blank option is first and is compiled | |
| 1035 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 1036 option = element.querySelectorAll('option')[0]; | |
| 1037 expect(option.value).toEqual(''); | |
| 1038 expect(option.text).toEqual('blank is not so blank'); | |
| 1039 }); | |
| 1040 | |
| 1041 | |
| 1042 it('should support binding via ngBindTemplate directive', () { | |
| 1043 var option; | |
| 1044 createSingleSelect('<option value="" ng-bind="\'blank is \' + blankV
al"></option>'); | |
| 1045 | |
| 1046 scope.apply(() { | |
| 1047 scope.context['blankVal'] = 'so blank'; | |
| 1048 scope.context['values'] = [{'name': 'A'}]; | |
| 1049 }); | |
| 1050 | |
| 1051 // check blank option is first and is compiled | |
| 1052 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 1053 option = element.querySelectorAll('option')[0]; | |
| 1054 expect(option.value).toEqual(''); | |
| 1055 expect(option.text).toEqual('blank is so blank'); | |
| 1056 }); | |
| 1057 | |
| 1058 | |
| 1059 it('should support biding via ngBind attribute', () { | |
| 1060 var option; | |
| 1061 createSingleSelect('<option value="" ng-bind="blankVal"></option>'); | |
| 1062 | |
| 1063 scope.apply(() { | |
| 1064 scope.context['blankVal'] = 'is blank'; | |
| 1065 scope.context['values'] = [{'name': 'A'}]; | |
| 1066 }); | |
| 1067 | |
| 1068 // check blank option is first and is compiled | |
| 1069 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 1070 option = element.querySelectorAll('option')[0]; | |
| 1071 expect(option.value).toEqual(''); | |
| 1072 expect(option.text).toEqual('is blank'); | |
| 1073 }); | |
| 1074 | |
| 1075 | |
| 1076 it('should be rendered with the attributes preserved', () { | |
| 1077 var option; | |
| 1078 createSingleSelect('<option value="" class="coyote" id="road-runner"
' + | |
| 1079 'custom-attr="custom-attr">{{blankVal}}</option>'); | |
| 1080 | |
| 1081 scope.apply(() { | |
| 1082 scope.context['blankVal'] = 'is blank'; | |
| 1083 }); | |
| 1084 | |
| 1085 // check blank option is first and is compiled | |
| 1086 option = element.querySelectorAll('option')[0]; | |
| 1087 expect(option.classes.contains('coyote')).toEqual(true);; | |
| 1088 expect(option.attributes['id']).toEqual('road-runner'); | |
| 1089 expect(option.attributes['custom-attr']).toEqual('custom-attr'); | |
| 1090 }); | |
| 1091 | |
| 1092 it('should be selected, if it is available and no other option is sele
cted', () { | |
| 1093 // selectedIndex is used here because $ incorrectly reports element.
value | |
| 1094 scope.apply(() { | |
| 1095 scope.context['values'] = [{'name': 'A'}]; | |
| 1096 }); | |
| 1097 createSingleSelect(true); | |
| 1098 // ensure the first option (the blank option) is selected | |
| 1099 expect(element.selectedIndex).toEqual(0); | |
| 1100 scope.apply(); | |
| 1101 // ensure the option has not changed following the digest | |
| 1102 expect(element.selectedIndex).toEqual(0); | |
| 1103 }); | |
| 1104 }); | |
| 1105 | |
| 1106 | |
| 1107 describe('on change', () { | |
| 1108 | |
| 1109 it('should update model on change', () { | |
| 1110 createSingleSelect(); | |
| 1111 | |
| 1112 scope.apply(() { | |
| 1113 scope.context['values'] = [{'name': 'A'}, {'name': 'B'}]; | |
| 1114 scope.context['selected'] = scope.context['values'][0]; | |
| 1115 }); | |
| 1116 | |
| 1117 expect(element.querySelectorAll('option')[0].selected).toEqual(true)
; | |
| 1118 | |
| 1119 element.querySelectorAll('option')[1].selected = true; | |
| 1120 _.triggerEvent(element, 'change'); | |
| 1121 expect(scope.context['selected']).toEqual(scope.context['values'][1]
); | |
| 1122 }); | |
| 1123 | |
| 1124 | |
| 1125 it('should update model on change through expression', () { | |
| 1126 createSelect({'ng-model': 'selected'}, null, null, | |
| 1127 'item in values', 'item.name', 'item.id'); | |
| 1128 | |
| 1129 scope.apply(() { | |
| 1130 scope.context['values'] = [{'id': 10, 'name': 'A'}, {'id': 20, 'na
me': 'B'}]; | |
| 1131 scope.context['selected'] = scope.context['values'][0]['id']; | |
| 1132 }); | |
| 1133 | |
| 1134 expect(element).toEqualSelect([['A'], 'B']); | |
| 1135 | |
| 1136 element.querySelectorAll('option')[1].selected = true; | |
| 1137 _.triggerEvent(element, 'change'); | |
| 1138 expect(scope.context['selected']).toEqual(scope.context['values'][1]
['id']); | |
| 1139 }); | |
| 1140 | |
| 1141 | |
| 1142 it('should update model to null on change', () { | |
| 1143 createSingleSelect(true); | |
| 1144 | |
| 1145 scope.apply(() { | |
| 1146 scope.context['values'] = [{'name': 'A'}, {'name': 'B'}]; | |
| 1147 scope.context['selected'] = scope.context['values'][0]; | |
| 1148 element.value = '0'; | |
| 1149 }); | |
| 1150 | |
| 1151 _.selectOption(element, 'blank'); | |
| 1152 expect(element).toEqualSelect([[''], 'A', 'B']); | |
| 1153 | |
| 1154 expect(scope.context['selected']).toEqual(null); | |
| 1155 }); | |
| 1156 }); | |
| 1157 | |
| 1158 | |
| 1159 describe('select-many', () { | |
| 1160 | |
| 1161 it('should read multiple selection', () { | |
| 1162 createMultiSelect(); | |
| 1163 | |
| 1164 scope.apply(() { | |
| 1165 scope.context['values'] = [{'name': 'A'}, {'name': 'B'}]; | |
| 1166 scope.context['selected'] = []; | |
| 1167 }); | |
| 1168 | |
| 1169 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 1170 expect(element.querySelectorAll('option')[0].selected).toEqual(false
);; | |
| 1171 expect(element.querySelectorAll('option')[1].selected).toEqual(false
);; | |
| 1172 | |
| 1173 scope.apply(() { | |
| 1174 scope.context['selected'].add(scope.context['values'][1]); | |
| 1175 }); | |
| 1176 | |
| 1177 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 1178 expect(element.querySelectorAll('option')[0].selected).toEqual(false
);; | |
| 1179 expect(element.querySelectorAll('option')[1].selected).toEqual(true)
;; | |
| 1180 | |
| 1181 scope.apply(() { | |
| 1182 scope.context['selected'].add(scope.context['values'][0]); | |
| 1183 }); | |
| 1184 | |
| 1185 expect(element.querySelectorAll('option').length).toEqual(2); | |
| 1186 expect(element.querySelectorAll('option')[0].selected).toEqual(true)
;; | |
| 1187 expect(element.querySelectorAll('option')[1].selected).toEqual(true)
;; | |
| 1188 }); | |
| 1189 | |
| 1190 | |
| 1191 it('should update model on change', () { | |
| 1192 createMultiSelect(); | |
| 1193 | |
| 1194 scope.apply(() { | |
| 1195 scope.context['values'] = [{'name': 'A'}, {'name': 'B'}]; | |
| 1196 scope.context['selected'] = []; | |
| 1197 }); | |
| 1198 | |
| 1199 element.querySelectorAll('option')[0].selected = true; | |
| 1200 | |
| 1201 _.triggerEvent(element, 'change'); | |
| 1202 expect(scope.context['selected']).toEqual([scope.context['values'][0
]]); | |
| 1203 }); | |
| 1204 | |
| 1205 | |
| 1206 it('should deselect all options when model is emptied', () { | |
| 1207 createMultiSelect(); | |
| 1208 scope.apply(() { | |
| 1209 scope.context['values'] = [{'name': 'A'}, {'name': 'B'}]; | |
| 1210 scope.context['selected'] = [scope.context['values'][0]]; | |
| 1211 }); | |
| 1212 expect(element.querySelectorAll('option')[0].selected).toEqual(true)
; | |
| 1213 | |
| 1214 scope.apply(() { | |
| 1215 scope.context['selected'].removeLast(); | |
| 1216 }); | |
| 1217 | |
| 1218 expect(element.querySelectorAll('option')[0].selected).toEqual(false
); | |
| 1219 }); | |
| 1220 }); | |
| 1221 | |
| 1222 | |
| 1223 xdescribe('ngRequired', () { | |
| 1224 | |
| 1225 it('should allow bindings on ngRequired', () { | |
| 1226 createSelect({ | |
| 1227 'ng-model': 'value', | |
| 1228 'ng-options': 'item.name for item in values', | |
| 1229 'ng-required': 'required' | |
| 1230 }, true); | |
| 1231 | |
| 1232 | |
| 1233 scope.apply(() { | |
| 1234 scope.context['values'] = [{'name': 'A', 'id': 1}, {'name': 'B', '
id': 2}]; | |
| 1235 scope.context['required'] = false; | |
| 1236 }); | |
| 1237 | |
| 1238 element.value = ''; | |
| 1239 _.triggerEvent(element, 'change'); | |
| 1240 expect(element).toBeValid(); | |
| 1241 | |
| 1242 scope.apply(() { | |
| 1243 scope.context['required'] = true; | |
| 1244 }); | |
| 1245 expect(element).not.toBeValid(); | |
| 1246 | |
| 1247 scope.apply(() { | |
| 1248 scope.context['value'] = scope.context['values'][0]; | |
| 1249 }); | |
| 1250 expect(element).toBeValid(); | |
| 1251 | |
| 1252 element.value = ''; | |
| 1253 _.triggerEvent(element, 'change'); | |
| 1254 expect(element).not.toBeValid(); | |
| 1255 | |
| 1256 scope.apply(() { | |
| 1257 scope.context['required'] = false; | |
| 1258 }); | |
| 1259 expect(element).toBeValid(); | |
| 1260 }); | |
| 1261 }); | |
| 1262 }); | |
| 1263 | |
| 1264 | |
| 1265 describe('option', () { | |
| 1266 | |
| 1267 it('should populate value attribute on OPTION', () { | |
| 1268 compile('<select ng-model="x"><option selected>abc</option></select>')
; | |
| 1269 expect(element).toEqualSelect([['?'], 'abc']); | |
| 1270 }); | |
| 1271 | |
| 1272 it('should ignore value if already exists', () { | |
| 1273 compile('<select ng-model="x"><option value="abc">xyz</option></select
>'); | |
| 1274 expect(element).toEqualSelect([['?'], 'abc']); | |
| 1275 }); | |
| 1276 | |
| 1277 it('should set value even if self closing HTML', () { | |
| 1278 scope.context['x'] = 'hello'; | |
| 1279 compile('<select ng-model="x"><option>hello</select>'); | |
| 1280 expect(element).toEqualSelect([['hello']]); | |
| 1281 }); | |
| 1282 | |
| 1283 it('should not blow up when option directive is found inside of a datali
st', | |
| 1284 () { | |
| 1285 _.compile('<div>' | |
| 1286 '<datalist><option>some val</option></datalist>' | |
| 1287 '<span>{{foo}}</span>' | |
| 1288 '</div>'); | |
| 1289 | |
| 1290 _.rootScope.context['foo'] = 'success'; | |
| 1291 _.rootScope.apply(); | |
| 1292 expect(_.rootElement.querySelector('span').text).toEqual('success'); | |
| 1293 }); | |
| 1294 }); | |
| 1295 }); | |
| 1296 }); | |
| 1297 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 256553002:
Revert "Update all Angular libs (run update_all.sh)." (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart