<!DOCTYPE html>
<!--
Copyright (C) 2017 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-download-commands</title>

<script src="../../../bower_components/webcomponentsjs/webcomponents-lite.min.js"></script>
<script src="../../../bower_components/web-component-tester/browser.js"></script>
<link rel="import" href="../../../test/common-test-setup.html"/>
<link rel="import" href="gr-download-commands.html">

<script>void(0);</script>

<test-fixture id="basic">
  <template>
    <gr-download-commands></gr-download-commands>
  </template>
</test-fixture>

<script>
  suite('gr-download-commands', () => {
    let element;
    let sandbox;
    const SCHEMES = ['http', 'repo', 'ssh'];
    const COMMANDS = [{
      title: 'Checkout',
      command: `git fetch http://andybons@localhost:8080/a/test-project
          refs/changes/05/5/1 && git checkout FETCH_HEAD`,
    }, {
      title: 'Cherry Pick',
      command: `git fetch http://andybons@localhost:8080/a/test-project
          refs/changes/05/5/1 && git cherry-pick FETCH_HEAD`,
    }, {
      title: 'Format Patch',
      command: `git fetch http://andybons@localhost:8080/a/test-project
          refs/changes/05/5/1 && git format-patch -1 --stdout FETCH_HEAD`,
    }, {
      title: 'Pull',
      command: `git pull http://andybons@localhost:8080/a/test-project
          refs/changes/05/5/1`,
    }];
    const SELECTED_SCHEME = 'http';

    setup(() => {
      sandbox = sinon.sandbox.create();
    });

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

    suite('unauthenticated', () => {
      setup(() => {
        element = fixture('basic');
        element.schemes = SCHEMES;
        element.commands = COMMANDS;
        element.selectedScheme = SELECTED_SCHEME;
        flushAsynchronousOperations();
      });

      test('focusOnCopy', () => {
        const focusStub = sandbox.stub(element.$$('gr-copy-clipboard'),
            'focusOnCopy');
        element.focusOnCopy();
        assert.isTrue(focusStub.called);
      });

      test('element visibility', () => {
        assert.isFalse(element.$$('ul').hasAttribute('hidden'));
        assert.isFalse(element.$$('.commands').hasAttribute('hidden'));

        element.schemes = [];
        assert.isTrue(element.$$('ul').hasAttribute('hidden'));
        assert.isTrue(element.$$('.commands').hasAttribute('hidden'));
      });

      test('tab selection', () => {
        flushAsynchronousOperations();
        let el = element.$$('[data-scheme="http"]').parentElement;
        assert.isTrue(el.hasAttribute('selected'));
        for (const scheme of ['repo', 'ssh']) {
          const el = element.$$('[data-scheme="' + scheme + '"]').parentElement;
          assert.isFalse(el.hasAttribute('selected'));
        }

        MockInteractions.tap(element.$$('[data-scheme="ssh"]'));
        el = element.$$('[data-scheme="ssh"]').parentElement;
        assert.isTrue(el.hasAttribute('selected'));
        for (const scheme of ['http', 'repo']) {
          const el = element.$$('[data-scheme="' + scheme + '"]').parentElement;
          assert.isFalse(el.hasAttribute('selected'));
        }
      });

      test('loads scheme from preferences', done => {
        stub('gr-rest-api-interface', {
          getPreferences() {
            return Promise.resolve({download_scheme: 'repo'});
          },
        });
        element._loggedIn = true;
        assert.isTrue(element.$.restAPI.getPreferences.called);
        element.$.restAPI.getPreferences.lastCall.returnValue.then(() => {
          assert.equal(element.selectedScheme, 'repo');
          done();
        });
      });

      test('normalize scheme from preferences', done => {
        stub('gr-rest-api-interface', {
          getPreferences() {
            return Promise.resolve({download_scheme: 'REPO'});
          },
        });
        element._loggedIn = true;
        element.$.restAPI.getPreferences.lastCall.returnValue.then(() => {
          assert.equal(element.selectedScheme, 'repo');
          done();
        });
      });

      test('saves scheme to preferences', () => {
        element._loggedIn = true;
        const savePrefsStub = sinon.stub(element.$.restAPI, 'savePreferences',
            () => { return Promise.resolve(); });

        flushAsynchronousOperations();

        const firstSchemeButton = element.$$('li gr-button[data-scheme]');

        MockInteractions.tap(firstSchemeButton);

        assert.isTrue(savePrefsStub.called);
        assert.equal(savePrefsStub.lastCall.args[0].download_scheme,
            firstSchemeButton.getAttribute('data-scheme'));
      });
    });
  });
</script>
