web/gr-files_test.ts

/**
 * @license
 * Copyright (C) 2024 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.
 */

import {assert} from '@open-wc/testing';

import {
  computeApprovalAndInfo,
  getChangeAccounts,
  getFileOwnership,
  shouldHide,
} from './gr-files';
import {
  FileOwnership,
  FileStatus,
  OwnerOrGroupOwner,
  PatchRange,
  UserRole,
} from './owners-model';
import {
  AccountInfo,
  ApprovalInfo,
  ChangeInfo,
  ChangeStatus,
  DetailedLabelInfo,
  SubmitRequirementResultInfo,
  ReviewerState,
} from '@gerritcodereview/typescript-api/rest-api';
import {FilesOwners, OwnersLabels} from './owners-service';
import {deepEqual} from './utils';
import {getRandom} from './test-utils';

suite('owners status tests', () => {
  const path = 'readme.md';
  const approvedPath = 'db.sql';
  const autoApprovedPath = 'foo.java';
  const filesOwners = {
    files: {[path]: [{name: 'John', id: 1}]},
    files_approved: {[approvedPath]: [{name: 'Merry', id: 2}]},
    files_auto_approved: {[autoApprovedPath]: [{name: 'Merry', id: 2}]},
  } as unknown as FilesOwners;

  suite('shouldHide tests', () => {
    const loggedIn = getRandom(UserRole.CHANGE_OWNER, UserRole.OTHER);

    test('shouldHide - should be `true` when change is not defined', () => {
      const undefinedChange = undefined;
      const definedPatchRange = {} as unknown as PatchRange;
      assert.equal(
        shouldHide(undefinedChange, definedPatchRange, filesOwners, loggedIn),
        true
      );
    });

    test('shouldHide - should be `true` when patch range is not defined', () => {
      const definedChange = {} as unknown as ChangeInfo;
      const undefinedPatchRange = undefined;
      assert.equal(
        shouldHide(definedChange, undefinedPatchRange, filesOwners, loggedIn),
        true
      );
    });

    test('shouldHide - should be `true` when change is abandoned', () => {
      const abandonedChange = {
        status: ChangeStatus.ABANDONED,
      } as unknown as ChangeInfo;
      const definedPatchRange = {} as unknown as PatchRange;
      assert.equal(
        shouldHide(abandonedChange, definedPatchRange, filesOwners, loggedIn),
        true
      );
    });

    test('shouldHide - should be `true` when change is merged', () => {
      const mergedChange = {
        status: ChangeStatus.MERGED,
      } as unknown as ChangeInfo;
      const definedPatchRange = {} as unknown as PatchRange;
      assert.equal(
        shouldHide(mergedChange, definedPatchRange, filesOwners, loggedIn),
        true
      );
    });

    test('shouldHide - should be `true` if not on the latest PS', () => {
      const changeWithPs2 = {
        status: ChangeStatus.NEW,
        revisions: {
          current_rev: {_number: 2},
        },
        current_revision: 'current_rev',
      } as unknown as ChangeInfo;
      const patchRangeOnPs1 = {patchNum: 1} as unknown as PatchRange;
      assert.equal(
        shouldHide(changeWithPs2, patchRangeOnPs1, filesOwners, loggedIn),
        true
      );
    });

    const change = {
      status: ChangeStatus.NEW,
      revisions: {
        current_rev: {_number: 1},
      },
      current_revision: 'current_rev',
    } as unknown as ChangeInfo;
    const patchRange = {patchNum: 1} as unknown as PatchRange;

    test('shouldHide - should be `true` when change has no submit requirements', () => {
      assert.equal(shouldHide(change, patchRange, filesOwners, loggedIn), true);
    });

    test('shouldHide - should be `true` when change has no `Owner-Approval` submit requirements', () => {
      const changeWithDifferentSubmitReqs = {
        ...change,
        submit_requirements: [
          {submittability_expression_result: {expression: 'other'}},
        ] as unknown as SubmitRequirementResultInfo[],
      };
      assert.equal(
        shouldHide(
          changeWithDifferentSubmitReqs,
          patchRange,
          filesOwners,
          loggedIn
        ),
        true
      );
    });

    const submitRequirements = getRandom({
      submit_requirements: [
        {submittability_expression_result: {expression: 'has:approval_owners'}},
        {
          submittability_expression_result: {
            expression: 'rule:owners~OwnersSubmitRequirement',
          },
        },
      ] as unknown as SubmitRequirementResultInfo[],
    });
    const changeWithSubmitRequirementOrRecord = {
      ...change,
      ...submitRequirements,
    };

    test('shouldHide - should be `true` when user is anonymous', () => {
      const anonymous = UserRole.ANONYMOUS;
      assert.equal(
        shouldHide(
          changeWithSubmitRequirementOrRecord,
          patchRange,
          filesOwners,
          anonymous
        ),
        true
      );
    });

    test('shouldHide - should be `true` when files owners are `undefined`', () => {
      const undefinedFilesOwners = getRandom(
        undefined,
        {}
      ) as unknown as FilesOwners;
      assert.equal(
        shouldHide(
          changeWithSubmitRequirementOrRecord,
          patchRange,
          undefinedFilesOwners,
          loggedIn
        ),
        true
      );
    });

    test('shouldHide - should be `false` when change has all files approved', () => {
      const allFilesApproved = {
        approved_files: {[approvedPath]: [{name: 'Merry', id: 2}]},
      } as unknown as FilesOwners;
      assert.equal(
        shouldHide(
          changeWithSubmitRequirementOrRecord,
          patchRange,
          allFilesApproved,
          loggedIn
        ),
        true
      );
    });

    test('shouldHide - should be `false` when change has no files approved', () => {
      const noApprovedFiles = {
        files: {[path]: [{name: 'John', id: 1}]},
      } as unknown as FilesOwners;
      assert.equal(
        shouldHide(
          changeWithSubmitRequirementOrRecord,
          patchRange,
          noApprovedFiles,
          loggedIn
        ),
        false
      );
    });

    test('shouldHide - should be `false` when change has both approved and not approved files', () => {
      assert.equal(
        shouldHide(
          changeWithSubmitRequirementOrRecord,
          patchRange,
          filesOwners,
          loggedIn
        ),
        false
      );
    });

    test('shouldHide - should be `false` when in edit mode', () => {
      const patchRangeWithoutPatchNum = {} as unknown as PatchRange;
      assert.equal(
        shouldHide(change, patchRangeWithoutPatchNum, filesOwners, loggedIn),
        false
      );
    });
  });

  suite('getFileOwnership tests', () => {
    const emptyFilesOwners = {} as unknown as FilesOwners;

    test('getFileOwnership - should be `undefined` when path is `undefined', () => {
      const undefinedPath = undefined;
      assert.equal(
        getFileOwnership(undefinedPath, emptyFilesOwners),
        undefined
      );
    });

    test('getFileOwnership - should be `undefined` when file owners are `undefined', () => {
      const undefinedFileOwners = undefined;
      assert.equal(getFileOwnership(path, undefinedFileOwners), undefined);
    });

    test('getFileOwnership - should return `FileOwnership` with `APPROVED` fileStatus when file is approved', () => {
      assert.equal(
        deepEqual(getFileOwnership(approvedPath, filesOwners), {
          fileStatus: FileStatus.APPROVED,
          owners: [{name: 'Merry', id: 2}],
        } as FileOwnership),
        true
      );
    });

    test('getFileOwnership - should return owners from `files_auto_approved` when file is auto-approved', () => {
      const filesOwnersWithExplicitAndAutoApprovers = {
        files_approved: {
          [approvedPath]: [
            {name: 'Merry', id: 2},
            {name: 'John', id: 1},
          ],
        },
        files_auto_approved: {
          [autoApprovedPath]: [{name: 'Merry', id: 2}],
        },
      } as unknown as FilesOwners;

      assert.equal(
        deepEqual(
          getFileOwnership(
            autoApprovedPath,
            filesOwnersWithExplicitAndAutoApprovers
          ),
          {
            fileStatus: FileStatus.AUTO_APPROVED,
            owners: [{name: 'Merry', id: 2}],
          } as FileOwnership
        ),
        true
      );
    });

    test('getFileOwnership - should return `FileOwnership` with `NOT_OWNED` fileStatus when file has no owner', () => {
      assert.equal(
        deepEqual(getFileOwnership(path, emptyFilesOwners), {
          fileStatus: FileStatus.NOT_OWNED,
        } as FileOwnership),
        true
      );
    });

    test('getFileOwnership - should return `FileOwnership` with `NEEDS_APPROVAL` fileStatus when file has owner', () => {
      const fileOwnersWithPathOwner = {
        files: {[path]: [{name: 'John', id: 1}]},
      } as unknown as FilesOwners;

      assert.equal(
        deepEqual(getFileOwnership(path, fileOwnersWithPathOwner), {
          fileStatus: FileStatus.NEEDS_APPROVAL,
          owners: [{name: 'John', id: 1}],
        } as FileOwnership),
        true
      );
    });
  });

  suite('computeApprovalAndInfo tests', () => {
    const account = 1;
    const fileOwner = {
      owner: {_account_id: account} as unknown as AccountInfo,
    } as unknown as OwnerOrGroupOwner;
    const label = 'Code-Review';
    const crPlus1OwnersVote = {
      [`${account}`]: {[label]: 1},
    } as unknown as OwnersLabels;
    const changeWithLabels = {
      labels: {
        [label]: {
          all: [
            {
              value: 1,
              date: '2024-10-22 17:26:21.000000000',
              permitted_voting_range: {
                min: -2,
                max: 2,
              },
              _account_id: account,
            },
          ],
          values: {
            '-2': 'This shall not be submitted',
            '-1': 'I would prefer this is not submitted as is',
            ' 0': 'No score',
            '+1': 'Looks good to me, but someone else must approve',
            '+2': 'Looks good to me, approved',
          },
          description: '',
          default_value: 0,
        },
      },
    } as unknown as ChangeInfo;

    test('computeApprovalAndInfo - should be `undefined` when change is `undefined', () => {
      const undefinedChange = undefined;
      assert.equal(
        computeApprovalAndInfo(fileOwner, crPlus1OwnersVote, undefinedChange),
        undefined
      );
    });

    test('computeApprovalAndInfo - should be `undefined` when there is no owners vote', () => {
      const emptyOwnersVote = {};
      assert.equal(
        computeApprovalAndInfo(fileOwner, emptyOwnersVote, changeWithLabels),
        undefined
      );
    });

    test('computeApprovalAndInfo - should be `undefined` for default owners vote', () => {
      const defaultOwnersVote = {[label]: 0} as unknown as OwnersLabels;
      assert.equal(
        computeApprovalAndInfo(fileOwner, defaultOwnersVote, changeWithLabels),
        undefined
      );
    });

    test('computeApprovalAndInfo - should be computed for CR+1 owners vote', () => {
      const expectedApproval = {
        value: 1,
        date: '2024-10-22 17:26:21.000000000',
        permitted_voting_range: {
          min: -2,
          max: 2,
        },
        _account_id: account,
      } as unknown as ApprovalInfo;
      const expectedInfo = {
        all: [expectedApproval],
        values: {
          '-2': 'This shall not be submitted',
          '-1': 'I would prefer this is not submitted as is',
          ' 0': 'No score',
          '+1': 'Looks good to me, but someone else must approve',
          '+2': 'Looks good to me, approved',
        },
        description: '',
        default_value: 0,
      } as unknown as DetailedLabelInfo;

      assert.equal(
        deepEqual(
          computeApprovalAndInfo(
            fileOwner,
            crPlus1OwnersVote,
            changeWithLabels
          ),
          [expectedApproval, expectedInfo]
        ),
        true
      );
    });
  });

  suite('getChangeAccounts tests', () => {
    test('getChangeAccounts - should return empty map when change is `undefined', () => {
      const undefinedChange = undefined;
      const accounts = getChangeAccounts(undefinedChange);
      assert.equal(accounts.byAccountId.size, 0);
      assert.equal(accounts.byEmailWithoutDomain.size, 0);
      assert.equal(accounts.byFullName.size, 0);
    });

    test('getChangeAccounts - should return map with owner when change has only owner and empty reviewers defined', () => {
      const owner = account(1);
      const changeWithOwner = {
        owner,
        reviewers: {},
      } as unknown as ChangeInfo;
      const accounts = getChangeAccounts(changeWithOwner);
      assert.equal(
        deepEqual(accounts.byAccountId, new Map([[1, owner]])),
        true
      );
      assert.equal(
        deepEqual(accounts.byEmailWithoutDomain, new Map([['1_email', owner]])),
        true
      );
      assert.equal(
        deepEqual(accounts.byFullName, new Map([['1_name', owner]])),
        true
      );
    });

    test('getChangeAccounts - should return map with owner, submitter and reviewers', () => {
      const owner = account(1);
      const submitter = account(2);
      const reviewer = account(3);
      const ccReviewer = account(4);
      const change = {
        owner,
        submitter,
        reviewers: {
          [ReviewerState.REVIEWER]: [reviewer],
          [ReviewerState.CC]: [ccReviewer],
        },
      } as unknown as ChangeInfo;
      const accounts = getChangeAccounts(change);
      assert.equal(
        deepEqual(
          accounts.byAccountId,
          new Map([
            [1, owner],
            [2, submitter],
            [3, reviewer],
            [4, ccReviewer],
          ])
        ),
        true
      );
      assert.equal(
        deepEqual(
          accounts.byEmailWithoutDomain,
          new Map([
            ['1_email', owner],
            ['2_email', submitter],
            ['3_email', reviewer],
            ['4_email', ccReviewer],
          ])
        ),
        true
      );
      assert.equal(
        deepEqual(
          accounts.byFullName,
          new Map([
            ['1_name', owner],
            ['2_name', submitter],
            ['3_name', reviewer],
            ['4_name', ccReviewer],
          ])
        ),
        true
      );
    });
  });
});

function account(id: number) {
  return {
    _account_id: id,
    email: `${id}_email@example.com`,
    name: `${id}_name`,
  } as unknown as AccountInfo;
}