Use TypeScript and adapt to changed override API

src/gmp/__tests__/gmp.test.ts

@@ -217,6 +217,8 @@ describe('Gmp tests', () => {
     'nvts',
     'ociimagetarget',
     'ociimagetargets',
+    'override',
+    'overrides',
     'performance',
     'webapplicationtarget',
     'webapplicationtargets',
@@ -270,8 +272,6 @@ describe('Gmp tests', () => {
     'license',
     'operatingsystem',
     'operatingsystems',
-    'override',
-    'overrides',
     'scanconfig',
     'scanconfigs',
     'schedule',

src/gmp/commands/__tests__/override.test.ts

@@ -0,0 +1,159 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, test, expect} from '@gsa/testing';
+import OverrideCommand from 'gmp/commands/override';
+import {
+  createHttp,
+  createEntityResponse,
+  createActionResultResponse,
+} from 'gmp/commands/testing';
+import {
+  ACTIVE_YES_FOR_NEXT_VALUE,
+  ACTIVE_YES_UNTIL_VALUE,
+  ANY,
+  MANUAL,
+} from 'gmp/models/override';
+
+describe('OverrideCommand tests', () => {
+  test('should request single override', async () => {
+    const response = createEntityResponse('override', {_id: 'foo'});
+    const fakeHttp = createHttp(response);
+
+    const cmd = new OverrideCommand(fakeHttp);
+    const resp = await cmd.get({id: 'foo'});
+    expect(fakeHttp.request).toHaveBeenCalledWith('get', {
+      args: {
+        cmd: 'get_override',
+        override_id: 'foo',
+      },
+    });
+    const {data} = resp;
+    expect(data.id).toEqual('foo');
+  });
+
+  test('should create a simple override', async () => {
+    const response = createActionResultResponse();
+    const fakeHttp = createHttp(response);
+
+    const cmd = new OverrideCommand(fakeHttp);
+    const resp = await cmd.create({
+      text: 'override text',
+      oid: 'oid',
+    });
+    expect(fakeHttp.request).toHaveBeenCalledWith('post', {
+      data: {
+        cmd: 'create_override',
+        new_severity: -1,
+        oid: 'oid',
+        text: 'override text',
+      },
+    });
+    const {data} = resp;
+    expect(data.id).toEqual('foo');
+  });
+
+  test('should create an override with details', async () => {
+    const response = createActionResultResponse();
+    const fakeHttp = createHttp(response);
+
+    const cmd = new OverrideCommand(fakeHttp);
+    const resp = await cmd.create({
+      active: ACTIVE_YES_FOR_NEXT_VALUE,
+      customSeverity: true,
+      days: 15,
+      hostsManual: 'host1,host2',
+      hosts: MANUAL,
+      newSeverity: 4.5,
+      oid: 'oid',
+      port: MANUAL,
+      portManual: '22/tcp',
+      resultId: MANUAL,
+      resultUuid: 'result-uuid',
+      severity: 'High',
+      taskId: MANUAL,
+      taskUuid: 'task-uuid',
+      text: 'override text',
+    });
+    expect(fakeHttp.request).toHaveBeenCalledWith('post', {
+      data: {
+        active: '1',
+        cmd: 'create_override',
+        hosts: 'host1,host2',
+        new_severity: 4.5,
+        oid: 'oid',
+        port: '22/tcp',
+        result_id: 'result-uuid',
+        severity: 'High',
+        task_id: 'task-uuid',
+        text: 'override text',
+      },
+    });
+    const {data} = resp;
+    expect(data.id).toEqual('foo');
+  });
+
+  test('should save a simple override', async () => {
+    const response = createActionResultResponse();
+    const fakeHttp = createHttp(response);
+
+    const cmd = new OverrideCommand(fakeHttp);
+    const resp = await cmd.save({
+      id: 'foo',
+      text: 'updated override text',
+      oid: 'oid',
+    });
+    expect(fakeHttp.request).toHaveBeenCalledWith('post', {
+      data: {
+        cmd: 'save_override',
+        new_severity: -1,
+        oid: 'oid',
+        override_id: 'foo',
+        text: 'updated override text',
+      },
+    });
+    const {data} = resp;
+    expect(data.id).toEqual('foo');
+  });
+
+  test('should allow to save an override with details', async () => {
+    const response = createActionResultResponse();
+    const fakeHttp = createHttp(response);
+
+    const cmd = new OverrideCommand(fakeHttp);
+    const resp = await cmd.save({
+      id: 'foo',
+      active: ACTIVE_YES_UNTIL_VALUE,
+      days: 15,
+      hostsManual: 'host1,host2',
+      hosts: MANUAL,
+      newSeverityFromList: 0,
+      oid: 'oid',
+      port: MANUAL,
+      portManual: '22/tcp',
+      resultId: ANY,
+      resultUuid: 'result-uuid',
+      severity: 'High',
+      taskId: ANY,
+      taskUuid: 'task-uuid',
+      text: 'updated override text',
+    });
+    expect(fakeHttp.request).toHaveBeenCalledWith('post', {
+      data: {
+        active: 15,
+        cmd: 'save_override',
+        hosts: 'host1,host2',
+        new_severity: 0,
+        oid: 'oid',
+        override_id: 'foo',
+        port: '22/tcp',
+        severity: 'High',
+        text: 'updated override text',
+      },
+    });
+    const {data} = resp;
+    expect(data.id).toEqual('foo');
+  });
+});

src/gmp/commands/__tests__/overrides.test.ts

@@ -0,0 +1,155 @@
+/* SPDX-FileCopyrightText: 2026 Greenbone AG
+ *
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import {describe, test, expect} from '@gsa/testing';
+import OverridesCommand from 'gmp/commands/overrides';
+import {
+  createHttp,
+  createEntitiesResponse,
+  createAggregatesResponse,
+} from 'gmp/commands/testing';
+import Override from 'gmp/models/override';
+
+describe('OverridesCommand tests', () => {
+  test('should fetch overrides with default params', async () => {
+    const response = createEntitiesResponse('override', [
+      {_id: '1', text: 'Override 1'},
+      {_id: '2', text: 'Override 2'},
+    ]);
+    const fakeHttp = createHttp(response);
+
+    const cmd = new OverridesCommand(fakeHttp);
+    const result = await cmd.get();
+    expect(fakeHttp.request).toHaveBeenCalledWith('get', {
+      args: {cmd: 'get_overrides', details: 1},
+    });
+    expect(result.data).toEqual([
+      new Override({id: '1', text: 'Override 1'}),
+      new Override({id: '2', text: 'Override 2'}),
+    ]);
+  });
+
+  test('should fetch overrides with custom filter', async () => {
+    const response = createEntitiesResponse('override', [
+      {_id: '3', text: 'Custom Override'},
+    ]);
+    const fakeHttp = createHttp(response);
+
+    const cmd = new OverridesCommand(fakeHttp);
+    const result = await cmd.get({filter: "text='Custom Override'"});
+    expect(fakeHttp.request).toHaveBeenCalledWith('get', {
+      args: {
+        cmd: 'get_overrides',
+        filter: "text='Custom Override'",
+        details: 1,
+      },
+    });
+    expect(result.data).toEqual([
+      new Override({id: '3', text: 'Custom Override'}),
+    ]);
+  });
+
+  test('should fetch all overrides', async () => {
+    const response = createEntitiesResponse('override', [
+      {_id: '1', text: 'Override 1'},
+      {_id: '2', text: 'Override 2'},
+    ]);
+    const fakeHttp = createHttp(response);
+
+    const cmd = new OverridesCommand(fakeHttp);
+    const result = await cmd.getAll();
+    expect(fakeHttp.request).toHaveBeenCalledWith('get', {
+      args: {cmd: 'get_overrides', filter: 'first=1 rows=-1', details: 1},
+    });
+    expect(result.data).toEqual([
+      new Override({id: '1', text: 'Override 1'}),
+      new Override({id: '2', text: 'Override 2'}),
+    ]);
+  });
+
+  test('should fetch active days aggregates', async () => {
+    const response = createAggregatesResponse({
+      group: [
+        {value: 1, count: 5},
+        {value: 2, count: 3},
+      ],
+    });
+    const fakeHttp = createHttp(response);
+
+    const cmd = new OverridesCommand(fakeHttp);
+    const result = await cmd.getActiveDaysAggregates();
+    expect(fakeHttp.request).toHaveBeenCalledWith('get', {
+      args: {
+        cmd: 'get_aggregate',
+        aggregate_type: 'override',
+        details: 1,
+        group_column: 'active_days',
+        max_groups: '250',
+      },
+    });
+    expect(result.data).toEqual({
+      groups: [
+        {value: 1, count: 5},
+        {value: 2, count: 3},
+      ],
+    });
+  });
+
+  test('should fetch created aggregates', async () => {
+    const response = createAggregatesResponse({
+      group: [
+        {value: '2024-01-01', count: 10},
+        {value: '2024-01-02', count: 7},
+      ],
+    });
+    const fakeHttp = createHttp(response);
+
+    const cmd = new OverridesCommand(fakeHttp);
+    const result = await cmd.getCreatedAggregates();
+    expect(fakeHttp.request).toHaveBeenCalledWith('get', {
+      args: {
+        cmd: 'get_aggregate',
+        aggregate_type: 'override',
+        details: 1,
+        group_column: 'created',
+        aggregate_mode: 'count',
+      },
+    });
+    expect(result.data).toEqual({
+      groups: [
+        {value: '2024-01-01', count: 10},
+        {value: '2024-01-02', count: 7},
+      ],
+    });
+  });
+
+  test('should fetch word counts aggregates', async () => {
+    const response = createAggregatesResponse({
+      group: [
+        {value: 'vulnerability', count: 15},
+        {value: 'false positive', count: 8},
+      ],
+    });
+    const fakeHttp = createHttp(response);
+
+    const cmd = new OverridesCommand(fakeHttp);
+    const result = await cmd.getWordCountsAggregates();
+    expect(fakeHttp.request).toHaveBeenCalledWith('get', {
+      args: {
+        cmd: 'get_aggregate',
+        aggregate_type: 'override',
+        details: 1,
+        group_column: 'text',
+        aggregate_mode: 'word_counts',
+      },
+    });
+    expect(result.data).toEqual({
+      groups: [
+        {value: 'vulnerability', count: 15},
+        {value: 'false positive', count: 8},
+      ],
+    });
+  });
+});