[Fleet] Display message explaining why agent is not upgradeable

x-pack/plugins/fleet/common/services/is_agent_upgradeable.test.ts

@@ -11,6 +11,7 @@ import {
   getRecentUpgradeInfoForAgent,
   isAgentUpgradeable,
   isAgentUpgrading,
+  getNotUpgradeableMessage,
 } from './is_agent_upgradeable';
 
 const getAgent = ({
@@ -241,6 +242,154 @@ describe('Fleet - isAgentUpgradeable', () => {
   });
 });
 
+describe('Fleet - getNotUpgradeableMessage', () => {
+  it('if agent reports not upgradeable with agent version < latest agent version', () => {
+    expect(getNotUpgradeableMessage(getAgent({ version: '7.9.0' }), '8.0.0')).toBe(
+      'agent is marked as not upgradeable in elastic-agent.'
+    );
+  });
+
+  it('if agent reports not upgradeable with agent version > latest agent version', () => {
+    expect(getNotUpgradeableMessage(getAgent({ version: '8.0.0' }), '7.9.0')).toBe(
+      'agent is marked as not upgradeable in elastic-agent.'
+    );
+  });
+
+  it('returns false if agent reports not upgradeable with agent version === latest agent version', () => {
+    expect(getNotUpgradeableMessage(getAgent({ version: '8.0.0' }), '8.0.0')).toBe(
+      'agent is marked as not upgradeable in elastic-agent.'
+    );
+  });
+
+  it('if agent reports upgradeable, with agent version === latest agent version', () => {
+    expect(
+      getNotUpgradeableMessage(getAgent({ version: '8.0.0', upgradeable: true }), '8.0.0')
+    ).toBe('agent version is already the latest.');
+  });
+
+  it('if agent reports upgradeable, with agent version > latest agent version', () => {
+    expect(
+      getNotUpgradeableMessage(getAgent({ version: '8.0.0', upgradeable: true }), '7.9.0')
+    ).toBe('agent version is lower than latest.');
+  });
+
+  it('if agent reports upgradeable, but agent is unenrolling', () => {
+    expect(
+      getNotUpgradeableMessage(
+        getAgent({ version: '7.9.0', upgradeable: true, unenrolling: true }),
+        '8.0.0'
+      )
+    ).toBe('agent unenrollment was started.');
+  });
+
+  it('if agent reports upgradeable, but agent is unenrolled', () => {
+    expect(
+      getNotUpgradeableMessage(
+        getAgent({ version: '7.9.0', upgradeable: true, unenrolled: true }),
+        '8.0.0'
+      )
+    ).toBe('agent was unenrolled.');
+  });
+
+  it('Returns no error message if agent reports upgradeable, with agent version < latest agent version', () => {
+    expect(
+      getNotUpgradeableMessage(getAgent({ version: '7.9.0', upgradeable: true }), '8.0.0')
+    ).toBeUndefined();
+  });
+
+  it('if agent reports upgradeable, with agent snapshot version === latest agent version', () => {
+    expect(
+      getNotUpgradeableMessage(getAgent({ version: '7.9.0-SNAPSHOT', upgradeable: true }), '7.9.0')
+    ).toBe('agent version is already the latest.');
+  });
+
+  it('it does not return message if agent reports upgradeable, with upgrade to agent snapshot version newer than latest agent version', () => {
+    expect(
+      getNotUpgradeableMessage(
+        getAgent({ version: '8.10.2', upgradeable: true }),
+        '8.10.2',
+        '8.11.0-SNAPSHOT'
+      )
+    ).toBeUndefined();
+  });
+
+  it('if agent reports upgradeable, with target version < current agent version ', () => {
+    expect(
+      getNotUpgradeableMessage(getAgent({ version: '7.9.0', upgradeable: true }), '8.0.0', '7.8.0')
+    ).toBe('the selected version is lower than the current version.');
+  });
+
+  it('if agent reports upgradeable, with target version == current agent version ', () => {
+    expect(
+      getNotUpgradeableMessage(getAgent({ version: '7.9.0', upgradeable: true }), '8.0.0', '7.9.0')
+    ).toBe('agent is already at the selected version.');
+  });
+
+  it('if agent with no upgrade details reports upgradeable, but is already upgrading', () => {
+    expect(
+      getNotUpgradeableMessage(
+        getAgent({ version: '7.9.0', upgradeable: true, upgrading: true }),
+        '8.0.0'
+      )
+    ).toBe('upgrade was already started.');
+  });
+
+  it('if agent reports upgradeable, but has an upgrade status other than failed', () => {
+    expect(
+      getNotUpgradeableMessage(
+        getAgent({
+          version: '7.9.0',
+          upgradeable: true,
+          upgradeDetails: {
+            target_version: '8.0.0',
+            action_id: 'XXX',
+            state: 'UPG_REQUESTED',
+          },
+        }),
+        '8.0.0'
+      )
+    ).toBe('upgrade was already started.');
+  });
+
+  it('it does not return a message if agent reports upgradeable and has a failed upgrade status', () => {
+    expect(
+      getNotUpgradeableMessage(
+        getAgent({
+          version: '7.9.0',
+          upgradeable: true,
+          upgradeDetails: {
+            target_version: '8.0.0',
+            action_id: 'XXX',
+            state: 'UPG_FAILED',
+            metadata: {
+              error_msg: 'Upgrade timed out',
+            },
+          },
+        }),
+        '8.0.0'
+      )
+    ).toBeUndefined();
+  });
+
+  it('if the agent reports upgradeable but was upgraded less than 10 minutes ago', () => {
+    expect(
+      getNotUpgradeableMessage(
+        getAgent({ version: '7.9.0', upgradeable: true, minutesSinceUpgrade: 9 }),
+        '8.0.0'
+      )
+    ).toBe('the agent has been upgraded recently. Please wait.');
+  });
+
+  it('if agent reports upgradeable and was upgraded more than 10 minutes ago', () => {
+    expect(
+      getNotUpgradeableMessage(
+        getAgent({ version: '7.9.0', upgradeable: true, minutesSinceUpgrade: 11 }),
+        '8.0.0'
+      )
+    ).toBeUndefined();
+  });
+});
+
 describe('hasAgentBeenUpgradedRecently', () => {
   it('returns true if the agent was upgraded less than 10 minutes ago', () => {
     expect(

x-pack/plugins/fleet/common/services/is_agent_upgradeable.ts

@@ -8,6 +8,7 @@
 import semverCoerce from 'semver/functions/coerce';
 import semverLt from 'semver/functions/lt';
 import semverGt from 'semver/functions/gt';
+import semverEq from 'semver/functions/eq';
 
 import type { Agent } from '../types';
 
@@ -42,6 +43,62 @@ export function isAgentUpgradeable(
   return isAgentVersionLessThanLatest(agentVersion, latestAgentVersion);
 }
 
+// Based on the previous, returns a detailed message explaining why the agent is not upgradeable
+export const getNotUpgradeableMessage = (
+  agent: Agent,
+  latestAgentVersion?: string,
+  versionToUpgrade?: string
+) => {
+  let agentVersion: string;
+  if (typeof agent?.local_metadata?.elastic?.agent?.version === 'string') {
+    agentVersion = agent.local_metadata.elastic.agent.version;
+  } else {
+    return `agent version is missing.`;
+  }
+  if (agent.unenrolled_at) {
+    return `agent was unenrolled.`;
+  }
+  if (agent.unenrollment_started_at) {
+    return `agent unenrollment was started.`;
+  }
+  if (!agent.local_metadata.elastic.agent.upgradeable) {
+    return `agent is marked as not upgradeable in elastic-agent.`;
+  }
+  if (isAgentUpgrading(agent)) {
+    return `upgrade was already started.`;
+  }
+  if (getRecentUpgradeInfoForAgent(agent).hasBeenUpgradedRecently) {
+    return `the agent has been upgraded recently. Please wait.`;
+  }
+  const agentVersionNumber = semverCoerce(agentVersion);
+  if (!agentVersionNumber) return 'agent version is not valid.';
+
+  if (versionToUpgrade !== undefined) {
+    const versionToUpgradeNumber = semverCoerce(versionToUpgrade);
+    if (!versionToUpgradeNumber) return 'the selected version is not valid.';
+
+    if (semverEq(agentVersionNumber, versionToUpgradeNumber))
+      return `agent is already at the selected version.`;
+
+    if (semverLt(versionToUpgradeNumber, agentVersionNumber))
+      return `the selected version is lower than the current version.`;
+    // explicitly allow this case - the agent is upgradeable
+    if (semverGt(versionToUpgradeNumber, agentVersionNumber)) return undefined;
+  }
+
+  const latestAgentVersionNumber = semverCoerce(latestAgentVersion);
+  if (!latestAgentVersionNumber) return 'latest version is not valid.';
+
+  if (semverEq(agentVersionNumber, latestAgentVersionNumber))
+    return `agent version is already the latest.`;
+
+  if (semverGt(agentVersionNumber, latestAgentVersionNumber))
+    return `agent version is lower than latest.`;
+
+  // in all the other cases, the agent is upgradeable; don't return any message.
+  return undefined;
+};
+
 const isAgentVersionLessThanLatest = (agentVersion: string, latestAgentVersion: string) => {
   // make sure versions are only the number before comparison
   const agentVersionNumber = semverCoerce(agentVersion);

x-pack/plugins/fleet/public/applications/fleet/sections/agents/components/agent_upgrade_modal/index.test.tsx

@@ -29,6 +29,7 @@ jest.mock('../../../../hooks', () => {
     }),
     sendPostBulkAgentUpgrade: jest.fn(),
     useAgentVersion: jest.fn().mockReturnValue('8.10.2'),
+    useKibanaVersion: jest.fn().mockReturnValue('8.10.2'),
   };
 });
 
@@ -198,4 +199,26 @@ describe('AgentUpgradeAgentModal', () => {
       expect(el).toBeDisabled();
     });
   });
+
+  it('should disable submit button and display a warning for a single agent that is not upgradeable', async () => {
+    const { utils } = renderAgentUpgradeAgentModal({
+      agents: [
+        {
+          status: 'offline',
+          upgrade_started_at: '2022-11-21T12:27:24Z',
+          id: 'agent1',
+          local_metadata: { elastic: { agent: { version: '8.9.0' } } },
+        },
+      ] as any,
+      agentCount: 2,
+    });
+    await waitFor(() => {
+      expect(utils.queryByText(/The selected agent is not upgradeable/)).toBeInTheDocument();
+      expect(
+        utils.queryByText(/Reason: agent is marked as not upgradeable in elastic-agent./)
+      ).toBeInTheDocument();
+      const el = utils.getByTestId('confirmModalConfirmButton');
+      expect(el).toBeDisabled();
+    });
+  });
 });