refactor: move handling of invalid configurations to loading of file

* Goal: No need to loop over all external classifications at every place where it is used

Signed-off-by: Dominikus Hellgartner <dominikus.hellgartner@tngtech.com>

src/ElectronBackend/input/__tests__/checkConfiguration.test.ts

@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: Meta Platforms, Inc. and its affiliates
+// SPDX-FileCopyrightText: TNG Technology Consulting GmbH <https://www.tngtech.com>
+//
+// SPDX-License-Identifier: Apache-2.0
+import { EMPTY_PROJECT_CONFIG } from '../../../Frontend/shared-constants';
+import {
+  Attributions,
+  Classifications,
+  PackageInfo,
+  ProjectConfig,
+} from '../../../shared/shared-types';
+import { faker } from '../../../testing/Faker';
+import { checkAndUpdateConfiguration } from '../checkConfiguration';
+
+function fakePackagesWithClassifications(
+  ...classificationIds: Array<number>
+): Attributions {
+  const attributions: Attributions = {};
+  classificationIds
+    .map((classificationId) =>
+      faker.opossum.packageInfo({ classification: classificationId }),
+    )
+    .forEach((packageInfo: PackageInfo, index: number) => {
+      attributions[`id${index}`] = packageInfo;
+    });
+  return attributions;
+}
+
+function fakeConfigWithClassificationIds(...classificationIds: Array<number>) {
+  const classifications: Classifications = {};
+  classificationIds.forEach((classificationId) => {
+    classifications[classificationId] = faker.word.words();
+  });
+  const configuration: ProjectConfig = { classifications };
+  return configuration;
+}
+
+describe('check and update configuration', () => {
+  it('returns configuration with empty classifications if no configuration set', () => {
+    const result = checkAndUpdateConfiguration(undefined, {});
+
+    expect(result).toEqual(EMPTY_PROJECT_CONFIG);
+  });
+
+  it('does not change the configuration if all classifications are correctly set', () => {
+    const configuration = fakeConfigWithClassificationIds(0, 1);
+    const expectedConfiguration = { ...configuration };
+    const externalAttributions = fakePackagesWithClassifications(1, 0, 1, 0);
+
+    const result = checkAndUpdateConfiguration(
+      configuration,
+      externalAttributions,
+    );
+
+    expect(result).toEqual(expectedConfiguration);
+  });
+
+  it('does updates the classification set on unknown classifications found', () => {
+    const configuration = fakeConfigWithClassificationIds(0, 1);
+    const copiedClassifications = { ...configuration.classifications };
+
+    const externalAttributions = fakePackagesWithClassifications(0, 1, 22);
+
+    const result = checkAndUpdateConfiguration(
+      configuration,
+      externalAttributions,
+    );
+
+    const expectedConfiguration = {
+      classifications: {
+        ...copiedClassifications,
+        22: 'not configured - 22',
+      },
+    };
+
+    expect(result).toEqual(expectedConfiguration);
+  });
+});

src/ElectronBackend/input/checkConfiguration.ts

@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: Meta Platforms, Inc. and its affiliates
+// SPDX-FileCopyrightText: TNG Technology Consulting GmbH <https://www.tngtech.com>
+//
+// SPDX-License-Identifier: Apache-2.0
+import { EMPTY_PROJECT_CONFIG } from '../../Frontend/shared-constants';
+import {
+  Attributions,
+  PackageInfo,
+  ProjectConfig,
+} from '../../shared/shared-types';
+import logger from '../main/logger';
+
+function checkAndUpdateClassifications(
+  config: ProjectConfig,
+  externalAttributions: Attributions,
+) {
+  const classifications = config.classifications;
+  const configuredAttributionKeys = Object.keys(classifications).map(
+    (configurationValue) => Number(configurationValue),
+  );
+  const containsUnconfiguredClassification = (packageInfo: PackageInfo) =>
+    packageInfo.classification &&
+    !configuredAttributionKeys.includes(packageInfo.classification);
+
+  const unconfiguredClassifications = Object.values(externalAttributions)
+    .filter(containsUnconfiguredClassification)
+    .map<number | undefined>((packageInfo) => packageInfo.classification)
+    .filter((classificationId) => classificationId !== undefined);
+  if (unconfiguredClassifications.length) {
+    logger.warn(
+      `Detected configuration values without configuration: ${unconfiguredClassifications.join(', ')}`,
+    );
+    unconfiguredClassifications.forEach((unconfiguredClassificationId) => {
+      classifications[unconfiguredClassificationId] =
+        `not configured - ${unconfiguredClassificationId}`;
+    });
+  }
+  return classifications;
+}
+
+export function checkAndUpdateConfiguration(
+  rawConfig: ProjectConfig | undefined,
+  externalAttributions: Attributions,
+) {
+  const config = rawConfig ?? EMPTY_PROJECT_CONFIG;
+  config.classifications = checkAndUpdateClassifications(
+    config,
+    externalAttributions,
+  );
+  return config;
+}

src/ElectronBackend/input/importFromFile.ts

@@ -29,6 +29,7 @@ import {
 } from '../types/types';
 import { getFilePathWithAppendix } from '../utils/getFilePathWithAppendix';
 import { isOpossumFileFormat } from '../utils/isOpossumFileFormat';
+import { checkAndUpdateConfiguration } from './checkConfiguration';
 import {
   parseInputJsonFile,
   parseOpossumFile,
@@ -128,6 +129,12 @@ export async function loadInputAndOutputFromFilePath(
     parsedInputData.frequentLicenses,
   );
 
+  logger.info('Checking configuration');
+  parsedInputData.config = checkAndUpdateConfiguration(
+    parsedInputData.config,
+    externalAttributions,
+  );
+
   if (parsedOutputData === null) {
     logger.info('Creating output file');
     if (isOpossumFileFormat(filePath)) {