<!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-comment-api</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-comment-api.html">

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

<test-fixture id="basic">
  <template>
    <gr-comment-api></gr-comment-api>
  </template>
</test-fixture>

<script>
  suite('gr-comment-api tests', () => {
    const PARENT = 'PARENT';

    let element;
    let sandbox;

    setup(() => {
      sandbox = sinon.sandbox.create();
      element = fixture('basic');
    });

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

    test('loads logged-out', () => {
      const changeNum = 1234;

      sandbox.stub(element.$.restAPI, 'getLoggedIn')
          .returns(Promise.resolve(false));
      sandbox.stub(element.$.restAPI, 'getDiffComments')
          .returns(Promise.resolve({
            'foo.c': [{id: '123', message: 'foo bar', in_reply_to: '321'}],
          }));
      sandbox.stub(element.$.restAPI, 'getDiffRobotComments')
          .returns(Promise.resolve({'foo.c': [{id: '321', message: 'done'}]}));
      sandbox.stub(element.$.restAPI, 'getDiffDrafts')
          .returns(Promise.resolve({}));

      return element.loadAll(changeNum).then(() => {
        assert.isTrue(element.$.restAPI.getDiffComments.calledWithExactly(
            changeNum));
        assert.isTrue(element.$.restAPI.getDiffRobotComments.calledWithExactly(
            changeNum));
        assert.isTrue(element.$.restAPI.getDiffDrafts.calledWithExactly(
            changeNum));
        assert.isOk(element._changeComments._comments);
        assert.isOk(element._changeComments._robotComments);
        assert.deepEqual(element._changeComments._drafts, {});
      });
    });

    test('loads logged-in', () => {
      const changeNum = 1234;

      sandbox.stub(element.$.restAPI, 'getLoggedIn')
          .returns(Promise.resolve(true));
      sandbox.stub(element.$.restAPI, 'getDiffComments')
          .returns(Promise.resolve({
            'foo.c': [{id: '123', message: 'foo bar', in_reply_to: '321'}],
          }));
      sandbox.stub(element.$.restAPI, 'getDiffRobotComments')
          .returns(Promise.resolve({'foo.c': [{id: '321', message: 'done'}]}));
      sandbox.stub(element.$.restAPI, 'getDiffDrafts')
          .returns(Promise.resolve({'foo.c': [{id: '555', message: 'ack'}]}));

      return element.loadAll(changeNum).then(() => {
        assert.isTrue(element.$.restAPI.getDiffComments.calledWithExactly(
            changeNum));
        assert.isTrue(element.$.restAPI.getDiffRobotComments.calledWithExactly(
            changeNum));
        assert.isTrue(element.$.restAPI.getDiffDrafts.calledWithExactly(
            changeNum));
        assert.isOk(element._changeComments._comments);
        assert.isOk(element._changeComments._robotComments);
        assert.notDeepEqual(element._changeComments._drafts, {});
      });
    });

    suite('reloadDrafts', () => {
      let commentStub;
      let robotCommentStub;
      let draftStub;
      setup(() => {
        commentStub = sandbox.stub(element.$.restAPI, 'getDiffComments')
          .returns(Promise.resolve({}));
        robotCommentStub = sandbox.stub(element.$.restAPI,
            'getDiffRobotComments').returns(Promise.resolve({}));
        draftStub = sandbox.stub(element.$.restAPI, 'getDiffDrafts')
            .returns(Promise.resolve({}));
      });

      test('without loadAll first', done => {
        assert.isNotOk(element._changeComments);
        sandbox.spy(element, 'loadAll');
        element.reloadDrafts().then(() => {
          assert.isTrue(element.loadAll.called);
          assert.isOk(element._changeComments);
          assert.equal(commentStub.callCount, 1);
          assert.equal(robotCommentStub.callCount, 1);
          assert.equal(draftStub.callCount, 1);
          done();
        });
      });

      test('with loadAll first', done => {
        assert.isNotOk(element._changeComments);
        element.loadAll().then(() => {
          assert.isOk(element._changeComments);
          assert.equal(commentStub.callCount, 1);
          assert.equal(robotCommentStub.callCount, 1);
          assert.equal(draftStub.callCount, 1);
          return element.reloadDrafts();
        }).then(() => {
          assert.isOk(element._changeComments);
          assert.equal(commentStub.callCount, 1);
          assert.equal(robotCommentStub.callCount, 1);
          assert.equal(draftStub.callCount, 2);
          done();
        });
      });
    });

    suite('_changeComment methods', () => {
      setup(done => {
        const changeNum = 1234;
        stub('gr-rest-api-interface', {
          getDiffComments() { return Promise.resolve({}); },
          getDiffRobotComments() { return Promise.resolve({}); },
          getDiffDrafts() { return Promise.resolve({}); },
        });
        element.loadAll(changeNum).then(() => {
          done();
        });
      });

      test('_isInBaseOfPatchRange', () => {
        const comment = {patch_set: 1};
        const patchRange = {basePatchNum: 1, patchNum: 2};
        assert.isTrue(element._changeComments._isInBaseOfPatchRange(comment,
            patchRange));

        patchRange.basePatchNum = PARENT;
        assert.isFalse(element._changeComments._isInBaseOfPatchRange(comment,
            patchRange));

        comment.side = PARENT;
        assert.isFalse(element._changeComments._isInBaseOfPatchRange(comment,
            patchRange));

        comment.patch_set = 2;
        assert.isTrue(element._changeComments._isInBaseOfPatchRange(comment,
            patchRange));

        patchRange.basePatchNum = -2;
        comment.side = PARENT;
        comment.parent = 1;
        assert.isFalse(element._changeComments._isInBaseOfPatchRange(comment,
            patchRange));

        comment.parent = 2;
        assert.isTrue(element._changeComments._isInBaseOfPatchRange(comment,
            patchRange));
      });

      test('_isInRevisionOfPatchRange', () => {
        const comment = {patch_set: 123};
        const patchRange = {basePatchNum: 122, patchNum: 124};
        assert.isFalse(element._changeComments._isInRevisionOfPatchRange(
            comment, patchRange));

        patchRange.patchNum = 123;
        assert.isTrue(element._changeComments._isInRevisionOfPatchRange(
            comment, patchRange));

        comment.side = PARENT;
        assert.isFalse(element._changeComments._isInRevisionOfPatchRange(
            comment, patchRange));
      });

      test('_isInPatchRange', () => {
        const patchRange1 = {basePatchNum: 122, patchNum: 124};
        const patchRange2 = {basePatchNum: 123, patchNum: 125};
        const patchRange3 = {basePatchNum: 124, patchNum: 125};

        const isInBasePatchStub = sandbox.stub(element._changeComments,
            '_isInBaseOfPatchRange');
        const isInRevisionPatchStub = sandbox.stub(element._changeComments,
            '_isInRevisionOfPatchRange');

        isInBasePatchStub.withArgs({}, patchRange1).returns(true);
        isInBasePatchStub.withArgs({}, patchRange2).returns(false);
        isInBasePatchStub.withArgs({}, patchRange3).returns(false);

        isInRevisionPatchStub.withArgs({}, patchRange1).returns(false);
        isInRevisionPatchStub.withArgs({}, patchRange2).returns(true);
        isInRevisionPatchStub.withArgs({}, patchRange3).returns(false);

        assert.isTrue(element._changeComments._isInPatchRange({}, patchRange1));
        assert.isTrue(element._changeComments._isInPatchRange({}, patchRange2));
        assert.isFalse(element._changeComments._isInPatchRange({},
            patchRange3));
      });

      suite('comment ranges and paths', () => {
        function makeTime(mins) {
          return `2013-02-26 15:0${mins}:43.986000000`;
        }

        setup(() => {
          element._changeComments._drafts = {
            'file/one': [
              {
                id: 11,
                patch_set: 2,
                side: PARENT,
                line: 1,
                updated: makeTime(3),
              },
              {
                id: 12,
                in_reply_to: 2,
                patch_set: 2,
                line: 1,
                updated: makeTime(3),
              },
            ],
          };
          element._changeComments._robotComments = {
            'file/one': [
              {
                id: 1,
                patch_set: 2,
                side: PARENT,
                line: 1,
                updated: makeTime(1),
                range: {
                  start_line: 1,
                  start_character: 2,
                  end_line: 2,
                  end_character: 2,
                },
              }, {
                id: 2,
                in_reply_to: 4,
                patch_set: 2,
                unresolved: true,
                line: 1,
                updated: makeTime(2),
              },
            ],
          };
          element._changeComments._comments = {
            'file/one': [
              {id: 3, patch_set: 2, side: PARENT, line: 2, updated: makeTime(1)},
              {id: 4, patch_set: 2, line: 1, updated: makeTime(1)},
            ],
            'file/two': [
              {id: 5, patch_set: 2, line: 2, updated: makeTime(1)},
              {id: 6, patch_set: 3, line: 2, updated: makeTime(1)},
            ],
            'file/three': [
              {
                id: 7,
                patch_set: 2,
                side: PARENT,
                unresolved: true,
                line: 1,
                updated: makeTime(1),
              },
              {id: 8, patch_set: 3, line: 1, updated: makeTime(1)},
            ],
            'file/four': [
              {id: 9, patch_set: 5, side: PARENT, line: 1, updated: makeTime(1)},
              {id: 10, patch_set: 5, line: 1, updated: makeTime(1)},
            ],
          };
        });

        test('getPaths', () => {
          const patchRange = {basePatchNum: 1, patchNum: 4};
          let paths = element._changeComments.getPaths(patchRange);
          assert.equal(Object.keys(paths).length, 0);

          patchRange.basePatchNum = PARENT;
          patchRange.patchNum = 3;
          paths = element._changeComments.getPaths(patchRange);
          assert.notProperty(paths, 'file/one');
          assert.property(paths, 'file/two');
          assert.property(paths, 'file/three');
          assert.notProperty(paths, 'file/four');

          patchRange.patchNum = 2;
          paths = element._changeComments.getPaths(patchRange);
          assert.property(paths, 'file/one');
          assert.property(paths, 'file/two');
          assert.property(paths, 'file/three');
          assert.notProperty(paths, 'file/four');

          paths = element._changeComments.getPaths();
          assert.property(paths, 'file/one');
          assert.property(paths, 'file/two');
          assert.property(paths, 'file/three');
          assert.property(paths, 'file/four');
        });

        test('getCommentsBySideForPath', () => {
          const patchRange = {basePatchNum: 1, patchNum: 3};
          let path = 'file/one';
          let comments = element._changeComments.getCommentsBySideForPath(path,
              patchRange);
          assert.equal(comments.meta.changeNum, 1234);
          assert.equal(comments.left.length, 0);
          assert.equal(comments.right.length, 0);

          path = 'file/two';
          comments = element._changeComments.getCommentsBySideForPath(path,
              patchRange);
          assert.equal(comments.left.length, 0);
          assert.equal(comments.right.length, 1);

          patchRange.basePatchNum = 2;
          comments = element._changeComments.getCommentsBySideForPath(path,
              patchRange);
          assert.equal(comments.left.length, 1);
          assert.equal(comments.right.length, 1);

          patchRange.basePatchNum = PARENT;
          path = 'file/three';
          comments = element._changeComments.getCommentsBySideForPath(path,
              patchRange);
          assert.equal(comments.left.length, 0);
          assert.equal(comments.right.length, 1);
        });

        test('getAllCommentsForPath', () => {
          let path = 'file/one';
          let comments = element._changeComments.getAllCommentsForPath(path);
          assert.deepEqual(comments.length, 4);
          path = 'file/two';
          comments = element._changeComments.getAllCommentsForPath(path, 2);
          assert.deepEqual(comments.length, 1);
        });

        test('getAllDraftsForPath', () => {
          const path = 'file/one';
          const drafts = element._changeComments.getAllDraftsForPath(path);
          assert.deepEqual(drafts.length, 2);
        });

        test('computeUnresolvedNum', () => {
          assert.equal(element._changeComments
              .computeUnresolvedNum(2, 'file/one'), 0);
          assert.equal(element._changeComments
              .computeUnresolvedNum(1, 'file/one'), 0);
          assert.equal(element._changeComments
              .computeUnresolvedNum(2, 'file/three'), 1);
        });

        test('computeUnresolvedNum w/ non-linear thread', () => {
          element._changeComments._drafts = {};
          element._changeComments._robotComments = {};
          element._changeComments._comments = {
            path: [{
              id: '9c6ba3c6_28b7d467',
              patch_set: 1,
              updated: '2018-02-28 14:41:13.000000000',
              unresolved: true,
            }, {
              id: '3df7b331_0bead405',
              patch_set: 1,
              in_reply_to: '1c346623_ab85d14a',
              updated: '2018-02-28 23:07:55.000000000',
              unresolved: false,
            }, {
              id: '6153dce6_69958d1e',
              patch_set: 1,
              in_reply_to: '9c6ba3c6_28b7d467',
              updated: '2018-02-28 17:11:31.000000000',
              unresolved: true,
            }, {
              id: '1c346623_ab85d14a',
              patch_set: 1,
              in_reply_to: '9c6ba3c6_28b7d467',
              updated: '2018-02-28 23:01:39.000000000',
              unresolved: false,
            }],
          };
          assert.equal(
              element._changeComments.computeUnresolvedNum(1, 'path'), 0);
        });

        test('computeCommentCount', () => {
          assert.equal(element._changeComments
              .computeCommentCount(2, 'file/one'), 4);
          assert.equal(element._changeComments
              .computeCommentCount(1, 'file/one'), 0);
          assert.equal(element._changeComments
              .computeCommentCount(2, 'file/three'), 1);
        });

        test('computeDraftCount', () => {
          assert.equal(element._changeComments
              .computeDraftCount(2, 'file/one'), 2);
          assert.equal(element._changeComments
              .computeDraftCount(1, 'file/one'), 0);
          assert.equal(element._changeComments
              .computeDraftCount(2, 'file/three'), 0);
        });

        test('getAllPublishedComments', () => {
          let publishedComments = element._changeComments
              .getAllPublishedComments();
          assert.equal(Object.keys(publishedComments).length, 4);
          assert.equal(Object.keys(publishedComments[['file/one']]).length, 4);
          assert.equal(Object.keys(publishedComments[['file/two']]).length, 2);
          publishedComments = element._changeComments
              .getAllPublishedComments(2);
          assert.equal(Object.keys(publishedComments[['file/one']]).length, 4);
          assert.equal(Object.keys(publishedComments[['file/two']]).length, 1);
        });

        test('getAllComments', () => {
          let comments = element._changeComments.getAllComments();
          assert.equal(Object.keys(comments).length, 4);
          assert.equal(Object.keys(comments[['file/one']]).length, 4);
          assert.equal(Object.keys(comments[['file/two']]).length, 2);
          comments = element._changeComments.getAllComments(false, 2);
          assert.equal(Object.keys(comments).length, 4);
          assert.equal(Object.keys(comments[['file/one']]).length, 4);
          assert.equal(Object.keys(comments[['file/two']]).length, 1);
          // Include drafts
          comments = element._changeComments.getAllComments(true);
          assert.equal(Object.keys(comments).length, 4);
          assert.equal(Object.keys(comments[['file/one']]).length, 6);
          assert.equal(Object.keys(comments[['file/two']]).length, 2);
          comments = element._changeComments.getAllComments(true, 2);
          assert.equal(Object.keys(comments).length, 4);
          assert.equal(Object.keys(comments[['file/one']]).length, 6);
          assert.equal(Object.keys(comments[['file/two']]).length, 1);
        });

        test('computeAllThreads', () => {
          const expectedThreads = [
            {
              comments: [
                {
                  id: 5,
                  patch_set: 2,
                  line: 2,
                  __path: 'file/two',
                  updated: '2013-02-26 15:01:43.986000000',
                },
              ],
              patchNum: 2,
              path: 'file/two',
              line: 2,
              rootId: 5,
            }, {
              comments: [
                {
                  id: 3,
                  patch_set: 2,
                  side: 'PARENT',
                  line: 2,
                  __path: 'file/one',
                  updated: '2013-02-26 15:01:43.986000000',
                },
              ],
              commentSide: 'PARENT',
              patchNum: 2,
              path: 'file/one',
              line: 2,
              rootId: 3,
            }, {
              comments: [
                {
                  id: 1,
                  patch_set: 2,
                  side: 'PARENT',
                  line: 1,
                  updated: '2013-02-26 15:01:43.986000000',
                  range: {
                    start_line: 1,
                    start_character: 2,
                    end_line: 2,
                    end_character: 2,
                  },
                  __path: 'file/one',
                },
              ],
              commentSide: 'PARENT',
              patchNum: 2,
              path: 'file/one',
              line: 1,
              rootId: 1,
            }, {
              comments: [
                {
                  id: 9,
                  patch_set: 5,
                  side: 'PARENT',
                  line: 1,
                  __path: 'file/four',
                  updated: '2013-02-26 15:01:43.986000000',
                },
              ],
              commentSide: 'PARENT',
              patchNum: 5,
              path: 'file/four',
              line: 1,
              rootId: 9,
            }, {
              comments: [
                {
                  id: 8,
                  patch_set: 3,
                  line: 1,
                  __path: 'file/three',
                  updated: '2013-02-26 15:01:43.986000000',
                },
              ],
              patchNum: 3,
              path: 'file/three',
              line: 1,
              rootId: 8,
            }, {
              comments: [
                {
                  id: 7,
                  patch_set: 2,
                  side: 'PARENT',
                  unresolved: true,
                  line: 1,
                  __path: 'file/three',
                  updated: '2013-02-26 15:01:43.986000000',
                },
              ],
              commentSide: 'PARENT',
              patchNum: 2,
              path: 'file/three',
              line: 1,
              rootId: 7,
            }, {
              comments: [
                {
                  id: 4,
                  patch_set: 2,
                  line: 1,
                  __path: 'file/one',
                  updated: '2013-02-26 15:01:43.986000000',
                },
                {
                  id: 2,
                  in_reply_to: 4,
                  patch_set: 2,
                  unresolved: true,
                  line: 1,
                  __path: 'file/one',
                  updated: '2013-02-26 15:02:43.986000000',
                },
                {
                  id: 12,
                  in_reply_to: 2,
                  patch_set: 2,
                  line: 1,
                  __path: 'file/one',
                  __draft: true,
                  updated: '2013-02-26 15:03:43.986000000',
                },
              ],
              patchNum: 2,
              path: 'file/one',
              line: 1,
              rootId: 4,
            }, {
              comments: [
                {
                  id: 6,
                  patch_set: 3,
                  line: 2,
                  __path: 'file/two',
                  updated: '2013-02-26 15:01:43.986000000',
                },
              ],
              patchNum: 3,
              path: 'file/two',
              line: 2,
              rootId: 6,
            }, {
              comments: [
                {
                  id: 10,
                  patch_set: 5,
                  line: 1,
                  __path: 'file/four',
                  updated: '2013-02-26 15:01:43.986000000',
                },
              ],
              rootId: 10,
              patchNum: 5,
              path: 'file/four',
              line: 1,
            }, {
              comments: [
                {
                  id: 11,
                  patch_set: 2,
                  side: 'PARENT',
                  line: 1,
                  __path: 'file/one',
                  __draft: true,
                  updated: '2013-02-26 15:03:43.986000000',
                },
              ],
              rootId: 11,
              commentSide: 'PARENT',
              patchNum: 2,
              path: 'file/one',
              line: 1,
            },
          ];
          const threads = element._changeComments.getAllThreadsForChange();
          assert.deepEqual(threads, expectedThreads);
        });

        test('getCommentsForThreadGroup', () => {
          let expectedComments = [
            {
              __path: 'file/one',
              id: 4,
              patch_set: 2,
              line: 1,
              updated: '2013-02-26 15:01:43.986000000',
            },
            {
              __path: 'file/one',
              id: 2,
              in_reply_to: 4,
              patch_set: 2,
              unresolved: true,
              line: 1,
              updated: '2013-02-26 15:02:43.986000000',
            },
            {
              __path: 'file/one',
              __draft: true,
              id: 12,
              in_reply_to: 2,
              patch_set: 2,
              line: 1,
              updated: '2013-02-26 15:03:43.986000000',
            },
          ];
          assert.deepEqual(element._changeComments.getCommentsForThread(4),
              expectedComments);

          expectedComments = [{
            id: 11,
            patch_set: 2,
            side: 'PARENT',
            line: 1,
            __path: 'file/one',
            __draft: true,
            updated: '2013-02-26 15:03:43.986000000',
          }];

          assert.deepEqual(element._changeComments.getCommentsForThread(11),
              expectedComments);

          assert.deepEqual(element._changeComments.getCommentsForThread(1000),
              null);
        });
      });
    });
  });
</script>