test(observability): add unit tests for delete tenant action

ref: #MAOBS-105

Signed-off-by: yjaaouane <[email protected]>

Author: yjaaouane

packages/manager/apps/observability/src/__tests__/components/listing/common/confirmation-modal/ConfirmationModal.spec.tsx

@@ -0,0 +1,107 @@
+import React from 'react';
+
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { vi } from 'vitest';
+
+import { ConfirmationModal } from '@/components/listing/common/confirmation-modal/ConfirmationModal.component';
+
+vi.mock('@ovh-ux/manager-react-components', () => ({
+  Modal: ({
+    children,
+    'data-testid': dataTestId,
+    ...props
+  }: {
+    children: React.ReactNode;
+    'data-testid'?: string;
+    [key: string]: unknown;
+  }) => (
+    <div data-testid={dataTestId || 'modal'} {...props}>
+      {children}
+    </div>
+  ),
+}));
+
+describe('ConfirmationModal', () => {
+  it('renders title and message', () => {
+    render(
+      <ConfirmationModal
+        title="Delete tenant"
+        message="Are you sure?"
+        onDismiss={() => {}}
+        confirmButtonLabel="Confirm"
+        cancelButtonLabel="Cancel"
+      />,
+    );
+
+    expect(screen.getByTestId('confirmation-modal')).toBeInTheDocument();
+    expect(screen.getByText('Delete tenant')).toBeInTheDocument();
+    expect(screen.getByText('Are you sure?')).toBeInTheDocument();
+    expect(screen.getByTestId('confirm-button-test-id')).toBeInTheDocument();
+    expect(screen.getByTestId('cancel-button-test-id')).toBeInTheDocument();
+  });
+
+  it('shows spinner and hides actions when loading', () => {
+    render(
+      <ConfirmationModal title="Processing" message="Please wait" onDismiss={() => {}} isLoading />,
+    );
+
+    expect(screen.getByTestId('spinner')).toBeInTheDocument();
+    expect(screen.queryByTestId('confirm-button-test-id')).not.toBeInTheDocument();
+    expect(screen.queryByTestId('cancel-button-test-id')).not.toBeInTheDocument();
+  });
+
+  it('displays error message when provided', () => {
+    render(
+      <ConfirmationModal
+        title="Error"
+        message="Something went wrong"
+        onDismiss={() => {}}
+        error="Could not delete"
+      />,
+    );
+
+    expect(screen.getByTestId('confirmation-modal-error-message')).toBeInTheDocument();
+    expect(screen.getByText('Could not delete')).toBeInTheDocument();
+  });
+
+  it('calls handlers when clicking buttons', async () => {
+    const user = userEvent.setup();
+    const onDismiss = vi.fn();
+    const onConfirm = vi.fn();
+
+    render(
+      <ConfirmationModal
+        title="Confirm"
+        message="Confirm action"
+        onDismiss={onDismiss}
+        onConfirm={onConfirm}
+        confirmButtonLabel="Confirm"
+        cancelButtonLabel="Cancel"
+      />,
+    );
+
+    await user.click(screen.getByTestId('cancel-button-test-id'));
+    expect(onDismiss).toHaveBeenCalledTimes(1);
+
+    await user.click(screen.getByTestId('confirm-button-test-id'));
+    expect(onConfirm).toHaveBeenCalledTimes(1);
+  });
+
+  it('respects confirm button loading and disabled states', () => {
+    render(
+      <ConfirmationModal
+        title="States"
+        message="Check states"
+        onDismiss={() => {}}
+        onConfirm={() => {}}
+        confirmButtonLabel="Confirm"
+        isConfirmButtonDisabled
+        isConfirmButtonLoading
+      />,
+    );
+
+    const confirm = screen.getByTestId('confirm-button-test-id');
+    expect(confirm).toBeInTheDocument();
+  });
+});

packages/manager/apps/observability/src/__tests__/components/listing/tenants/actions/TenantsListActions.component.spec.tsx

@@ -90,6 +90,10 @@ vi.mock('@ovh-ux/manager-react-components', () => ({
   ActionMenuItem: {},
 }));
 
+vi.mock('@/routes/Routes.utils', () => ({
+  getDeleteTenantUrl: (tenantId: string) => `/metrics/tenants/delete/${tenantId}`,
+}));
+
 describe('TenantsListActions', () => {
   const testTenantId: string = 'test-tenant-123';
 

packages/manager/apps/observability/src/__tests__/data/hooks/tenants/useDeleteTenant.hook.spec.tsx

@@ -0,0 +1,157 @@
+import React from 'react';
+
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+import { vi } from 'vitest';
+
+import { deleteTenant } from '@/data/api/tenants.api';
+import type { GetTenantPayload } from '@/data/api/tenants.props';
+import { useDeleteTenant } from '@/data/hooks/tenants/useDeleteTenant.hook';
+import type { Tenant } from '@/types/tenants.type';
+
+vi.mock('@/data/api/tenants.api', () => ({
+  deleteTenant: vi.fn(),
+}));
+
+const mockDeleteTenant = vi.mocked(deleteTenant);
+
+const createWrapper = () => {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: { retry: false, gcTime: 0 },
+      mutations: { retry: false, gcTime: 0 },
+    },
+  });
+
+  const TestWrapper = ({ children }: { children: React.ReactNode }) => (
+    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
+  );
+  TestWrapper.displayName = 'TestWrapper';
+  return { TestWrapper, queryClient };
+};
+
+describe('useDeleteTenant', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const payload: GetTenantPayload = {
+    resourceName: 'service-a',
+  } as unknown as GetTenantPayload;
+
+  const deletedTenant: Tenant = {
+    id: 'tenant-123',
+    currentState: {
+      title: 'Tenant 123',
+    },
+  };
+
+  it('calls deleteTenant with correct payload', async () => {
+    mockDeleteTenant.mockResolvedValue(deletedTenant);
+    const { TestWrapper } = createWrapper();
+
+    const { result } = renderHook(() => useDeleteTenant(), { wrapper: TestWrapper });
+
+    result.current.mutate(payload);
+
+    await waitFor(() => {
+      expect(mockDeleteTenant).toHaveBeenCalledWith(payload);
+    });
+  });
+
+  it('returns success state on resolve', async () => {
+    mockDeleteTenant.mockResolvedValue(deletedTenant);
+    const { TestWrapper } = createWrapper();
+
+    const { result } = renderHook(() => useDeleteTenant(), { wrapper: TestWrapper });
+
+    result.current.mutate(payload);
+
+    await waitFor(() => {
+      expect(result.current.isSuccess).toBe(true);
+      expect(result.current.data).toEqual(deletedTenant);
+      expect(result.current.error).toBe(null);
+    });
+  });
+
+  it('returns error state on reject', async () => {
+    const err = new Error('Failed');
+    mockDeleteTenant.mockRejectedValue(err);
+    const { TestWrapper } = createWrapper();
+
+    const { result } = renderHook(() => useDeleteTenant(), { wrapper: TestWrapper });
+
+    result.current.mutate(payload);
+
+    await waitFor(() => {
+      expect(result.current.isError).toBe(true);
+      expect(result.current.error).toEqual(err);
+      expect(result.current.data).toBeUndefined();
+    });
+  });
+
+  it('supports custom lifecycle callbacks', async () => {
+    mockDeleteTenant.mockResolvedValue(deletedTenant);
+    const onSuccess = vi.fn();
+    const onError = vi.fn();
+    const onMutate = vi.fn();
+    const onSettled = vi.fn();
+    const { TestWrapper } = createWrapper();
+
+    const { result } = renderHook(
+      () =>
+        useDeleteTenant({
+          onSuccess,
+          onError,
+          onMutate,
+          onSettled,
+        }),
+      { wrapper: TestWrapper },
+    );
+
+    result.current.mutate(payload);
+
+    await waitFor(() => {
+      expect(onMutate).toHaveBeenCalledWith(payload);
+      expect(onSuccess).toHaveBeenCalled();
+      expect(onSettled).toHaveBeenCalled();
+    });
+
+    expect(onError).not.toHaveBeenCalled();
+  });
+
+  it('exposes loading state during mutation', async () => {
+    let resolveFn: (v: Tenant) => void;
+    const pending = new Promise<Tenant>((resolve) => {
+      resolveFn = resolve;
+    });
+    mockDeleteTenant.mockReturnValue(pending);
+    const { TestWrapper } = createWrapper();
+
+    const { result } = renderHook(() => useDeleteTenant(), { wrapper: TestWrapper });
+
+    result.current.mutate(payload);
+
+    await waitFor(() => {
+      expect(result.current.isPending).toBe(true);
+    });
+    expect(result.current.data).toBeUndefined();
+    expect(result.current.error).toBe(null);
+
+    resolveFn!(deletedTenant);
+  });
+
+  it('can reset mutation state', async () => {
+    mockDeleteTenant.mockResolvedValue(deletedTenant);
+    const { TestWrapper } = createWrapper();
+    const { result } = renderHook(() => useDeleteTenant(), { wrapper: TestWrapper });
+
+    result.current.mutate(payload);
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    result.current.reset();
+    await waitFor(() => expect(result.current.isIdle).toBe(true));
+    expect(result.current.data).toBeUndefined();
+    expect(result.current.error).toBe(null);
+  });
+});