front_end/models/issues_manager/PropertyRuleIssue.test.ts

// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import type * as SDK from '../../core/sdk/sdk.js';
import * as Protocol from '../../generated/protocol.js';
import {setupLocaleHooks} from '../../testing/LocaleHelpers.js';
import {MockIssuesManager} from '../../testing/MockIssuesManager.js';
import {MockIssuesModel} from '../../testing/MockIssuesModel.js';
import * as IssuesManager from '../issues_manager/issues_manager.js';

describe('PropertyRuleIssue', () => {
  setupLocaleHooks();

  function createProtocolIssue(propertyRuleIssueDetails: Protocol.Audits.PropertyRuleIssueDetails):
      Protocol.Audits.InspectorIssue {
    return {
      code: Protocol.Audits.InspectorIssueCode.PropertyRuleIssue,
      details: {propertyRuleIssueDetails},
    };
  }

  const mockModel = new MockIssuesModel([]) as unknown as SDK.IssuesModel.IssuesModel;
  const mockManager = new MockIssuesManager([]) as unknown as IssuesManager.IssuesManager.IssuesManager;

  it('can be created for property rules parsing failures', () => {
    const issueDetails = {
      sourceCodeLocation: {
        url: 'http://example.com',
        lineNumber: 2,
        columnNumber: 2,
      },
      propertyRuleIssueReason: Protocol.Audits.PropertyRuleIssueReason.InvalidInitialValue,
      propertyValue: 'invalid',
    };
    const issue = createProtocolIssue(issueDetails);
    const propertyRuleIssues = IssuesManager.PropertyRuleIssue.PropertyRuleIssue.fromInspectorIssue(mockModel, issue);
    assert.lengthOf(propertyRuleIssues, 1);
    const propertyRuleIssue = propertyRuleIssues[0];

    assert.strictEqual(propertyRuleIssue.getCategory(), IssuesManager.Issue.IssueCategory.OTHER);
    assert.deepEqual(propertyRuleIssue.sources(), [issueDetails.sourceCodeLocation]);
    assert.strictEqual(propertyRuleIssue.getKind(), IssuesManager.Issue.IssueKind.PAGE_ERROR);
    assert.isNotNull(propertyRuleIssue.getDescription());
    assert.strictEqual(propertyRuleIssue.getPropertyName(), 'initial-value');
  });

  it('only aggregates identical issues', () => {
    const issueDetails = [
      {
        sourceCodeLocation: {
          url: 'http://example.com',
          lineNumber: 2,
          columnNumber: 2,
        },
        propertyRuleIssueReason: Protocol.Audits.PropertyRuleIssueReason.InvalidInitialValue,
        propertyValue: 'invalid',
      },
      {
        sourceCodeLocation: {
          url: 'http://example.com',
          lineNumber: 2,
          columnNumber: 2,
        },
        propertyRuleIssueReason: Protocol.Audits.PropertyRuleIssueReason.InvalidInitialValue,
        propertyValue: 'invalid',
      },
      {
        sourceCodeLocation: {
          url: 'http://example.com',
          lineNumber: 2,
          columnNumber: 2,
        },
        propertyRuleIssueReason: Protocol.Audits.PropertyRuleIssueReason.InvalidInherits,
        propertyValue: 'invalid',
      },
      {
        sourceCodeLocation: {
          url: 'http://example.com',
          lineNumber: 3,
          columnNumber: 2,
        },
        propertyRuleIssueReason: Protocol.Audits.PropertyRuleIssueReason.InvalidInitialValue,
        propertyValue: 'invalid',
      },
    ];

    const issues = issueDetails
                       .map(
                           details => IssuesManager.PropertyRuleIssue.PropertyRuleIssue.fromInspectorIssue(
                               mockModel, createProtocolIssue(details)))
                       .flat();

    assert.lengthOf(issues, 4);

    const aggregator = new IssuesManager.IssueAggregator.IssueAggregator(mockManager);
    for (const issue of issues) {
      mockManager.dispatchEventToListeners(
          IssuesManager.IssuesManager.Events.ISSUE_ADDED, {issuesModel: mockModel, issue});
    }

    const aggregatedIssues = Array.from(aggregator.aggregatedIssues());
    assert.lengthOf(aggregatedIssues, 3);

    // Use shallow comparison. We thus ensure the correct issues are aggregated:
    assert.strictEqual(Array.from(aggregatedIssues[0].sources())[0], issueDetails[0].sourceCodeLocation);
    assert.strictEqual(Array.from(aggregatedIssues[1].sources())[0], issueDetails[2].sourceCodeLocation);
    assert.strictEqual(Array.from(aggregatedIssues[2].sources())[0], issueDetails[3].sourceCodeLocation);
  });
});