web/gr-owned-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 {
  AccountId,
  AccountInfo,
  ChangeInfo,
  ChangeStatus,
  CommitId,
  RevisionInfo,
  EDIT,
  SubmitRequirementResultInfo,
} from '@gerritcodereview/typescript-api/rest-api';
import {
  FileStatus,
  ownedFiles,
  OwnedFilesInfo,
  shouldHide,
} from './gr-owned-files';
import {FilesOwners, GroupOwner, Owner} from './owners-service';
import {deepEqual} from './utils';
import {User, UserRole} from './owners-model';
import {getRandom} from './test-utils';

suite('owned files tests', () => {
  suite('ownedFiles tests', () => {
    const ownerAccountId = 1;
    const owner = account(ownerAccountId);

    const ownedFile = 'README.md';
    const ownedApprovedFile = 'db.sql';
    const files = {
      [ownedFile]: [fileOwner(1)],
      'some.text': [fileOwner(6)],
    };
    const files_approved = {
      [ownedApprovedFile]: [fileOwner(1)],
    };
    const filesOwners = {
      files,
      files_approved,
    } as unknown as FilesOwners;
    const emptyOwnerFilesInfo = {
      ownedFiles: [],
      numberOfApproved: 0,
      numberOfPending: 0,
    } as unknown as OwnedFilesInfo;

    test('ownedFiles - should be `undefined` when owner is `undefined`', () => {
      const undefinedOwner = undefined;
      assert.equal(ownedFiles(undefinedOwner, filesOwners), undefined);
    });

    test('ownedFiles - should be `undefined` when filesOwners are `undefined`', () => {
      const undefinedFilesOwners = undefined;
      assert.equal(ownedFiles(owner, undefinedFilesOwners), undefined);
    });

    test('ownedFiles - should return empty owned file when no files are owned by user', () => {
      const user = account(2);
      assert.equal(
        deepEqual(ownedFiles(user, filesOwners), emptyOwnerFilesInfo),
        true
      );
    });

    test('ownedFiles - should return owned files', () => {
      assert.equal(
        deepEqual(ownedFiles(owner, filesOwners), {
          ownedFiles: [
            {file: ownedFile, status: FileStatus.NEEDS_APPROVAL},
            {file: ownedApprovedFile, status: FileStatus.APPROVED},
          ],
          numberOfApproved: 1,
          numberOfPending: 1,
        }),
        true
      );
    });

    test('ownedFiles - should return auto-approved files', () => {
      const autoApprovedFilesOwners = {
        files_auto_approved: {
          [ownedApprovedFile]: [fileOwner(1)],
        },
      } as unknown as FilesOwners;
      assert.equal(
        deepEqual(ownedFiles(owner, autoApprovedFilesOwners), {
          ownedFiles: [
            {file: ownedApprovedFile, status: FileStatus.AUTO_APPROVED},
          ],
          numberOfApproved: 1,
          numberOfPending: 0,
        }),
        true
      );
    });

    test('ownedFiles - should return explicitly approved files without auto approval flag', () => {
      const explicitlyApprovedFilesOwners = {
        files_approved: {
          [ownedApprovedFile]: [fileOwner(1)],
        },
      } as unknown as FilesOwners;
      assert.equal(
        deepEqual(ownedFiles(owner, explicitlyApprovedFilesOwners), {
          ownedFiles: [{file: ownedApprovedFile, status: FileStatus.APPROVED}],
          numberOfApproved: 1,
          numberOfPending: 0,
        }),
        true
      );
    });

    test('ownedFiles - should match file owner through email without domain name', () => {
      const filesOwners = {
        files: {
          [ownedFile]: [fileOwnerWithNameOnly(`${ownerAccountId}_email`)],
          'some.text': [fileOwnerWithNameOnly('random_joe')],
        },
      } as unknown as FilesOwners;
      assert.equal(
        deepEqual(ownedFiles(owner, filesOwners), {
          ownedFiles: [{file: ownedFile, status: FileStatus.NEEDS_APPROVAL}],
          numberOfApproved: 0,
          numberOfPending: 1,
        }),
        true
      );
    });

    test('ownedFiles - should match file owner through full name', () => {
      const filesOwners = {
        files_approved: {
          [ownedFile]: [fileOwnerWithNameOnly(`${ownerAccountId}_name`)],
          'some.text': [fileOwnerWithNameOnly('random_joe')],
        },
      } as unknown as FilesOwners;
      assert.equal(
        deepEqual(ownedFiles(owner, filesOwners), {
          ownedFiles: [{file: ownedFile, status: FileStatus.APPROVED}],
          numberOfApproved: 1,
          numberOfPending: 0,
        }),
        true
      );
    });

    test('ownedFiles - should NOT match file owner over email without domain or full name when account id is different', () => {
      const notFileOwner = {...owner, _account_id: 2 as unknown as AccountId};
      assert.equal(
        deepEqual(ownedFiles(notFileOwner, filesOwners), emptyOwnerFilesInfo),
        true
      );
    });
  });

  suite('shouldHide tests', () => {
    const current_revision = 'commit-1' as unknown as CommitId;
    const change = {
      status: ChangeStatus.NEW,
      submit_requirements: [
        {submittability_expression_result: {expression: 'has:approval_owners'}},
      ] as unknown as SubmitRequirementResultInfo[],
      current_revision,
    } as unknown as ChangeInfo;
    const revisionInfo = {
      _number: 1,
      commit: {commit: current_revision},
    } as unknown as RevisionInfo;
    const user = {account: account(1), role: UserRole.OTHER};
    const ownedFiles = [{file: 'README.md', status: FileStatus.NEEDS_APPROVAL}];

    test('shouldHide - should be `true` when change is `undefined`', () => {
      const undefinedChange = undefined;
      assert.equal(
        shouldHide(undefinedChange, revisionInfo, user, ownedFiles),
        true
      );
    });

    test('shouldHide - should be `true` when change is `ABANDONED` or `MERGED`', () => {
      const abandonedOrMergedChange = {
        ...change,
        status: getRandom(ChangeStatus.ABANDONED, ChangeStatus.MERGED),
      };
      assert.equal(
        shouldHide(abandonedOrMergedChange, revisionInfo, user, ownedFiles),
        true
      );
    });

    test('shouldHide - should be `true` when revisionInfo is `undefined` or in `EDIT` mode', () => {
      const undefinedOrEditRevisionInfo = getRandom(undefined, {
        _number: EDIT,
      } as unknown as RevisionInfo);
      assert.equal(
        shouldHide(change, undefinedOrEditRevisionInfo, user, ownedFiles),
        true
      );
    });

    test('shouldHide - should be `true` when NOT current_revision is viewed', () => {
      const notCurrentRevisionInfo = {
        _number: 0,
        commit: {commit: 'not-current' as unknown as CommitId},
      } as unknown as RevisionInfo;
      assert.equal(
        shouldHide(change, notCurrentRevisionInfo, user, ownedFiles),
        true
      );
    });

    test('shouldHide - should be `true` when change has different submit requirements', () => {
      const changeWithOtherSubmitRequirements = {
        ...change,
        submit_requirements: [
          {
            submittability_expression_result: {
              expression: 'has:other_predicate',
            },
          },
        ] as unknown as SubmitRequirementResultInfo[],
      };
      assert.equal(
        shouldHide(
          changeWithOtherSubmitRequirements,
          revisionInfo,
          user,
          ownedFiles
        ),
        true
      );
    });

    test('shouldHide - should be `true` when user is `undefined` or `ANONYMOUS`', () => {
      const undefinedOrAnonymousUser = getRandom(undefined, {
        role: UserRole.ANONYMOUS,
      } as unknown as User);
      assert.equal(
        shouldHide(change, revisionInfo, undefinedOrAnonymousUser, ownedFiles),
        true
      );
    });

    test('shouldHide - should be `false` when user owns files', () => {
      assert.equal(shouldHide(change, revisionInfo, user, ownedFiles), false);
    });
  });
});

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

function fileOwner(id: number): Owner {
  return {
    id,
    name: `${id}_name`,
  } as unknown as Owner;
}

function fileOwnerWithNameOnly(name: string): GroupOwner {
  return {name} as unknown as GroupOwner;
}