feature(crr): add management-network endpoint & source-DNS Apply Actions rows and refine the certificate step

Author: hervedombya

src/react/locations/CRRSetupWizard/hooks/useImportDestinationCertificateMutation.test.ts

@@ -19,4 +19,10 @@ describe('isCertificateAlreadyImported', () => {
   it('is true when the exact certificate is already in the truststore', () => {
     expect(isCertificateAlreadyImported(withCerts(['some-other-cert', CERT]), CERT)).toBe(true);
   });
+
+  it('ignores trailing-whitespace / line-ending differences so a re-import stays a no-op', () => {
+    expect(isCertificateAlreadyImported(withCerts([CERT]), `${CERT}\n`)).toBe(true);
+    expect(isCertificateAlreadyImported(withCerts([`${CERT}\n`]), CERT)).toBe(true);
+    expect(isCertificateAlreadyImported(withCerts([CERT]), CERT.replace(/\n/g, '\r\n'))).toBe(true);
+  });
 });

src/react/locations/CRRSetupWizard/hooks/useImportDestinationCertificateMutation.ts

@@ -3,9 +3,13 @@ import { useAddCertificateToZenkoConfigurationMutation } from '../../../../js/mu
 import { getZenkoCRQuery } from '../../../queries';
 import type { ZenkoCR } from '../../../truststore/Truststore';
 
+export const normalizeCertificate = (certificate: string): string => certificate.replace(/\r\n/g, '\n').trim();
+
 /** True when the PEM is already in the source truststore, so importing it again is a no-op. */
 export const isCertificateAlreadyImported = (zenkoCR: ZenkoCR | undefined, certificate: string): boolean =>
-  (zenkoCR?.spec?.egress?.extraCACerts ?? []).some((bundle) => bundle['ca.crt'] === certificate);
+  (zenkoCR?.spec?.egress?.extraCACerts ?? []).some(
+    (bundle) => normalizeCertificate(bundle['ca.crt']) === normalizeCertificate(certificate),
+  );
 
 /**
  * Imports the destination CA certificate into the source cluster's truststore
@@ -22,12 +26,13 @@ export const useImportDestinationCertificateMutation = () => {
 
   return useMutation({
     mutationFn: async ({ certificate }: { certificate: string }) => {
+      const normalized = normalizeCertificate(certificate);
       // Read the latest cached CR at execution time, not the render-time snapshot.
       const currentCR = queryClient.getQueryData<ZenkoCR>(['zenkoCR']) ?? zenkoCR;
-      if (isCertificateAlreadyImported(currentCR, certificate)) {
+      if (isCertificateAlreadyImported(currentCR, normalized)) {
         return;
       }
-      await addCertificate.mutateAsync({ certificate });
+      await addCertificate.mutateAsync({ certificate: normalized });
     },
   });
 };

src/react/locations/CRRSetupWizard/steps/ApplyActionsStep/ApplyActionsStep.test.tsx

@@ -54,7 +54,6 @@ describe('ApplyActionsStep', () => {
     expect(screen.getByText('Configure paris-prod for Cross-Region Replication')).toBeInTheDocument();
 
     const actions = [
-      'Import Destination Certificate',
       'Create Account on Source: crr-src',
       'Create Bucket on Source: crr-src-bucket',
       'Create Account on Destination: crr-dest',
@@ -64,21 +63,24 @@ describe('ApplyActionsStep', () => {
       'Create IAM Role',
       'Attach Policy to Role',
       'Create Target Bucket: crr-target-bucket',
+      'Register Destination S3 Endpoint',
+      'Configure Source DNS Resolution',
+      'Import Certificate into Truststore',
       'Create Location',
       'Create Replication Rule',
     ];
     for (const action of actions) {
       expect(screen.getByText(action)).toBeInTheDocument();
     }
-    expect(screen.getAllByText('Pending...').length).toBe(12);
+    expect(screen.getAllByText('Pending...').length).toBe(14);
     // The setup only becomes confirmable once every action has succeeded.
     expect(screen.getByRole('button', { name: /Continue/i })).toBeDisabled();
   });
 
   it('does not surface a source-account action when the user reuses an existing account', () => {
     render(<ApplyActionsStep {...VALUES} accountNameType="existing" />, { wrapper: Wrapper });
     expect(screen.queryByText(/Create Account on Source/i)).not.toBeInTheDocument();
-    expect(screen.getAllByText('Pending...').length).toBe(11);
+    expect(screen.getAllByText('Pending...').length).toBe(13);
   });
 
   it('does not surface the source bucket, target bucket or replication rule when no rule is requested', () => {
@@ -88,7 +90,7 @@ describe('ApplyActionsStep', () => {
     expect(screen.queryByText(/Create Bucket on Source/i)).not.toBeInTheDocument();
     expect(screen.queryByText(/Create Target Bucket/i)).not.toBeInTheDocument();
     expect(screen.queryByText(/Create Replication Rule/i)).not.toBeInTheDocument();
-    expect(screen.getAllByText('Pending...').length).toBe(9);
+    expect(screen.getAllByText('Pending...').length).toBe(11);
   });
 
   it('falls back to "ARTESCA" in the title when Verify returned no instance name', () => {

src/react/locations/CRRSetupWizard/steps/ApplyActionsStep/ApplyActionsStep.tsx

@@ -1,4 +1,4 @@
-import { Form, Icon, Stack, Text } from '@scality/core-ui';
+import { Form, Icon, Loader, Stack, Text } from '@scality/core-ui';
 import { useStepper } from '@scality/core-ui/dist/components/steppers/Stepper.component';
 import { Button } from '@scality/core-ui/dist/next';
 import { useCreateBucket, useSetBucketReplication, useSetBucketVersioning } from '@scality/data-browser-library';
@@ -61,6 +61,14 @@ const StatusCell = ({ view, onRetry }: { view: StepView; onRetry: () => void })
       </StatusBox>
     );
   }
+  if (view.active) {
+    return (
+      <StatusBox>
+        <Loader size="small" />
+        <span>Pending...</span>
+      </StatusBox>
+    );
+  }
   return <span>Pending...</span>;
 };
 
@@ -136,9 +144,7 @@ export const ApplyActionsStep = (props: Props) => {
 
   // biome-ignore lint/correctness/useExhaustiveDependencies: keyed on the mutation instances so a status change rebuilds the config and rows show live status
   const { mutations, variables } = useMemo(() => {
-    const configs: MutationConfig[] = [
-      { id: 'import-destination-certificate', label: 'Import Destination Certificate', mutation: importCertificate },
-    ];
+    const configs: MutationConfig[] = [];
     const resolvers: VariablesResolvers = {
       'import-destination-certificate': () => ({ certificate: props.certificate }),
     };
@@ -172,6 +178,12 @@ export const ApplyActionsStep = (props: Props) => {
     configs.push({ id: CONFIGURATOR_CHAIN_LINK_ID, label: 'Configure Destination', mutation: setup });
     resolvers[CONFIGURATOR_CHAIN_LINK_ID] = () => body;
 
+    configs.push({
+      id: 'import-destination-certificate',
+      label: 'Import Certificate into Truststore',
+      mutation: importCertificate,
+    });
+
     configs.push({ id: 'create-location', label: 'Create Location', mutation: createLocation });
     resolvers['create-location'] = (prev) => {
       const result = configuratorResult(prev);
@@ -253,6 +265,7 @@ export const ApplyActionsStep = (props: Props) => {
           sourceBucketName: sourceBucketName ?? '',
           targetBucketName: props.targetBucketName ?? '',
           destinationAccountName: destinationAccountName ?? '',
+          isManagementNetwork: props.connectionMode === 'management-network',
         },
         { configuratorEvents: setup.events, chainStatusById, configuratorError },
       ),
@@ -263,6 +276,7 @@ export const ApplyActionsStep = (props: Props) => {
       sourceBucketName,
       props.targetBucketName,
       destinationAccountName,
+      props.connectionMode,
       setup.events,
       chainStatusById,
       configuratorError,

src/react/locations/CRRSetupWizard/steps/ApplyActionsStep/steps.test.ts

@@ -16,6 +16,7 @@ const baseInput: StepListInput = {
   sourceBucketName: 'src-bucket',
   targetBucketName: 'target-bucket',
   destinationAccountName: 'dest-account',
+  isManagementNetwork: true,
 };
 
 const noProgress: StepStateSources = { configuratorEvents: [], chainStatusById: {} };
@@ -34,7 +35,6 @@ describe('buildStepViews', () => {
   it('lists the full provisioning sequence in order when the user creates a new source account and a replication rule', () => {
     const views = buildStepViews(baseInput, noProgress);
     expect(views.map((v) => v.id)).toEqual([
-      'import-destination-certificate',
       'create-source-account',
       'create-source-bucket',
       'create-account',
@@ -44,17 +44,24 @@ describe('buildStepViews', () => {
       'create-role',
       'attach-role-policy',
       'create-bucket',
+      'register-endpoint',
+      'configure-source-dns',
+      'import-destination-certificate',
       'create-location',
       'create-replication-rule',
     ]);
   });
 
   it('numbers the steps and shows the chosen source and destination account names', () => {
-    const [first, sourceAcc, sourceBkt, destAcc] = buildStepViews(baseInput, noProgress);
-    expect(first).toMatchObject({ step: 1, label: 'Import Destination Certificate' });
-    expect(sourceAcc).toMatchObject({ step: 2, label: 'Create Account on Source: src-account' });
-    expect(sourceBkt).toMatchObject({ step: 3, label: 'Create Bucket on Source: src-bucket' });
-    expect(destAcc).toMatchObject({ step: 4, label: 'Create Account on Destination: dest-account' });
+    const views = buildStepViews(baseInput, noProgress);
+    const [sourceAcc, sourceBkt, destAcc] = views;
+    expect(sourceAcc).toMatchObject({ step: 1, label: 'Create Account on Source: src-account' });
+    expect(sourceBkt).toMatchObject({ step: 2, label: 'Create Bucket on Source: src-bucket' });
+    expect(destAcc).toMatchObject({ step: 3, label: 'Create Account on Destination: dest-account' });
+    expect(views.find((v) => v.id === 'import-destination-certificate')).toMatchObject({
+      step: 12,
+      label: 'Import Certificate into Truststore',
+    });
   });
 
   it('labels the destination IAM chain and the target bucket per the ARTESCA CRR procedure', () => {
@@ -65,6 +72,8 @@ describe('buildStepViews', () => {
     expect(labels).toContain('Create IAM Role');
     expect(labels).toContain('Attach Policy to Role');
     expect(labels).toContain('Create Target Bucket: target-bucket');
+    expect(labels).toContain('Register Destination S3 Endpoint');
+    expect(labels).toContain('Configure Source DNS Resolution');
     expect(labels).toContain('Create Location');
     expect(labels).toContain('Create Replication Rule');
   });
@@ -81,6 +90,12 @@ describe('buildStepViews', () => {
     expect(views.find((v) => v.id === 'create-replication-rule')).toBeUndefined();
   });
 
+  it('drops the endpoint and DNS steps in data-network mode', () => {
+    const views = buildStepViews({ ...baseInput, isManagementNetwork: false }, noProgress);
+    expect(views.find((v) => v.id === 'register-endpoint')).toBeUndefined();
+    expect(views.find((v) => v.id === 'configure-source-dns')).toBeUndefined();
+  });
+
   it('shows every step as pending before anything runs', () => {
     expect(buildStepViews(baseInput, noProgress).every((v) => v.state === 'pending')).toBe(true);
   });
@@ -149,6 +164,35 @@ describe('buildStepViews — wizard-run rows', () => {
   });
 });
 
+describe('buildStepViews — active flag', () => {
+  it('marks a wizard row active only while its link is running', () => {
+    const running = buildStepViews(baseInput, withChain({ 'create-location': { status: 'pending' } }));
+    expect(running.find((v) => v.id === 'create-location')).toMatchObject({ state: 'pending', active: true });
+  });
+
+  it('does not mark a wizard row active before it starts or after it succeeds', () => {
+    const idle = buildStepViews(baseInput, noProgress);
+    expect(idle.find((v) => v.id === 'create-location')).toMatchObject({ state: 'pending', active: false });
+
+    const done = buildStepViews(baseInput, withChain({ 'create-location': { status: 'success' } }));
+    expect(done.find((v) => v.id === 'create-location')?.active).toBe(false);
+  });
+
+  it('marks a configurator row active between its started and completed events', () => {
+    const started = buildStepViews(baseInput, withEvents([{ event: 'step.started', step: 'create-user', at: 't' }]));
+    expect(started.find((v) => v.id === 'create-user')).toMatchObject({ state: 'pending', active: true });
+
+    const completed = buildStepViews(
+      baseInput,
+      withEvents([
+        { event: 'step.started', step: 'create-user', at: 't' },
+        { event: 'step.completed', step: 'create-user', at: 't' },
+      ]),
+    );
+    expect(completed.find((v) => v.id === 'create-user')).toMatchObject({ state: 'succeeded', active: false });
+  });
+});
+
 describe('buildStepViews — crr-configurator rows', () => {
   it('marks a configurator step done once it completes and shows the reason when one fails', () => {
     const events: SetupEvent[] = [
@@ -167,6 +211,29 @@ describe('buildStepViews — crr-configurator rows', () => {
     expect(failed?.errorMessage).toBe('IAM refused CreateUser: entity already exists');
   });
 
+  it('drives the management-network endpoint and DNS rows from their stream events', () => {
+    const succeeded = buildStepViews(
+      baseInput,
+      withEvents([{ event: 'step.completed', step: 'register-endpoint', at: 't' }]),
+    );
+    expect(succeeded.find((v) => v.id === 'register-endpoint')?.state).toBe('succeeded');
+
+    const failed = buildStepViews(
+      baseInput,
+      withEvents([
+        {
+          event: 'step.failed',
+          step: 'configure-source-dns',
+          at: 't',
+          error: { code: 'InternalError', message: 'source could not resolve the endpoint' },
+        },
+      ]),
+    );
+    const dns = failed.find((v) => v.id === 'configure-source-dns');
+    expect(dns?.state).toBe('failed');
+    expect(dns?.errorMessage).toBe('source could not resolve the endpoint');
+  });
+
   it('blames the first pending configurator row when the stream fails without pinning a step', () => {
     const views = buildStepViews(baseInput, {
       configuratorEvents: [],
@@ -234,6 +301,8 @@ describe('allSucceeded / hasFailure', () => {
         'create-role',
         'attach-role-policy',
         'create-bucket',
+        'register-endpoint',
+        'configure-source-dns',
       ].map((step) => ({ event: 'step.completed', step, at: 't' }) as SetupEvent),
       chainStatusById: {
         'import-destination-certificate': { status: 'success' },