<!DOCTYPE html>
<!--
@license
Copyright (C) 2018 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-documentation-search</title>

<script src="/node_modules/@webcomponents/webcomponentsjs/custom-elements-es5-adapter.js"></script>

<script src="/node_modules/page/page.js"></script>
<script src="/node_modules/@webcomponents/webcomponentsjs/webcomponents-lite.js"></script>
<script src="/components/wct-browser-legacy/browser.js"></script>

<test-fixture id="basic">
  <template>
    <gr-documentation-search></gr-documentation-search>
  </template>
</test-fixture>

<script type="module">
import '../../../test/common-test-setup.js';
import './gr-documentation-search.js';
let counter;
const documentationGenerator = () => {
  return {
    title: `Gerrit Code Review - REST API Developers Notes${++counter}`,
    url: 'Documentation/dev-rest-api.html',
  };
};

suite('gr-documentation-search tests', () => {
  let element;
  let documentationSearches;
  let sandbox;
  let value;

  setup(() => {
    sandbox = sinon.sandbox.create();
    sandbox.stub(page, 'show');
    element = fixture('basic');
    counter = 0;
  });

  teardown(() => {
    sandbox.restore();
  });

  suite('list with searches for documentation', () => {
    setup(done => {
      documentationSearches = _.times(26, documentationGenerator);
      stub('gr-rest-api-interface', {
        getDocumentationSearches() {
          return Promise.resolve(documentationSearches);
        },
      });
      element._paramsChanged(value).then(() => { flush(done); });
    });

    test('test for test repo in the list', done => {
      flush(() => {
        assert.equal(element._documentationSearches[0].title,
            'Gerrit Code Review - REST API Developers Notes1');
        assert.equal(element._documentationSearches[0].url,
            'Documentation/dev-rest-api.html');
        done();
      });
    });
  });

  suite('filter', () => {
    setup(() => {
      documentationSearches = _.times(25, documentationGenerator);
      _.times(1, documentationSearches);
    });

    test('_paramsChanged', done => {
      sandbox.stub(
          element.$.restAPI,
          'getDocumentationSearches',
          () => Promise.resolve(documentationSearches));
      const value = {
        filter: 'test',
      };
      element._paramsChanged(value).then(() => {
        assert.isTrue(element.$.restAPI.getDocumentationSearches.lastCall
            .calledWithExactly('test'));
        done();
      });
    });
  });

  suite('loading', () => {
    test('correct contents are displayed', () => {
      assert.isTrue(element._loading);
      assert.equal(element.computeLoadingClass(element._loading), 'loading');
      assert.equal(getComputedStyle(element.$.loading).display, 'block');

      element._loading = false;
      element._repos = _.times(25, documentationGenerator);

      flushAsynchronousOperations();
      assert.equal(element.computeLoadingClass(element._loading), '');
      assert.equal(getComputedStyle(element.$.loading).display, 'none');
    });
  });
});
</script>
