@openshift-assisted/ui-lib 2.16.4-cim → 2.16.5-cim

package/lib/ocm/components/clusterWizard/OperatorsSelect.test.ts

@@ -1,163 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Bundle } from '@openshift-assisted/types/assisted-installer-service';
-import { OperatorsValues } from '../../../common';
-
-// Test the counting logic that was implemented in OperatorsSelect
-function calculateSelectedOperators(
-  values: OperatorsValues,
-  bundles: Bundle[],
-  opSpecs: Record<string, unknown>,
-): string[] {
-  // Calculate all selected operators (direct selections + bundle selections)
-  const bundleOperators = values.selectedBundles.flatMap(
-    (bundleId) => bundles.find((b) => b.id === bundleId)?.operators || [],
-  );
-
-  const allSelectedOperators = values.selectedOperators
-    .concat(bundleOperators)
-    .filter((op, index, array) => array.indexOf(op) === index); // Remove duplicates
-
-  return allSelectedOperators.filter((opKey) => !!opSpecs[opKey]);
-}
-
-describe('OperatorsSelect counting logic', () => {
-  const mockBundles: Bundle[] = [
-    {
-      id: 'virtualization',
-      title: 'Virtualization',
-      description: 'Virtualization bundle',
-      operators: ['cnv', 'nmstate', 'mtv'],
-    },
-    {
-      id: 'openshift-ai',
-      title: 'OpenShift AI',
-      description: 'AI bundle',
-      operators: ['nvidia-gpu', 'authorino', 'odf'],
-    },
-  ];
-
-  const mockOpSpecs = {
-    lvm: { title: 'LVM' },
-    odf: { title: 'ODF' },
-    cnv: { title: 'CNV' },
-    nmstate: { title: 'NMState' },
-    mtv: { title: 'MTV' },
-    'nvidia-gpu': { title: 'NVIDIA GPU' },
-    authorino: { title: 'Authorino' },
-  };
-
-  it('should count only manually selected operators when no bundles are selected', () => {
-    const values: OperatorsValues = {
-      selectedOperators: ['lvm', 'odf'],
-      selectedBundles: [],
-    };
-
-    const result = calculateSelectedOperators(values, mockBundles, mockOpSpecs);
-
-    expect(result).toHaveLength(2);
-    expect(result).toContain('lvm');
-    expect(result).toContain('odf');
-  });
-
-  it('should count bundle operators when a bundle is selected', () => {
-    const values: OperatorsValues = {
-      selectedOperators: ['lvm'], // 1 manually selected
-      selectedBundles: ['virtualization'], // bundle with 3 operators: cnv, nmstate, mtv
-    };
-
-    const result = calculateSelectedOperators(values, mockBundles, mockOpSpecs);
-
-    expect(result).toHaveLength(4);
-    expect(result).toContain('lvm');
-    expect(result).toContain('cnv');
-    expect(result).toContain('nmstate');
-    expect(result).toContain('mtv');
-  });
-
-  it('should not double-count operators that are both manually selected and in a bundle', () => {
-    const values: OperatorsValues = {
-      selectedOperators: ['lvm', 'cnv'], // cnv is also in the bundle
-      selectedBundles: ['virtualization'], // bundle with: cnv, nmstate, mtv
-    };
-
-    const result = calculateSelectedOperators(values, mockBundles, mockOpSpecs);
-
-    expect(result).toHaveLength(4);
-    expect(result).toContain('lvm');
-    expect(result).toContain('cnv');
-    expect(result).toContain('nmstate');
-    expect(result).toContain('mtv');
-    // cnv should only appear once in the result
-    expect(result.filter((op) => op === 'cnv')).toHaveLength(1);
-  });
-
-  it('should only count operators that have valid specs', () => {
-    const values: OperatorsValues = {
-      selectedOperators: ['lvm', 'invalid-operator'], // invalid-operator not in opSpecs
-      selectedBundles: [],
-    };
-
-    const result = calculateSelectedOperators(values, mockBundles, mockOpSpecs);
-
-    expect(result).toHaveLength(1);
-    expect(result).toContain('lvm');
-    expect(result).not.toContain('invalid-operator');
-  });
-
-  it('should handle multiple bundles correctly', () => {
-    const values: OperatorsValues = {
-      selectedOperators: ['lvm'],
-      selectedBundles: ['virtualization', 'openshift-ai'], // Two bundles
-    };
-
-    const result = calculateSelectedOperators(values, mockBundles, mockOpSpecs);
-
-    expect(result).toHaveLength(7); // lvm + 3 from virtualization + 3 from openshift-ai
-    expect(result).toContain('lvm');
-    expect(result).toContain('cnv');
-    expect(result).toContain('nmstate');
-    expect(result).toContain('mtv');
-    expect(result).toContain('nvidia-gpu');
-    expect(result).toContain('authorino');
-    expect(result).toContain('odf');
-  });
-
-  it('should handle overlapping operators in multiple bundles', () => {
-    const values: OperatorsValues = {
-      selectedOperators: [],
-      selectedBundles: ['virtualization', 'openshift-ai'], // Both bundles have 'odf' (but only virtualization has it in our mock)
-    };
-
-    // Let's modify the virtualization bundle to include odf to test overlap
-    const bundlesWithOverlap: Bundle[] = [
-      {
-        id: 'virtualization',
-        title: 'Virtualization',
-        description: 'Virtualization bundle',
-        operators: ['cnv', 'nmstate', 'mtv', 'odf'], // Added odf
-      },
-      {
-        id: 'openshift-ai',
-        title: 'OpenShift AI',
-        description: 'AI bundle',
-        operators: ['nvidia-gpu', 'authorino', 'odf'], // odf is in both bundles
-      },
-    ];
-
-    const result = calculateSelectedOperators(values, bundlesWithOverlap, mockOpSpecs);
-
-    expect(result).toHaveLength(6); // cnv, nmstate, mtv, odf, nvidia-gpu, authorino (odf not double-counted)
-    expect(result.filter((op) => op === 'odf')).toHaveLength(1); // odf should only appear once
-  });
-
-  it('should handle empty selections correctly', () => {
-    const values: OperatorsValues = {
-      selectedOperators: [],
-      selectedBundles: [],
-    };
-
-    const result = calculateSelectedOperators(values, mockBundles, mockOpSpecs);
-
-    expect(result).toHaveLength(0);
-  });
-});

package/lib/ocm/components/clusterWizard/disconnected/OptionalConfigurationsStep.tsx

@@ -1,201 +0,0 @@
-import * as React from 'react';
-import { Formik, useFormikContext } from 'formik';
-import * as Yup from 'yup';
-import {
-  ClusterWizardStep,
-  TechnologyPreview,
-  getRichTextValidation,
-  sshPublicKeyValidationSchema,
-  pullSecretValidationSchema,
-  getFormikErrorFields,
-} from '../../../../common';
-import { Split, SplitItem, Grid, GridItem, Form, Content, Checkbox } from '@patternfly/react-core';
-import { useClusterWizardContext } from '../ClusterWizardContext';
-import ClusterWizardFooter from '../ClusterWizardFooter';
-import ClusterWizardNavigation from '../ClusterWizardNavigation';
-import { WithErrorBoundary } from '../../../../common/components/ErrorHandling/WithErrorBoundary';
-import UploadSSH from '../../../../common/components/clusterConfiguration/UploadSSH';
-import PullSecretField from '../../../../common/components/ui/formik/PullSecretField';
-import { isInOcm, handleApiError, getApiErrorMessage } from '../../../../common/api';
-import { useAlerts } from '../../../../common/components/AlertsContextProvider';
-import { AlertVariant } from '@patternfly/react-core';
-import InfraEnvsService from '../../../services/InfraEnvsService';
-import { InfraEnvsAPI } from '../../../services/apis';
-import usePullSecret from '../../../hooks/usePullSecret';
-import { useParams } from 'react-router-dom-v5-compat';
-import ClustersService from '../../../services/ClustersService';
-import { Cluster } from '@openshift-assisted/types/assisted-installer-service';
-
-type OptionalConfigurationsFormValues = {
-  sshPublicKey?: string;
-  pullSecret?: string;
-};
-
-const PullSecretSync: React.FC<{ pullSecret?: string }> = ({ pullSecret }) => {
-  const { setFieldValue } = useFormikContext<OptionalConfigurationsFormValues>();
-
-  React.useEffect(() => {
-    if (pullSecret !== undefined) {
-      setFieldValue('pullSecret', pullSecret);
-    }
-  }, [pullSecret, setFieldValue]);
-
-  return null;
-};
-
-const OptionalConfigurationsStep = () => {
-  const pullSecret = usePullSecret() || '';
-  const { clusterId } = useParams<{ clusterId: string }>();
-  const [cluster, setCluster] = React.useState<Cluster | null>(null);
-
-  const { moveNext, moveBack, setDisconnectedInfraEnv, disconnectedInfraEnv } =
-    useClusterWizardContext();
-  const { addAlert } = useAlerts();
-  const [editPullSecret, setEditPullSecret] = React.useState(false);
-
-  React.useEffect(() => {
-    const fetchCluster = async () => {
-      if (!clusterId) {
-        return;
-      }
-      try {
-        const fetchedCluster = await ClustersService.get(clusterId);
-        setCluster(fetchedCluster);
-      } catch (error) {
-        handleApiError(error, () => {
-          addAlert({
-            title: 'Failed to fetch cluster',
-            message: getApiErrorMessage(error),
-            variant: AlertVariant.danger,
-          });
-        });
-      }
-    };
-    void fetchCluster();
-  }, [clusterId, addAlert]);
-
-  const validationSchema = React.useMemo(
-    () =>
-      Yup.object<OptionalConfigurationsFormValues>().shape({
-        sshPublicKey: sshPublicKeyValidationSchema,
-        pullSecret: pullSecretValidationSchema,
-      }),
-    [],
-  );
-
-  const initialValues: OptionalConfigurationsFormValues = {
-    sshPublicKey: '',
-    pullSecret: pullSecret,
-  };
-
-  return (
-    <Formik
-      initialValues={initialValues}
-      validate={getRichTextValidation<OptionalConfigurationsFormValues>(validationSchema)}
-      onSubmit={async (values) => {
-        if (!cluster || !cluster.id) {
-          addAlert({
-            title: 'Missing cluster',
-            message: 'Cluster must be created before configuring infrastructure environment',
-            variant: AlertVariant.danger,
-          });
-          return;
-        }
-
-        try {
-          // Check if infraEnv already exists
-          if (disconnectedInfraEnv && disconnectedInfraEnv.id) {
-            // Update existing infraEnv
-            const updateParams = {
-              pullSecret: values.pullSecret || pullSecret,
-              ...(values.sshPublicKey && { sshAuthorizedKey: values.sshPublicKey }),
-            };
-            const { data: updatedInfraEnv } = await InfraEnvsAPI.update(
-              disconnectedInfraEnv.id,
-              updateParams,
-            );
-            setDisconnectedInfraEnv(updatedInfraEnv);
-            moveNext();
-          } else {
-            // Create infraEnv with all params
-            const createParams = {
-              name: `disconnected-cluster_infra-env`,
-              pullSecret: values.pullSecret || pullSecret,
-              clusterId: cluster.id,
-              openshiftVersion: cluster.openshiftVersion,
-              cpuArchitecture: 'x86_64' as const,
-              ...(values.sshPublicKey && { sshAuthorizedKey: values.sshPublicKey }),
-            };
-            const createdInfraEnv = await InfraEnvsService.create(createParams);
-            setDisconnectedInfraEnv(createdInfraEnv);
-            moveNext();
-          }
-        } catch (error) {
-          handleApiError(error, () => {
-            addAlert({
-              title:
-                disconnectedInfraEnv && disconnectedInfraEnv.id
-                  ? 'Failed to update infrastructure environment'
-                  : 'Failed to create infrastructure environment',
-              message: getApiErrorMessage(error),
-              variant: AlertVariant.danger,
-            });
-          });
-        }
-      }}
-    >
-      {({ submitForm, isValid, errors, touched, isSubmitting }) => {
-        const errorFields = getFormikErrorFields(errors, touched);
-        const handleNext = () => {
-          void submitForm(); // This will trigger onSubmit
-        };
-
-        return (
-          <ClusterWizardStep
-            navigation={<ClusterWizardNavigation />}
-            footer={
-              <ClusterWizardFooter
-                disconnectedClusterId={clusterId}
-                onNext={handleNext} // Changed from moveNext
-                onBack={moveBack}
-                isNextDisabled={!isValid}
-                errorFields={errorFields}
-                isSubmitting={isSubmitting}
-              />
-            }
-          >
-            <WithErrorBoundary title="Failed to load Optional Configurations step">
-              <PullSecretSync pullSecret={pullSecret} />
-              <Grid hasGutter>
-                <GridItem>
-                  <Split>
-                    <SplitItem>
-                      <Content component="h2">Optional configurations</Content>
-                    </SplitItem>
-                    <SplitItem>
-                      <TechnologyPreview />
-                    </SplitItem>
-                  </Split>
-                </GridItem>
-                <GridItem>
-                  <Form id="wizard-cluster-optional-configurations__form">
-                    <UploadSSH />
-                    <Checkbox
-                      label="Edit pull secret"
-                      isChecked={editPullSecret}
-                      onChange={(_, checked) => setEditPullSecret(checked)}
-                      id="edit-pull-secret-checkbox"
-                    />
-                    {(editPullSecret || !pullSecret) && <PullSecretField isOcm={isInOcm} />}
-                  </Form>
-                </GridItem>
-              </Grid>
-            </WithErrorBoundary>
-          </ClusterWizardStep>
-        );
-      }}
-    </Formik>
-  );
-};
-
-export default OptionalConfigurationsStep;

package/lib/ocm/hooks/useInfraEnvHosts.ts

@@ -1,60 +0,0 @@
-import React from 'react';
-import useInfraEnvId from './useInfraEnvId';
-import { CpuArchitecture, DEFAULT_POLLING_INTERVAL } from '../../common';
-import { getErrorMessage } from '../../common/utils';
-import { InfraEnvsAPI } from '../services/apis';
-import InfraEnvIdsCacheService from '../services/InfraEnvIdsCacheService';
-import { Cluster, Host } from '@openshift-assisted/types/assisted-installer-service';
-
-const useInfraEnvHosts = (
-  clusterId: Cluster['id'],
-  cpuArchitecture: CpuArchitecture,
-  clusterName?: string,
-  pullSecret?: string,
-  openshiftVersion?: string,
-) => {
-  const [hosts, setHosts] = React.useState<Host[]>();
-  const [error, setError] = React.useState('');
-  const { infraEnvId, error: infraEnvIdError } = useInfraEnvId(
-    clusterId,
-    cpuArchitecture,
-    clusterName,
-    pullSecret,
-    openshiftVersion,
-  );
-
-  const getHosts = React.useCallback(async () => {
-    try {
-      if (infraEnvId) {
-        const { data: hostsData } = await InfraEnvsAPI.getHosts(infraEnvId);
-        setHosts(hostsData);
-      }
-    } catch (e) {
-      // Invalidate this cluster's cached data
-      InfraEnvIdsCacheService.removeInfraEnvId(clusterId, cpuArchitecture);
-      setError(getErrorMessage(e));
-    }
-  }, [clusterId, cpuArchitecture, infraEnvId]);
-
-  React.useEffect(() => {
-    if (infraEnvIdError) {
-      setHosts(undefined);
-      setError(infraEnvIdError);
-    } else {
-      if (infraEnvId) {
-        // Initial fetch
-        void getHosts();
-
-        // Set up polling to refetch hosts periodically
-        const intervalId = setInterval(() => {
-          void getHosts();
-        }, DEFAULT_POLLING_INTERVAL);
-
-        return () => clearInterval(intervalId);
-      }
-    }
-  }, [getHosts, infraEnvId, infraEnvIdError]);
-
-  return { hosts, error, isLoading: !hosts && !error };
-};
-export default useInfraEnvHosts;

package/lib/ocm/hooks/useLateBinding.ts

@@ -1,71 +0,0 @@
-import { useCallback, useEffect, useState } from 'react';
-import { Cluster } from '@openshift-assisted/types/assisted-installer-service';
-import { CpuArchitecture, useAlerts } from '../../common';
-import useInfraEnvHosts from './useInfraEnvHosts';
-import HostsService from '../services/HostsService';
-import { getErrorMessage } from '../../common/utils';
-import { useFeature } from './use-feature';
-
-const useLateBinding = (cluster: Cluster): boolean => {
-  const [isBinding, setIsBinding] = useState(false);
-  const { addAlert, removeAlert, alerts } = useAlerts();
-  const isSingleClusterFeatureEnabled = useFeature('ASSISTED_INSTALLER_SINGLE_CLUSTER_FEATURE');
-
-  const {
-    hosts: infraEnvHosts,
-    error: infraEnvError,
-    isLoading: infraEnvLoading,
-  } = useInfraEnvHosts(
-    isSingleClusterFeatureEnabled ? cluster.id : '',
-    cluster.cpuArchitecture
-      ? (cluster.cpuArchitecture as CpuArchitecture)
-      : CpuArchitecture.USE_DAY1_ARCHITECTURE,
-    cluster.name,
-    undefined,
-    cluster.openshiftVersion,
-  );
-
-  const bindHosts = useCallback(async () => {
-    if (infraEnvHosts && !infraEnvError && !infraEnvLoading && isSingleClusterFeatureEnabled) {
-      for (const host of infraEnvHosts) {
-        if (host.clusterId !== cluster.id) {
-          setIsBinding(true);
-          try {
-            const alertKey = alerts.find((alert) => alert.key === host.id)?.key;
-            if (alertKey) {
-              removeAlert(alertKey);
-            }
-            await HostsService.bind(host, cluster.id);
-          } catch (error) {
-            addAlert({
-              title: `Failed to bind host ${host.requestedHostname || ''}`,
-              message: getErrorMessage(error),
-              key: host.id,
-            });
-          } finally {
-            setIsBinding(false);
-          }
-        }
-      }
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [
-    infraEnvHosts,
-    infraEnvError,
-    infraEnvLoading,
-    isSingleClusterFeatureEnabled,
-    cluster.id,
-    addAlert,
-    removeAlert,
-  ]);
-
-  useEffect(() => {
-    if (isSingleClusterFeatureEnabled) {
-      void bindHosts();
-    }
-  }, [isSingleClusterFeatureEnabled, bindHosts]);
-
-  return infraEnvLoading || isBinding;
-};
-
-export default useLateBinding;