<!doctype html>
<!--
@license
Copyright (c) 2015 The Polymer Project Authors. All rights reserved.
This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt
The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt
The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt
Code distributed by Google as part of the polymer project is also
subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt
-->

<html>
<head>

  <title>iron-selector-content</title>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0">

  <script src="../../webcomponentsjs/webcomponents-lite.js"></script>
  <script src="../../web-component-tester/browser.js"></script>
  <script src="../../test-fixture/test-fixture-mocha.js"></script>

  <link rel="import" href="../../test-fixture/test-fixture.html">
  <link rel="import" href="content-element.html">

  <style>
    .iron-selected {
      background: #ccc;
    }
  </style>

</head>
<body>

  <test-content-element id="selector1" selected="item0">
    <div id="item0">item0</div>
    <div id="item1">item1</div>
    <div id="item2">item2</div>
    <div id="item3">item3</div>
  </test-content-element>

  <test-content-element id="selector2" selected="item0" selectable="item">
    <item id="item0">item0</item>
    <hr>
    <item id="item1">item1</item>
    <item id="item2">item2</item>
    <hr>
    <item id="item3">item3</item>
  </test-content-element>

  <test-content-element id="selector3" selected="item0">
    <template is="dom-repeat" id="t">
      <div id$="[[item.name]]">[[item.name]]</div>
    </template>
  </test-content-element>

  <script>

    var s1 = document.querySelector('#selector1');
    var s2 = document.querySelector('#selector2');
    var s3 = document.querySelector('#selector3');

    var t = document.querySelector('#t');

    suite('content', function() {

      test('attribute selected', function() {
        // check selected class
        assert.isTrue(s1.querySelector('#item0').classList.contains('iron-selected'));
      });

      test('set selected', function() {
        // set selected
        s1.selected = 'item1';
        // check selected class
        assert.isTrue(s1.querySelector('#item1').classList.contains('iron-selected'));
      });

      test('get items', function() {
        assert.equal(s1.$.selector.items.length, 4);
      });

      test('activate event', function() {
        var item = s1.querySelector('#item2');
        item.dispatchEvent(new CustomEvent('tap', {bubbles: true}));
        // check selected class
        assert.isTrue(item.classList.contains('iron-selected'));
      });

      test('add item dynamically', function() {
        var item = document.createElement('div');
        item.id = 'item4';
        item.textContent = 'item4';
        Polymer.dom(s1).appendChild(item);
        Polymer.dom.flush();
        // set selected
        s1.selected = 'item4';
        // check items length
        assert.equal(s1.$.selector.items.length, 5);
        // check selected class
        assert.isTrue(s1.querySelector('#item4').classList.contains('iron-selected'));
      });

    });

    suite('content with selectable', function() {

      test('attribute selected', function() {
        // check selected class
        assert.isTrue(s2.querySelector('#item0').classList.contains('iron-selected'));
      });

      test('set selected', function() {
        // set selected
        s2.selected = 'item1';
        // check selected class
        assert.isTrue(s2.querySelector('#item1').classList.contains('iron-selected'));
      });

      test('get items', function() {
        assert.equal(s2.$.selector.items.length, 4);
      });

      test('activate event', function() {
        var item = s2.querySelector('#item2');
        item.dispatchEvent(new CustomEvent('tap', {bubbles: true}));
        // check selected class
        assert.isTrue(item.classList.contains('iron-selected'));
      });

      test('add item dynamically', function() {
        var item = document.createElement('item');
        item.id = 'item4';
        item.textContent = 'item4';
        Polymer.dom(s2).appendChild(item);
        Polymer.dom.flush();
        // set selected
        s2.selected = 'item4';
        // check items length
        assert.equal(s2.$.selector.items.length, 5);
        // check selected class
        assert.isTrue(s2.querySelector('#item4').classList.contains('iron-selected'));
      });

    });

    suite('content with dom-repeat', function() {

      test('supports repeated children', function(done) {
        t.items = [{name:'item0'}, {name: 'item1'}, {name: 'item2'}, {name: 'item3'}];
        setTimeout(function() {
          // check selected
          assert.equal(s3.selected, 'item0');
          // check selected class
          assert.isTrue(s3.querySelector('#item0').classList.contains('iron-selected'));
          // set selected
          s3.selected = 'item2';
          // check selected class
          assert.isTrue(s3.querySelector('#item2').classList.contains('iron-selected'));
          done();
        });
      });

    });

  </script>

</body>
</html>
