<!DOCTYPE html>
<!--
Copyright (C) 2015 The Android Open Source Project

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->

<meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">
<title>gr-linked-text</title>

<script src="../bower_components/webcomponentsjs/webcomponents-lite.min.js"></script>
<script src="../bower_components/web-component-tester/browser.js"></script>
<script src="../scripts/util.js"></script>

<link rel="import" href="../elements/gr-linked-text.html">

<test-fixture id="basic">
  <template>
    <gr-linked-text>
      <div id="output"></div>
    </gr-linked-text>
  </template>
</test-fixture>

<script>
  suite('gr-linked-text tests', function() {
    var element;

    setup(function() {
      element = fixture('basic');
      element.config = {
        ph: {
          match: '([Bb]ug|[Ii]ssue)\\s*#?(\\d+)',
          link: 'https://code.google.com/p/gerrit/issues/detail?id=$2'
        },
        changeid: {
          match: '(I[0-9a-f]{8,40})',
          link: '#/q/$1'
        },
        googlesearch: {
          match: 'google:(.+)',
          link: 'https://bing.com/search?q=$1',  // html should supercede link.
          html: '<a href="https://google.com/search?q=$1">$1</a>',
        },
        hashedhtml: {
          match: 'hash:(.+)',
          html: '<a href="#/awesomesauce">$1</a>',
        },
        disabledconfig: {
          match: 'foo:(.+)',
          link: 'https://google.com/search?q=$1',
          enabled: false,
        },
      };
    });

    test('URL pattern was parsed and linked.', function() {
      // Reguar inline link.
      var url = 'https://code.google.com/p/gerrit/issues/detail?id=3650';
      element.content = url;
      var linkEl = element.$.output.childNodes[0];
      assert.equal(linkEl.target, '_blank');
      assert.equal(linkEl.href, url);
      assert.equal(linkEl.textContent, url);
    });

    test('Bug pattern was parsed and linked', function() {
      // "Issue/Bug" pattern.
      element.content = 'Issue 3650';

      var linkEl = element.$.output.childNodes[0];
      var url = 'https://code.google.com/p/gerrit/issues/detail?id=3650';
      assert.equal(linkEl.target, '_blank');
      assert.equal(linkEl.href, url);
      assert.equal(linkEl.textContent, 'Issue 3650');

      element.content = 'Bug 3650';
      linkEl = element.$.output.childNodes[0];
      assert.equal(linkEl.target, '_blank');
      assert.equal(linkEl.href, url);
      assert.equal(linkEl.textContent, 'Bug 3650');
    });

    test('Change-Id pattern was parsed and linked', function() {
      // "Change-Id:" pattern.
      var changeID = 'I11d6a37f5e9b5df0486f6c922d8836dfa780e03e'
      var prefix = 'Change-Id: ';
      element.content = prefix + changeID;

      var textNode = element.$.output.childNodes[0];
      var linkEl = element.$.output.childNodes[1];
      assert.equal(textNode.textContent, prefix);
      var url = '/q/' + changeID;
      assert.equal(linkEl.target, '_blank');
      // Since url is a path, the host is added automatically.
      assert.isTrue(linkEl.href.endsWith(url));
      assert.equal(linkEl.textContent, changeID);
    });

    test('Multiple matches', function() {
      element.content = 'Issue 3650\nIssue 3450';
      var linkEl1 = element.$.output.childNodes[0];
      var newlineNode = element.$.output.childNodes[1];
      var linkEl2 = element.$.output.childNodes[2];

      assert.equal(linkEl1.target, '_blank');
      assert.equal(linkEl1.href,
          'https://code.google.com/p/gerrit/issues/detail?id=3650');
      assert.equal(linkEl1.textContent, 'Issue 3650');

      assert.equal(linkEl2.target, '_blank');
      assert.equal(linkEl2.href,
          'https://code.google.com/p/gerrit/issues/detail?id=3450');
      assert.equal(linkEl2.textContent, 'Issue 3450');
    });

    test('html field in link config', function() {
      element.content = 'google:do a barrel roll';
      var linkEl = element.$.output.childNodes[0];
      assert.equal(linkEl.href,
          'https://google.com/search?q=do%20a%20barrel%20roll');
      assert.equal(linkEl.textContent, 'do a barrel roll');
    });

    test('removing hash from links', function() {
      element.content = 'hash:foo';
      var linkEl = element.$.output.childNodes[0];
      assert.isTrue(linkEl.href.endsWith('/awesomesauce'));
      assert.equal(linkEl.textContent, 'foo');
    });

    test('disabled config', function() {
      element.content = 'foo:baz';
      assert.equal(element.$.output.innerHTML, 'foo:baz');
    });

  });
</script>
