[WM-2427] Remove ability for Cromwell appTypes to be deleted

src/analysis/Environments/DeleteButton.ts

@@ -3,10 +3,13 @@ import { ReactNode } from 'react';
 import { h } from 'react-hyperscript-helpers';
 import { isResourceDeletable } from 'src/analysis/utils/resource-utils';
 import { getDisplayRuntimeStatus } from 'src/analysis/utils/runtime-utils';
+import { cromwellAppToolLabels } from 'src/analysis/utils/tool-utils';
 import { Link } from 'src/components/common';
 import { makeMenuIcon } from 'src/components/PopupTrigger';
-import { isApp } from 'src/libs/ajax/leonardo/models/app-models';
+import { App, isApp } from 'src/libs/ajax/leonardo/models/app-models';
 import { LeoRuntimeStatus } from 'src/libs/ajax/leonardo/models/runtime-models';
+import * as Utils from 'src/libs/utils';
+import { makeCromwellAppsNotDeletable } from 'src/pages/EnvironmentsPage/environmentsPermissions';
 
 import { DecoratedComputeResource } from './Environments.models';
 
@@ -18,19 +21,28 @@ export interface DeleteButtonProps {
 export const DeleteButton = (props: DeleteButtonProps): ReactNode => {
   const { resource, onClick } = props;
   const resourceType = isApp(resource) ? 'app' : 'runtime';
-  const isDeletable = isResourceDeletable(resourceType, resource);
+  // Casting resource to type App to access the appType property
+  const castToApp = resource as App;
+  const appsToDelete = makeCromwellAppsNotDeletable();
+  const isDeletable = appsToDelete.canBeDeleted(castToApp) && isResourceDeletable(resourceType, resource);
 
   return h(
     Link,
     {
       disabled: !isDeletable,
-      tooltip: isDeletable
-        ? 'Delete cloud environment'
-        : `Cannot delete a cloud environment while in status ${_.upperCase(
-            getDisplayRuntimeStatus(resource.status as LeoRuntimeStatus)
-          )}.`,
+      tooltip: Utils.cond(
+        [isDeletable, () => 'Delete cloud environment'],
+        [Object.keys(cromwellAppToolLabels).includes(castToApp.appType), () => 'Deleting not yet supported'],
+        [
+          Utils.DEFAULT,
+          () =>
+            `Cannot delete a cloud environment while in status ${_.upperCase(
+              getDisplayRuntimeStatus(resource.status as LeoRuntimeStatus)
+            )}.`,
+        ]
+      ),
       onClick: () => onClick(resource),
     },
-    [makeMenuIcon('trash'), 'Delete']
+    [makeMenuIcon('trash', undefined), 'Delete']
   );
 };

src/analysis/Environments/Environments.models.ts

@@ -22,5 +22,9 @@ export interface LeoResourcePermissionsProvider {
   canPauseResource: (resource: App | ListRuntimeItem) => boolean;
 }
 
+export interface CanDeleteProvider {
+  canBeDeleted: (resource: App) => boolean;
+}
+
 export type DeleteRuntimeProvider = Pick<LeoRuntimeProvider, 'delete'>;
 export type DeleteDiskProvider = Pick<LeoDiskProvider, 'delete'>;

src/analysis/Environments/Environments.test.ts

@@ -1,5 +1,5 @@
 import { NavLinkProvider } from '@terra-ui-packages/core-utils';
-import { act, fireEvent, getAllByRole, screen } from '@testing-library/react';
+import { act, fireEvent, getAllByRole, screen, within } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
 import _ from 'lodash/fp';
 import { h } from 'react-hyperscript-helpers';
@@ -524,6 +524,51 @@ describe('Environments', () => {
       expect(getTextContentForColumn(fourthAppRow, 8)).toBe(makeCompleteDate(azureApp2.auditInfo.dateAccessed));
     });
 
+    it('Renders Cromwell apps with disabled delete', async () => {
+      // Arrange
+      const props = getEnvironmentsProps();
+
+      const googleApp1 = generateTestAppWithGoogleWorkspace({}, defaultGoogleWorkspace);
+      const azureApp1 = generateTestAppWithAzureWorkspace({ appType: appToolLabels.CROMWELL }, defaultAzureWorkspace);
+      const azureWorkspace2 = generateAzureWorkspace();
+      const azureApp2 = generateTestAppWithAzureWorkspace({ appType: appToolLabels.WORKFLOWS_APP }, azureWorkspace2);
+      asMockedFn(props.leoAppData.listWithoutProject).mockResolvedValue([googleApp1, azureApp1, azureApp2]);
+      asMockedFn(props.useWorkspaces).mockReturnValue({
+        ...defaultUseWorkspacesProps,
+        workspaces: [defaultGoogleWorkspace, defaultAzureWorkspace, azureWorkspace2],
+      });
+
+      // Act
+      await act(async () => {
+        render(h(Environments, props));
+      });
+
+      // Assert
+      const tableRows: HTMLElement[] = screen.getAllByRole('row').slice(1); // skip header row
+      const firstAppRow: HTMLElement = tableRows[0];
+      const actionColumnButton1 = within(firstAppRow)
+        .getAllByRole('button')
+        .filter((button) => button.textContent.includes('Delete'))[0];
+      expect(actionColumnButton1).not.toHaveAttribute('disabled');
+
+      const secondAppRow: HTMLElement = tableRows[1];
+      const actionColumnButton2 = within(secondAppRow)
+        .getAllByRole('button')
+        .filter((button) => button.textContent.includes('Delete'))[0];
+      expect(actionColumnButton2).toHaveAttribute('disabled');
+
+      const thirdAppRow: HTMLElement = tableRows[2];
+      const actionColumnButton3 = within(thirdAppRow)
+        .getAllByRole('button')
+        .filter((button) => button.textContent.includes('Delete'))[0];
+      expect(actionColumnButton3).toHaveAttribute('disabled');
+
+      // Check for tooltip, and that it's only present for azure apps
+      const notSupportedTooltip = screen.getAllByText('Deleting not yet supported');
+      expect(notSupportedTooltip).toBeInTheDocument;
+      expect(notSupportedTooltip.length).toBe(2);
+    });
+
     it.each([
       { app: generateTestAppWithGoogleWorkspace({}, defaultGoogleWorkspace), workspace: defaultGoogleWorkspace },
       { app: generateTestAppWithAzureWorkspace({}, defaultAzureWorkspace), workspace: defaultAzureWorkspace },

src/analysis/utils/tool-utils.ts

@@ -10,6 +10,7 @@ import { CloudProvider, cloudProviderTypes } from 'src/libs/workspace-utils';
 
 export type RuntimeToolLabel = 'Jupyter' | 'RStudio' | 'JupyterLab';
 export type AppToolLabel = 'GALAXY' | 'CROMWELL' | 'HAIL_BATCH' | 'WDS' | 'WORKFLOWS_APP' | 'CROMWELL_RUNNER_APP';
+export type CromwellAppToolLabel = 'CROMWELL' | 'WORKFLOWS_APP' | 'CROMWELL_RUNNER_APP';
 export type AppAccessScope = 'USER_PRIVATE' | 'WORKSPACE_SHARED';
 export type LaunchableToolLabel = 'spark' | 'terminal' | 'RStudio' | 'JupyterLab';
 export type ToolLabel = RuntimeToolLabel | AppToolLabel;
@@ -48,6 +49,12 @@ export const appToolLabels: Record<AppToolLabel, AppToolLabel> = {
   WDS: 'WDS',
 };
 
+export const cromwellAppToolLabels: Record<CromwellAppToolLabel, CromwellAppToolLabel> = {
+  CROMWELL: 'CROMWELL',
+  WORKFLOWS_APP: 'WORKFLOWS_APP',
+  CROMWELL_RUNNER_APP: 'CROMWELL_RUNNER_APP',
+};
+
 export const appAccessScopes: Record<AppAccessScope, AppAccessScope> = {
   USER_PRIVATE: 'USER_PRIVATE',
   WORKSPACE_SHARED: 'WORKSPACE_SHARED',

src/pages/EnvironmentsPage/environmentsPermissions.ts

@@ -1,5 +1,6 @@
-import { LeoResourcePermissionsProvider } from 'src/analysis/Environments/Environments.models';
+import { CanDeleteProvider, LeoResourcePermissionsProvider } from 'src/analysis/Environments/Environments.models';
 import { getCreatorForCompute } from 'src/analysis/utils/resource-utils';
+import { cromwellAppToolLabels } from 'src/analysis/utils/tool-utils';
 import { App } from 'src/libs/ajax/leonardo/models/app-models';
 import { PersistentDisk } from 'src/libs/ajax/leonardo/models/disk-models';
 import { ListRuntimeItem } from 'src/libs/ajax/leonardo/models/runtime-models';
@@ -21,6 +22,14 @@ const makePermissionsProvider = (userEmailGetter: () => string): LeoResourcePerm
   return permissionsProvider;
 };
 
+export const makeCromwellAppsNotDeletable = (): CanDeleteProvider => {
+  return {
+    canBeDeleted: (resource: App) => {
+      return !Object.keys(cromwellAppToolLabels).includes(resource.appType);
+    },
+  };
+};
+
 const currentUserEmailGetter = (): string => {
   return getTerraUser().email!;
 };