refactored out useEffect from setup technology

elastic · Jan 10, 2025 · fe67912 · fe67912
1 parent 304825a
commit fe67912
Show file tree

Hide file tree

Showing 4 changed files with 162 additions and 104 deletions.
diff --git a/...agent_policy/create_package_policy_page/single_page_layout/hooks/setup_technology.test.ts b/...agent_policy/create_package_policy_page/single_page_layout/hooks/setup_technology.test.ts
@@ -246,12 +246,11 @@ describe('useSetupTechnology', () => {
       })
     );
 
-    expect(generateNewAgentPolicyWithDefaults).toHaveBeenCalled();
-
     act(() => {
       result.current.handleSetupTechnologyChange(SetupTechnology.AGENTLESS);
     });
     await waitFor(() => {
+      expect(generateNewAgentPolicyWithDefaults).toHaveBeenCalled();
       expect(updatePackagePolicyMock).toHaveBeenCalledWith({ supports_agentless: true });
       expect(result.current.selectedSetupTechnology).toBe(SetupTechnology.AGENTLESS);
       expect(setNewAgentPolicy).toHaveBeenCalledWith({
@@ -290,13 +289,12 @@ describe('useSetupTechnology', () => {
       initialProps,
     });
 
-    expect(generateNewAgentPolicyWithDefaults).toHaveBeenCalled();
-
     act(() => {
       result.current.handleSetupTechnologyChange(SetupTechnology.AGENTLESS);
     });
 
     expect(result.current.selectedSetupTechnology).toBe(SetupTechnology.AGENTLESS);
+    expect(generateNewAgentPolicyWithDefaults).toHaveBeenCalled();
     expect(updatePackagePolicyMock).toHaveBeenCalledWith({ supports_agentless: true });
     expect(setNewAgentPolicy).toHaveBeenCalledWith({
       inactivity_timeout: 3600,
@@ -450,6 +448,7 @@ describe('useSetupTechnology', () => {
         updateAgentPolicies: updateAgentPoliciesMock,
         setSelectedPolicyTab: setSelectedPolicyTabMock,
         packagePolicy: packagePolicyMock,
+        packageInfo: packageInfoMock,
         updatePackagePolicy: updatePackagePolicyMock,
       })
     );
@@ -469,6 +468,11 @@ describe('useSetupTechnology', () => {
         name: 'Agentless policy for endpoint-1',
         supports_agentless: true,
         inactivity_timeout: 3600,
+        global_data_tags: [
+          { name: 'organization', value: 'org' },
+          { name: 'division', value: 'div' },
+          { name: 'team', value: 'team' },
+        ],
       });
       expect(updatePackagePolicyMock).toHaveBeenCalledWith({ supports_agentless: true });
     });
@@ -544,14 +548,42 @@ describe('useSetupTechnology', () => {
       },
     });
 
+    const packageInfoWithoutGlobalDataTags = {
+      policy_templates: [
+        {
+          name: 'cspm',
+          title: 'Template 1',
+          description: '',
+          deployment_modes: {
+            default: {
+              enabled: true,
+            },
+            agentless: {
+              enabled: true,
+            },
+          },
+        },
+        {
+          name: 'not-cspm',
+          title: 'Template 2',
+          description: '',
+          deployment_modes: {
+            default: {
+              enabled: true,
+            },
+          },
+        },
+      ] as RegistryPolicyTemplate[],
+    } as PackageInfo;
+
     const { result } = renderHook(() =>
       useSetupTechnology({
         setNewAgentPolicy,
         newAgentPolicy: newAgentPolicyMock,
         updateAgentPolicies: updateAgentPoliciesMock,
         setSelectedPolicyTab: setSelectedPolicyTabMock,
         packagePolicy: packagePolicyMock,
-        packageInfo: packageInfoMock,
+        packageInfo: packageInfoWithoutGlobalDataTags,
         updatePackagePolicy: updatePackagePolicyMock,
       })
     );
@@ -591,14 +623,42 @@ describe('useSetupTechnology', () => {
       },
     });
 
+    const packageInfoWithoutGlobalDataTags = {
+      policy_templates: [
+        {
+          name: 'cspm',
+          title: 'Template 1',
+          description: '',
+          deployment_modes: {
+            default: {
+              enabled: true,
+            },
+            agentless: {
+              enabled: true,
+            },
+          },
+        },
+        {
+          name: 'not-cspm',
+          title: 'Template 2',
+          description: '',
+          deployment_modes: {
+            default: {
+              enabled: true,
+            },
+          },
+        },
+      ] as RegistryPolicyTemplate[],
+    } as PackageInfo;
+
     const { result } = renderHook(() =>
       useSetupTechnology({
         setNewAgentPolicy,
         newAgentPolicy: newAgentPolicyMock,
         updateAgentPolicies: updateAgentPoliciesMock,
         setSelectedPolicyTab: setSelectedPolicyTabMock,
         packagePolicy: packagePolicyMock,
-        packageInfo: packageInfoMock,
+        packageInfo: packageInfoWithoutGlobalDataTags,
         updatePackagePolicy: updatePackagePolicyMock,
       })
     );
@@ -719,6 +779,7 @@ describe('useSetupTechnology', () => {
     });
 
     await waitFor(() => {
+      expect(result.current.selectedSetupTechnology).toBe(SetupTechnology.AGENT_BASED);
       expect(setNewAgentPolicy).toHaveBeenCalledWith(newAgentPolicyMock);
       expect(setNewAgentPolicy).not.toHaveBeenCalledWith({
         global_data_tags: [

diff --git a/...ions/agent_policy/create_package_policy_page/single_page_layout/hooks/setup_technology.ts b/...ions/agent_policy/create_package_policy_page/single_page_layout/hooks/setup_technology.ts
@@ -5,7 +5,7 @@
  * 2.0.
  */
 
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useCallback, useMemo, useRef, useState } from 'react';
 
 import { useConfig } from '../../../../../hooks';
 import { generateNewAgentPolicyWithDefaults } from '../../../../../../../../common/services/generate_new_agent_policy';
@@ -81,74 +81,17 @@ export function useSetupTechnology({
   const { isAgentlessEnabled } = useAgentless();
 
   // this is a placeholder for the new agent-BASED policy that will be used when the user switches from agentless to agent-based and back
-  const newAgentBasedPolicy = useRef<NewAgentPolicy>(newAgentPolicy);
+  const orginalAgentPolicyRef = useRef<NewAgentPolicy>({ ...newAgentPolicy });
+  const [currentAgentPolicy, setCurrentAgentPolicy] = useState(newAgentPolicy);
   const defaultSetupTechnology = useMemo(() => {
     return isOnlyAgentlessIntegration(packageInfo) || isAgentlessSetupDefault(packageInfo)
       ? SetupTechnology.AGENTLESS
       : SetupTechnology.AGENT_BASED;
   }, [packageInfo]);
   const [selectedSetupTechnology, setSelectedSetupTechnology] =
     useState<SetupTechnology>(defaultSetupTechnology);
-  const [newAgentlessPolicy, setNewAgentlessPolicy] = useState<AgentPolicy | NewAgentPolicy>(() => {
-    const agentless = generateNewAgentPolicyWithDefaults({
-      inactivity_timeout: 3600,
-      supports_agentless: true,
-      monitoring_enabled: ['logs', 'metrics'],
-    });
-    return agentless;
-  });
 
-  useEffect(() => {
-    if (isEditPage && agentPolicies && agentPolicies.some((policy) => policy.supports_agentless)) {
-      setSelectedSetupTechnology(SetupTechnology.AGENTLESS);
-      return;
-    }
-    if (isAgentlessEnabled && selectedSetupTechnology === SetupTechnology.AGENTLESS) {
-      const nextNewAgentlessPolicy = {
-        ...newAgentlessPolicy,
-        name: getAgentlessAgentPolicyNameFromPackagePolicyName(packagePolicy.name),
-        ...getAdditionalAgentlessPolicyInfo(packageInfo),
-      };
-      if (
-        !newAgentlessPolicy.name ||
-        nextNewAgentlessPolicy.name !== newAgentlessPolicy.name ||
-        (packageInfo && !newAgentlessPolicy.global_data_tags)
-      ) {
-        setNewAgentlessPolicy(nextNewAgentlessPolicy);
-        setNewAgentPolicy(nextNewAgentlessPolicy as NewAgentPolicy);
-        updateAgentPolicies([nextNewAgentlessPolicy] as AgentPolicy[]);
-      }
-    }
-    if (
-      selectedSetupTechnology === SetupTechnology.AGENTLESS &&
-      !packagePolicy.supports_agentless
-    ) {
-      updatePackagePolicy({
-        supports_agentless: true,
-      });
-    } else if (
-      selectedSetupTechnology !== SetupTechnology.AGENTLESS &&
-      packagePolicy.supports_agentless
-    ) {
-      updatePackagePolicy({
-        supports_agentless: false,
-      });
-    }
-  }, [
-    isAgentlessEnabled,
-    isEditPage,
-    newAgentlessPolicy,
-    newAgentPolicy,
-    packagePolicy.name,
-    packagePolicy.supports_agentless,
-    selectedSetupTechnology,
-    updateAgentPolicies,
-    setNewAgentPolicy,
-    agentPolicies,
-    setSelectedSetupTechnology,
-    updatePackagePolicy,
-    packageInfo,
-  ]);
+  const agentlessPolicyName = getAgentlessAgentPolicyNameFromPackagePolicyName(packagePolicy.name);
 
   const handleSetupTechnologyChange = useCallback(
     (setupTechnology: SetupTechnology) => {
@@ -157,43 +100,66 @@ export function useSetupTechnology({
       }
 
       if (setupTechnology === SetupTechnology.AGENTLESS) {
-        if (isAgentlessEnabled) {
-          const agentlessPolicy = {
-            ...newAgentlessPolicy,
-          } as NewAgentPolicy;
-
-          setNewAgentPolicy(agentlessPolicy);
-          setNewAgentlessPolicy(agentlessPolicy);
-          setSelectedPolicyTab(SelectedPolicyTab.NEW);
-          updateAgentPolicies([agentlessPolicy] as AgentPolicy[]);
-        }
-        updatePackagePolicy({
-          supports_agentless: true,
-        });
+        setSelectedPolicyTab(SelectedPolicyTab.NEW);
       } else if (setupTechnology === SetupTechnology.AGENT_BASED) {
-        setNewAgentPolicy({
-          ...newAgentBasedPolicy.current,
-          supports_agentless: false,
-        });
-        updatePackagePolicy({
-          supports_agentless: false,
-        });
         setSelectedPolicyTab(SelectedPolicyTab.NEW);
-        updateAgentPolicies([newAgentBasedPolicy.current] as AgentPolicy[]);
       }
       setSelectedSetupTechnology(setupTechnology);
     },
-    [
-      isAgentlessEnabled,
-      selectedSetupTechnology,
-      updatePackagePolicy,
-      setNewAgentPolicy,
-      newAgentlessPolicy,
-      setSelectedPolicyTab,
-      updateAgentPolicies,
-    ]
+    [isAgentlessEnabled, selectedSetupTechnology, setSelectedPolicyTab, setSelectedSetupTechnology]
   );
 
+  if (
+    isEditPage &&
+    agentPolicies &&
+    agentPolicies.some((policy) => policy.supports_agentless) &&
+    selectedSetupTechnology === SetupTechnology.AGENT_BASED
+  ) {
+    setSelectedSetupTechnology(SetupTechnology.AGENTLESS);
+  }
+
+  if (
+    !isEditPage &&
+    packagePolicy &&
+    isAgentlessEnabled &&
+    selectedSetupTechnology === SetupTechnology.AGENTLESS &&
+    (!currentAgentPolicy.supports_agentless || agentlessPolicyName !== currentAgentPolicy.name)
+  ) {
+    const nextNewAgentlessPolicy = {
+      ...generateNewAgentPolicyWithDefaults({
+        inactivity_timeout: 3600,
+        supports_agentless: true,
+        monitoring_enabled: ['logs', 'metrics'],
+      }),
+      name: agentlessPolicyName,
+      ...getAdditionalAgentlessPolicyInfo(packageInfo),
+    };
+    setCurrentAgentPolicy(nextNewAgentlessPolicy);
+    setNewAgentPolicy(nextNewAgentlessPolicy as NewAgentPolicy);
+    updateAgentPolicies([nextNewAgentlessPolicy] as AgentPolicy[]);
+    updatePackagePolicy({
+      supports_agentless: true,
+    });
+  }
+
+  if (
+    !isEditPage &&
+    selectedSetupTechnology !== SetupTechnology.AGENTLESS &&
+    (currentAgentPolicy.supports_agentless || packagePolicy.supports_agentless)
+  ) {
+    const nextNewAgentlessPolicy = {
+      ...orginalAgentPolicyRef.current,
+      supports_agentless: false,
+    };
+    setCurrentAgentPolicy(nextNewAgentlessPolicy);
+    setNewAgentPolicy(nextNewAgentlessPolicy);
+    updateAgentPolicies([nextNewAgentlessPolicy] as AgentPolicy[]);
+    updatePackagePolicy({
+      supports_agentless: false,
+    });
+    // }
+  }
+
   return {
     handleSetupTechnologyChange,
     selectedSetupTechnology,
@@ -203,11 +169,18 @@ export function useSetupTechnology({
 
 const isAgentlessSetupDefault = (packageInfo?: PackageInfo) => {
   // placegolder for the logic to determine if the agentless setup is the default
-  return packageInfo ? false : false;
+  // return packageInfo ? false : false;
+  return false;
 };
 
 const getAdditionalAgentlessPolicyInfo = (packageInfo?: PackageInfo) => {
-  const agentlessPolicyTemplate = packageInfo?.policy_templates?.find(
+  if (
+    !packageInfo?.policy_templates &&
+    !packageInfo?.policy_templates?.some((policy) => policy.deployment_modes)
+  ) {
+    return undefined;
+  }
+  const agentlessPolicyTemplate = packageInfo.policy_templates.find(
     (policy) => policy.deployment_modes
   );
 

diff --git a/.../fleet/sections/agent_policy/create_package_policy_page/single_page_layout/index.test.tsx b/.../fleet/sections/agent_policy/create_package_policy_page/single_page_layout/index.test.tsx
@@ -83,7 +83,13 @@ jest.mock('../../../../hooks', () => {
       data: { item: {} },
     }),
     sendCreatePackagePolicy: jest.fn().mockResolvedValue({
-      data: { item: { id: 'policy-1', inputs: [], policy_ids: ['agent-policy-1'] } },
+      data: {
+        item: {
+          id: 'policy-1',
+          inputs: [],
+          policy_ids: ['agent-policy-1'],
+        },
+      },
     }),
     sendCreateAgentPolicy: jest.fn().mockResolvedValue({
       data: { item: { id: 'agent-policy-2', name: 'Agent policy 2', namespace: 'default' } },
@@ -190,7 +196,16 @@ describe('When on the package policy create page', () => {
                 },
               ],
               multiple: true,
-              deployment_modes: { agentless: { enabled: options?.agentlessEnabled } },
+              deployment_modes: options?.agentlessEnabled
+                ? {
+                    agentless: {
+                      enabled: true,
+                      organization: 'org',
+                      division: 'division',
+                      team: 'team',
+                    },
+                  }
+                : { agentless: { enabled: false } },
             },
           ],
           data_streams: [
@@ -740,8 +755,13 @@ describe('When on the package policy create page', () => {
       });
 
       test('should create agentless agent policy and package policy when in cloud and agentless API url is set', async () => {
+        await waitFor(() => {
+          expect(renderResult.getByTestId(SETUP_TECHNOLOGY_SELECTOR_TEST_SUBJ)).toBeInTheDocument();
+        });
+
         fireEvent.click(renderResult.getByTestId(SETUP_TECHNOLOGY_SELECTOR_TEST_SUBJ));
         fireEvent.click(renderResult.getAllByText('Agentless')[0]);
+
         await act(async () => {
           fireEvent.click(renderResult.getByText(/Save and continue/).closest('button')!);
         });