@mcp-abap-adt/adt-clients 37.0.0 → 37.1.0

package/README.md

@@ -157,7 +157,7 @@ npm install @mcp-abap-adt/adt-clients
    - Typed execution API based on `IExecutor`
    - Executors:
      - `getClassExecutor()` for `classrun`
-     - `getClassTestRunner()` for a class's ABAP Unit tests: `run`, `getStatus`, `getResult`
+     - `getClassTestRunner()` for a class's ABAP Unit tests: `run`, `getStatus`, `getResult` (asynchronous, the default), or `runSync` (synchronous)
      - `getProgramTestRunner()` for a report's ABAP Unit tests, in its source or its includes
      - `getFunctionGroupTestRunner()` / `getFunctionModuleTestRunner()` for a function group's tests, or the ones exercising one module
      - `getProgramExecutor()` for `programrun` (on-premise systems)
@@ -440,6 +440,28 @@ const result = await runner.getResult(runId, { analyse: analyseUnitTest });
 `{ containerClass, testClass }`. On a legacy system the runner's `run` answers
 the finished result, and `getStatus`/`getResult` refuse without a request.
 
+**The synchronous runner, `runSync`.** `run` starts a run on
+`/sap/bc/adt/abapunit/runs`, which is then polled; that stays the default.
+`runSync` is the other runner ADT has — one `POST /sap/bc/adt/abapunit/testruns`
+answering the finished `aunit:runResult` — chosen explicitly by the caller.
+Some systems have only this one (an on-prem S/4HANA 2023, SAP_BASIS 758, was
+measured without `/abapunit/runs`); whether a system has `/runs` is in its
+discovery, and reading that is the caller's — the library picks no runner by
+release or by discovery.
+
+```typescript
+const result = await runner.runSync('ZCL_UNDER_TEST', { analyse: analyseUnitTest });
+```
+
+Its answer is read by the runner's `result` strategy, the one `getResult` uses:
+on the measured systems (on premise and ABAP Cloud, 2026-10-22) both runners
+answer the same document — `aunit:runResult` in `http://www.sap.com/adt/aunit`
+— with the same methods and alerts. Two differences: the endpoint addresses
+whole classes, so `{ containerClass, testClass }` targets run each distinct
+container whole; and `title` and `context` are not sent. Scope, risk levels and
+durations are, with `run`'s defaults. On a legacy system `runSync` is the
+request `run` already sends there, read by `result`.
+
 A report's tests are local classes in its source or in an include it pulls in —
 written through `getProgram().update()` or `getInclude().update()` — and run
 through `executor.getProgramTestRunner().run(programName)`, with the same

package/dist/core/class/index.d.ts

@@ -6,6 +6,6 @@ export { AdtLocalDefinitions, type ILocalDefinitionsConfig, } from './AdtLocalDe
 export { AdtLocalMacros, type ILocalMacrosConfig } from './AdtLocalMacros';
 export { AdtLocalTestClass, type ILocalTestClassConfig, } from './AdtLocalTestClass';
 export { AdtLocalTypes, type ILocalTypesConfig } from './AdtLocalTypes';
-export { getClassUnitTestResult, getClassUnitTestStatus, IClassUnitTestDefinition, IClassUnitTestRunOptions, startClassUnitTestRun, startClassUnitTestRunByObject, } from './run';
+export { getClassUnitTestResult, getClassUnitTestStatus, IClassUnitTestDefinition, IClassUnitTestRunOptions, startClassUnitTestRun, startClassUnitTestRunByObject, startClassUnitTestRunSync, } from './run';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/class/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/class/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EACL,mBAAmB,EACnB,KAAK,uBAAuB,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,EACL,iBAAiB,EACjB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,EACxB,qBAAqB,EACrB,6BAA6B,GAC9B,MAAM,OAAO,CAAC;AACf,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/class/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EACL,mBAAmB,EACnB,KAAK,uBAAuB,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,EACL,iBAAiB,EACjB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,EACxB,qBAAqB,EACrB,6BAA6B,EAC7B,yBAAyB,GAC1B,MAAM,OAAO,CAAC;AACf,cAAc,SAAS,CAAC"}

package/dist/core/class/index.js

@@ -17,7 +17,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startClassUnitTestRunByObject = exports.startClassUnitTestRun = exports.getClassUnitTestStatus = exports.getClassUnitTestResult = exports.AdtLocalTypes = exports.AdtLocalTestClass = exports.AdtLocalMacros = exports.AdtLocalDefinitions = exports.AdtClass = void 0;
+exports.startClassUnitTestRunSync = exports.startClassUnitTestRunByObject = exports.startClassUnitTestRun = exports.getClassUnitTestStatus = exports.getClassUnitTestResult = exports.AdtLocalTypes = exports.AdtLocalTestClass = exports.AdtLocalMacros = exports.AdtLocalDefinitions = exports.AdtClass = void 0;
 var AdtClass_1 = require("./AdtClass");
 Object.defineProperty(exports, "AdtClass", { enumerable: true, get: function () { return AdtClass_1.AdtClass; } });
 var AdtLocalDefinitions_1 = require("./AdtLocalDefinitions");
@@ -33,4 +33,5 @@ Object.defineProperty(exports, "getClassUnitTestResult", { enumerable: true, get
 Object.defineProperty(exports, "getClassUnitTestStatus", { enumerable: true, get: function () { return run_1.getClassUnitTestStatus; } });
 Object.defineProperty(exports, "startClassUnitTestRun", { enumerable: true, get: function () { return run_1.startClassUnitTestRun; } });
 Object.defineProperty(exports, "startClassUnitTestRunByObject", { enumerable: true, get: function () { return run_1.startClassUnitTestRunByObject; } });
+Object.defineProperty(exports, "startClassUnitTestRunSync", { enumerable: true, get: function () { return run_1.startClassUnitTestRunSync; } });
 __exportStar(require("./types"), exports);

package/dist/core/class/run.d.ts

@@ -61,4 +61,39 @@ export declare const getClassUnitTestResult: typeof getUnitTestRunResult;
  * container runs without the caller naming one.
  */
 export declare function startClassUnitTestRunByObject(connection: IAbapConnection, className: string, options?: IClassUnitTestRunOptions): Promise<IAdtWireResponse>;
+/**
+ * Run the ABAP Unit tests of whole classes and answer the finished result —
+ * `POST /sap/bc/adt/abapunit/testruns`, one request, no run to poll.
+ *
+ * The one implementation of this endpoint: the regular runner's `runSync` and
+ * the legacy runner's `run` both send it.
+ *
+ * **Measured:** synchronous on a modern and a legacy on-prem system, over HTTP
+ * and over RFC — `<aunit:runResult>` in the POST's answer, no `Location` — and
+ * the typed and `application/xml` bodies byte-identical; the legacy system
+ * ignores a typed `Accept` and answers `application/xml` either way. Advertised
+ * (2026-10-22) by an on-prem system and an ABAP Cloud system alike, beside
+ * `/abapunit/runs`; and on an on-prem S/4HANA 2023 that has no `/runs` at all
+ * (fr0ster/mcp-abap-adt#286).
+ *
+ * **Reading the result: `kind` carries the distinction, `severity` does not.**
+ * A failed assertion and an uncaught exception both come back
+ * `severity="critical"`, so a parser classifying on severity reports a short
+ * dump as a failed test. `kind` separates them: `failedAssertion`,
+ * `exception`, `noTestClasses`.
+ *
+ * The format differs from `/runs`:
+ * - root `aunit:runConfiguration` in `http://www.sap.com/adt/aunit` (not
+ *   `aunit:run` in `http://www.sap.com/adt/api/aunit`);
+ * - objects by URI in `adtcore:objectReferences` — so a run covers whole
+ *   classes: the format has no way to name one test class inside its
+ *   container;
+ * - `application/xml` for `Content-Type` and `Accept`.
+ *
+ * `options` absent sends no `<options>` element — the body the legacy runner
+ * has always sent, unchanged. Given, the scope, risk levels and durations go in
+ * `<options>` with the same defaults `/runs` gets; `title` and `context` have
+ * no place in this format and are not sent.
+ */
+export declare function startClassUnitTestRunSync(connection: IAbapConnection, classNames: string[], options?: IClassUnitTestRunOptions): Promise<IAdtWireResponse>;
 //# sourceMappingURL=run.d.ts.map

package/dist/core/class/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/core/class/run.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,QAAQ,CAC5B,UAAU,EAAE,eAAe,EAC3B,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,OAAc,EACxB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,YAAY,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAoB3B;AAOD,YAAY,EACV,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,8BAA8B,CAAC;AAMtC,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EAErB,MAAM,oBAAoB,CAAC;AAE5B,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,eAAe,EAC3B,KAAK,EAAE,wBAAwB,EAAE,EACjC,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CA6C3B;AAED,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,6BAAuB,CAAC;AAE3D,qEAAqE;AACrE,eAAO,MAAM,sBAAsB,6BAAuB,CAAC;AAE3D;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,UAAU,EAAE,eAAe,EAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CAM3B"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/core/class/run.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAKjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,QAAQ,CAC5B,UAAU,EAAE,eAAe,EAC3B,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,OAAc,EACxB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,YAAY,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAoB3B;AAOD,YAAY,EACV,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,8BAA8B,CAAC;AAMtC,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EAErB,MAAM,oBAAoB,CAAC;AAE5B,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,eAAe,EAC3B,KAAK,EAAE,wBAAwB,EAAE,EACjC,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CA6C3B;AAED,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,6BAAuB,CAAC;AAE3D,qEAAqE;AACrE,eAAO,MAAM,sBAAsB,6BAAuB,CAAC;AAE3D;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,UAAU,EAAE,eAAe,EAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AASD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,yBAAyB,CAC7C,UAAU,EAAE,eAAe,EAC3B,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CA8B3B"}

package/dist/core/class/run.js

@@ -7,6 +7,8 @@ exports.getClassUnitTestResult = exports.getClassUnitTestStatus = void 0;
 exports.runClass = runClass;
 exports.startClassUnitTestRun = startClassUnitTestRun;
 exports.startClassUnitTestRunByObject = startClassUnitTestRunByObject;
+exports.startClassUnitTestRunSync = startClassUnitTestRunSync;
+const objects_1 = require("../../endpoints/objects");
 const passport_1 = require("../../runtime/debugger/passport");
 const xml_1 = require("../../utils/xml");
 /**
@@ -126,3 +128,89 @@ exports.getClassUnitTestResult = abapUnit_1.getUnitTestRunResult;
 async function startClassUnitTestRunByObject(connection, className, options) {
     return (0, abapUnit_1.startUnitTestRunByObject)(connection, { name: className, type: 'CLAS' }, options);
 }
+// =============================================================================
+// The synchronous runner: /abapunit/testruns
+// =============================================================================
+const CT_TESTRUNS = 'application/xml';
+const ACCEPT_TESTRUNS = 'application/xml';
+/**
+ * Run the ABAP Unit tests of whole classes and answer the finished result —
+ * `POST /sap/bc/adt/abapunit/testruns`, one request, no run to poll.
+ *
+ * The one implementation of this endpoint: the regular runner's `runSync` and
+ * the legacy runner's `run` both send it.
+ *
+ * **Measured:** synchronous on a modern and a legacy on-prem system, over HTTP
+ * and over RFC — `<aunit:runResult>` in the POST's answer, no `Location` — and
+ * the typed and `application/xml` bodies byte-identical; the legacy system
+ * ignores a typed `Accept` and answers `application/xml` either way. Advertised
+ * (2026-10-22) by an on-prem system and an ABAP Cloud system alike, beside
+ * `/abapunit/runs`; and on an on-prem S/4HANA 2023 that has no `/runs` at all
+ * (fr0ster/mcp-abap-adt#286).
+ *
+ * **Reading the result: `kind` carries the distinction, `severity` does not.**
+ * A failed assertion and an uncaught exception both come back
+ * `severity="critical"`, so a parser classifying on severity reports a short
+ * dump as a failed test. `kind` separates them: `failedAssertion`,
+ * `exception`, `noTestClasses`.
+ *
+ * The format differs from `/runs`:
+ * - root `aunit:runConfiguration` in `http://www.sap.com/adt/aunit` (not
+ *   `aunit:run` in `http://www.sap.com/adt/api/aunit`);
+ * - objects by URI in `adtcore:objectReferences` — so a run covers whole
+ *   classes: the format has no way to name one test class inside its
+ *   container;
+ * - `application/xml` for `Content-Type` and `Accept`.
+ *
+ * `options` absent sends no `<options>` element — the body the legacy runner
+ * has always sent, unchanged. Given, the scope, risk levels and durations go in
+ * `<options>` with the same defaults `/runs` gets; `title` and `context` have
+ * no place in this format and are not sent.
+ */
+async function startClassUnitTestRunSync(connection, classNames, options) {
+    const objectRefs = classNames
+        .map((name) => {
+        return `        <adtcore:objectReference adtcore:uri="${(0, xml_1.escapeXmlAttr)(objects_1.CLASS.uri(name))}"/>`;
+    })
+        .join('\n');
+    const xml = `<?xml version="1.0" encoding="UTF-8"?><aunit:runConfiguration xmlns:aunit="http://www.sap.com/adt/aunit">
+  <external>
+    <coverage active="false"/>
+  </external>
+${options ? testRunsOptions(options) : ''}  <adtcore:objectSets xmlns:adtcore="http://www.sap.com/adt/core">
+    <objectSet kind="inclusive">
+      <adtcore:objectReferences>
+${objectRefs}
+      </adtcore:objectReferences>
+    </objectSet>
+  </adtcore:objectSets>
+</aunit:runConfiguration>`;
+    return connection.makeAdtRequest({
+        url: '/sap/bc/adt/abapunit/testruns',
+        method: 'POST',
+        timeout: 0,
+        data: xml,
+        headers: {
+            'Content-Type': CT_TESTRUNS,
+            Accept: ACCEPT_TESTRUNS,
+        },
+    });
+}
+/**
+ * `<options>` of a `runConfiguration`, as Eclipse sends it. The scope's three
+ * flags are `testDeterminationStrategy`'s: own tests are `sameProgram`,
+ * foreign tests `assignedTests`, their preview `appendAssignedTestsPreview`.
+ */
+function testRunsOptions(options) {
+    const scope = options.scope ?? {};
+    const risk = options.riskLevel ?? {};
+    const duration = options.duration ?? {};
+    return `  <options>
+    <uriType value="semantic"/>
+    <testDeterminationStrategy sameProgram="${boolAttr(scope.ownTests, true)}" assignedTests="${boolAttr(scope.foreignTests, false)}" appendAssignedTestsPreview="${boolAttr(scope.addForeignTestsAsPreview, true)}"/>
+    <testRiskLevels harmless="${boolAttr(risk.harmless, true)}" dangerous="${boolAttr(risk.dangerous, true)}" critical="${boolAttr(risk.critical, true)}"/>
+    <testDurations short="${boolAttr(duration.short, true)}" medium="${boolAttr(duration.medium, true)}" long="${boolAttr(duration.long, true)}"/>
+    <withNavigationUri enabled="true"/>
+  </options>
+`;
+}

package/dist/executors/class/ClassTestRunner.d.ts

@@ -27,7 +27,12 @@ import { AbapUnitRunner, type IAbapUnitRunnerResults } from '../abapUnitRunner';
  * whose every test class runs.
  */
 export type IClassTestRunTarget = IClassUnitTestDefinition[] | string;
-/** One strategy per distinct answer: starting a run, polling it, its result. */
+/** The distinct containers a target names: what `/testruns` addresses. */
+export declare function containersOf(target: IClassTestRunTarget): string[];
+/**
+ * One strategy per distinct answer: starting a run, polling it, its result.
+ * `runSync` answers the result document itself, so it is read by `result`.
+ */
 export type IClassTestRunnerResults = IAbapUnitRunnerResults;
 /** The shipped default: documents as they arrived. */
 export declare const classTestRunnerDocuments: {
@@ -49,5 +54,26 @@ export declare class ClassTestRunner<R extends IClassTestRunnerResults = typeof
      * read as a failure.
      */
     run<E extends IAdtError = IAdtError>(target: IClassTestRunTarget, options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['run']>, E>>;
+    /**
+     * Run the tests and answer the finished result. One POST, to
+     * `/sap/bc/adt/abapunit/testruns` — the synchronous runner, beside the
+     * asynchronous `run` + `getStatus` + `getResult`, which stays the default.
+     *
+     * An explicit choice of the caller's: nothing here asks the system which
+     * runner it has. A system without `/abapunit/runs` (an on-prem S/4HANA 2023
+     * was measured with `/testruns` alone) needs this one; whether a system has
+     * it is in its discovery, which is the caller's to read.
+     *
+     * The answer is the `aunit:runResult` document, so it is read by this
+     * runner's `result` strategy — the one `getResult` uses — and a failing test
+     * is in it as an `alert`; whether that is a failure is `options.analyse`'s
+     * (`analyseUnitTest` from @mcp-abap-adt/adt-strategies reads it so).
+     *
+     * Differences from `run`: the endpoint addresses whole classes, so a target
+     * of test definitions runs each distinct container whole, and `title` and
+     * `context` are not sent; scope, risk levels and durations are, with the
+     * same defaults.
+     */
+    runSync<E extends IAdtError = IAdtError>(target: IClassTestRunTarget, options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['result']>, E>>;
 }
 //# sourceMappingURL=ClassTestRunner.d.ts.map

package/dist/executors/class/ClassTestRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClassTestRunner.d.ts","sourceRoot":"","sources":["../../../src/executors/class/ClassTestRunner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACxB,wBAAwB,EACxB,eAAe,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAG9D,OAAO,EACL,cAAc,EAEd,KAAK,sBAAsB,EAC5B,MAAM,mBAAmB,CAAC;AAE3B;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,wBAAwB,EAAE,GAAG,MAAM,CAAC;AAEtE,gFAAgF;AAChF,MAAM,MAAM,uBAAuB,GAAG,sBAAsB,CAAC;AAE7D,sDAAsD;AACtD,eAAO,MAAM,wBAAwB;;;;CAA0B,CAAC;AAEhE,qBAAa,eAAe,CACxB,CAAC,SAAS,uBAAuB,GAAG,OAAO,wBAAwB,CAErE,SAAQ,cAAc,CAAC,CAAC,CACxB,YACE,YAAY,CACV,mBAAmB,EACnB,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EACpB,wBAAwB,CACzB;gBAGD,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,EAEhB,OAAO,GAAE,CAA4C;IAKvD;;;;;;;;;;OAUG;IACG,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACvC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAUlD"}
+{"version":3,"file":"ClassTestRunner.d.ts","sourceRoot":"","sources":["../../../src/executors/class/ClassTestRunner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACxB,wBAAwB,EACxB,eAAe,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAM9D,OAAO,EACL,cAAc,EAEd,KAAK,sBAAsB,EAC5B,MAAM,mBAAmB,CAAC;AAE3B;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,wBAAwB,EAAE,GAAG,MAAM,CAAC;AAEtE,0EAA0E;AAC1E,wBAAgB,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,EAAE,CAIlE;AAED;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG,sBAAsB,CAAC;AAE7D,sDAAsD;AACtD,eAAO,MAAM,wBAAwB;;;;CAA0B,CAAC;AAEhE,qBAAa,eAAe,CACxB,CAAC,SAAS,uBAAuB,GAAG,OAAO,wBAAwB,CAErE,SAAQ,cAAc,CAAC,CAAC,CACxB,YACE,YAAY,CACV,mBAAmB,EACnB,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EACpB,wBAAwB,CACzB;gBAGD,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,EAEhB,OAAO,GAAE,CAA4C;IAKvD;;;;;;;;;;OAUG;IACG,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACvC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAWjD;;;;;;;;;;;;;;;;;;;OAmBG;IACG,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC3C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAarD"}

package/dist/executors/class/ClassTestRunner.js

@@ -21,9 +21,16 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassTestRunner = exports.classTestRunnerDocuments = void 0;
+exports.containersOf = containersOf;
 const run_1 = require("../../core/class/run");
 const adtResponse_1 = require("../../utils/adtResponse");
 const abapUnitRunner_1 = require("../abapUnitRunner");
+/** The distinct containers a target names: what `/testruns` addresses. */
+function containersOf(target) {
+    return typeof target === 'string'
+        ? [target]
+        : [...new Set(target.map((test) => test.containerClass))];
+}
 /** The shipped default: documents as they arrived. */
 exports.classTestRunnerDocuments = abapUnitRunner_1.abapUnitRunnerDocuments;
 class ClassTestRunner extends abapUnitRunner_1.AbapUnitRunner {
@@ -49,5 +56,29 @@ class ClassTestRunner extends abapUnitRunner_1.AbapUnitRunner {
         }
         return (0, adtResponse_1.answering)(() => (0, run_1.startClassUnitTestRun)(this.connection, target, options), this.results.run, options?.analyse);
     }
+    /**
+     * Run the tests and answer the finished result. One POST, to
+     * `/sap/bc/adt/abapunit/testruns` — the synchronous runner, beside the
+     * asynchronous `run` + `getStatus` + `getResult`, which stays the default.
+     *
+     * An explicit choice of the caller's: nothing here asks the system which
+     * runner it has. A system without `/abapunit/runs` (an on-prem S/4HANA 2023
+     * was measured with `/testruns` alone) needs this one; whether a system has
+     * it is in its discovery, which is the caller's to read.
+     *
+     * The answer is the `aunit:runResult` document, so it is read by this
+     * runner's `result` strategy — the one `getResult` uses — and a failing test
+     * is in it as an `alert`; whether that is a failure is `options.analyse`'s
+     * (`analyseUnitTest` from @mcp-abap-adt/adt-strategies reads it so).
+     *
+     * Differences from `run`: the endpoint addresses whole classes, so a target
+     * of test definitions runs each distinct container whole, and `title` and
+     * `context` are not sent; scope, risk levels and durations are, with the
+     * same defaults.
+     */
+    async runSync(target, options) {
+        const { analyse, ...runOptions } = options ?? {};
+        return (0, adtResponse_1.answering)(() => (0, run_1.startClassUnitTestRunSync)(this.connection, containersOf(target), runOptions), this.results.result, analyse);
+    }
 }
 exports.ClassTestRunner = ClassTestRunner;

package/dist/executors/class/ClassTestRunnerLegacy.d.ts

@@ -21,6 +21,12 @@ export declare class ClassTestRunnerLegacy<R extends IClassTestRunnerResults = t
      * result document itself, not an id.
      */
     run<E extends IAdtError = IAdtError>(target: IClassTestRunTarget, options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['run']>, E>>;
+    /**
+     * The same request as `run` — on a legacy system `run` is already the
+     * synchronous one — answered through the `result` strategy, as the regular
+     * runner's `runSync` is.
+     */
+    runSync<E extends IAdtError = IAdtError>(target: IClassTestRunTarget, options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['result']>, E>>;
     /**
      * Refused without a request: a legacy system finishes a run before it
      * answers and exposes no run to poll. `run`'s own answer is the result.

package/dist/executors/class/ClassTestRunnerLegacy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClassTestRunnerLegacy.d.ts","sourceRoot":"","sources":["../../../src/executors/class/ClassTestRunnerLegacy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,wBAAwB,EAEzB,MAAM,8BAA8B,CAAC;AAItC,OAAO,EACL,eAAe,EACf,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,qBAAqB,CAChC,CAAC,SAAS,uBAAuB,GAAG,OAAO,wBAAwB,CACnE,SAAQ,eAAe,CAAC,CAAC,CAAC;IAC1B;;;;;OAKG;IACY,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAChD,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAYjD;;;OAGG;IACY,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;IASD,0EAA0E;IAC3D,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;CAQF"}
+{"version":3,"file":"ClassTestRunnerLegacy.d.ts","sourceRoot":"","sources":["../../../src/executors/class/ClassTestRunnerLegacy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,wBAAwB,EAEzB,MAAM,8BAA8B,CAAC;AAItC,OAAO,EACL,eAAe,EACf,KAAK,wBAAwB,EAE7B,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,qBAAqB,CAChC,CAAC,SAAS,uBAAuB,GAAG,OAAO,wBAAwB,CACnE,SAAQ,eAAe,CAAC,CAAC,CAAC;IAC1B;;;;;OAKG;IACY,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAChD,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAUjD;;;;OAIG;IACY,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACpD,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAQpD;;;OAGG;IACY,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;IASD,0EAA0E;IAC3D,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;CAQF"}

package/dist/executors/class/ClassTestRunnerLegacy.js

@@ -15,7 +15,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassTestRunnerLegacy = void 0;
 const interfaces_adt_1 = require("@mcp-abap-adt/interfaces-adt");
-const runLegacy_1 = require("../../core/class/runLegacy");
+const run_1 = require("../../core/class/run");
 const adtResponse_1 = require("../../utils/adtResponse");
 const ClassTestRunner_1 = require("./ClassTestRunner");
 class ClassTestRunnerLegacy extends ClassTestRunner_1.ClassTestRunner {
@@ -26,10 +26,17 @@ class ClassTestRunnerLegacy extends ClassTestRunner_1.ClassTestRunner {
      * result document itself, not an id.
      */
     async run(target, options) {
-        const classNames = typeof target === 'string'
-            ? [target]
-            : [...new Set(target.map((test) => test.containerClass))];
-        return (0, adtResponse_1.answering)(() => (0, runLegacy_1.startClassUnitTestRunLegacy)(this.connection, classNames), this.results.run, options?.analyse);
+        // No options: the body a legacy system has always been sent — the
+        // `<options>` element `runSync` sends is unmeasured there.
+        return (0, adtResponse_1.answering)(() => (0, run_1.startClassUnitTestRunSync)(this.connection, (0, ClassTestRunner_1.containersOf)(target)), this.results.run, options?.analyse);
+    }
+    /**
+     * The same request as `run` — on a legacy system `run` is already the
+     * synchronous one — answered through the `result` strategy, as the regular
+     * runner's `runSync` is.
+     */
+    async runSync(target, options) {
+        return (0, adtResponse_1.answering)(() => (0, run_1.startClassUnitTestRunSync)(this.connection, (0, ClassTestRunner_1.containersOf)(target)), this.results.result, options?.analyse);
     }
     /**
      * Refused without a request: a legacy system finishes a run before it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-abap-adt/adt-clients",
-  "version": "37.0.0",
+  "version": "37.1.0",
   "description": "ADT clients for SAP ABAP systems - AdtClient and AdtRuntimeClient",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/core/class/runLegacy.d.ts

@@ -1,42 +0,0 @@
-/**
- * ABAP Unit test run operations for legacy systems (BASIS < 7.50)
- *
- * Legacy systems use:
- * - /sap/bc/adt/abapunit/testruns instead of /sap/bc/adt/abapunit/runs
- * - application/xml for Content-Type and Accept (not versioned vnd.sap.adt.api.abapunit.* types)
- */
-import type { IAbapConnection, IAdtWireResponse } from '@mcp-abap-adt/interfaces-adt-connection';
-/**
- * Start ABAP Unit test run on legacy systems
- * Uses /sap/bc/adt/abapunit/testruns endpoint with aunit:runConfiguration format
- *
- * There is only a start here. `getClassUnitTestStatusLegacy` and
- * `getClassUnitTestResultLegacy` polled `testruns/{runId}` and
- * `testruns/{runId}/results`, and were removed once the endpoint was measured:
- * the POST answers with the finished result, so there was never a run to poll.
- * Nothing called them — `ClassTestRunnerLegacy` serves both from the response the
- * POST returned — so they were an unmeasured contract kept alive by nobody
- * looking.
- *
- * **Reading the result: `kind` carries the distinction, `severity` does not.** A
- * failed assertion and an uncaught exception both come back
- * `severity="critical"`, measured on one release — so a parser classifying on
- * severity reports a short dump as a failed test. The field that separates them
- * is `kind`: `failedAssertion`, `exception`, `noTestClasses`.
- *
- * Also measured: this endpoint is **synchronous** on both a modern and a legacy
- * on-prem system, over HTTP and over RFC — `<aunit:runResult>` with no
- * `Location`, and the typed and `application/xml` bodies byte-identical. The
- * legacy system ignores the typed `Accept` altogether and answers
- * `application/xml` either way.
- *
- * Legacy format differs from modern:
- * - Root element: aunit:runConfiguration (not aunit:run)
- * - Namespace: http://www.sap.com/adt/aunit (not http://www.sap.com/adt/api/aunit)
- * - Objects via adtcore:objectReferences with URI (not aunit:tests with containerClass/class)
- *   — so a run covers whole classes: this format has no way to name one test
- *   class inside its container, and a caller's test class name is not sent.
- * - Content-Type/Accept: application/xml (not versioned vnd.sap.adt.api.abapunit.*)
- */
-export declare function startClassUnitTestRunLegacy(connection: IAbapConnection, classNames: string[]): Promise<IAdtWireResponse>;
-//# sourceMappingURL=runLegacy.d.ts.map

package/dist/core/class/runLegacy.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runLegacy.d.ts","sourceRoot":"","sources":["../../../src/core/class/runLegacy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAMjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,2BAA2B,CAC/C,UAAU,EAAE,eAAe,EAC3B,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO,CAAC,gBAAgB,CAAC,CA8B3B"}

package/dist/core/class/runLegacy.js

@@ -1,74 +0,0 @@
-"use strict";
-/**
- * ABAP Unit test run operations for legacy systems (BASIS < 7.50)
- *
- * Legacy systems use:
- * - /sap/bc/adt/abapunit/testruns instead of /sap/bc/adt/abapunit/runs
- * - application/xml for Content-Type and Accept (not versioned vnd.sap.adt.api.abapunit.* types)
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startClassUnitTestRunLegacy = startClassUnitTestRunLegacy;
-const objects_1 = require("../../endpoints/objects");
-const CT_XML = 'application/xml';
-const ACCEPT_XML = 'application/xml';
-/**
- * Start ABAP Unit test run on legacy systems
- * Uses /sap/bc/adt/abapunit/testruns endpoint with aunit:runConfiguration format
- *
- * There is only a start here. `getClassUnitTestStatusLegacy` and
- * `getClassUnitTestResultLegacy` polled `testruns/{runId}` and
- * `testruns/{runId}/results`, and were removed once the endpoint was measured:
- * the POST answers with the finished result, so there was never a run to poll.
- * Nothing called them — `ClassTestRunnerLegacy` serves both from the response the
- * POST returned — so they were an unmeasured contract kept alive by nobody
- * looking.
- *
- * **Reading the result: `kind` carries the distinction, `severity` does not.** A
- * failed assertion and an uncaught exception both come back
- * `severity="critical"`, measured on one release — so a parser classifying on
- * severity reports a short dump as a failed test. The field that separates them
- * is `kind`: `failedAssertion`, `exception`, `noTestClasses`.
- *
- * Also measured: this endpoint is **synchronous** on both a modern and a legacy
- * on-prem system, over HTTP and over RFC — `<aunit:runResult>` with no
- * `Location`, and the typed and `application/xml` bodies byte-identical. The
- * legacy system ignores the typed `Accept` altogether and answers
- * `application/xml` either way.
- *
- * Legacy format differs from modern:
- * - Root element: aunit:runConfiguration (not aunit:run)
- * - Namespace: http://www.sap.com/adt/aunit (not http://www.sap.com/adt/api/aunit)
- * - Objects via adtcore:objectReferences with URI (not aunit:tests with containerClass/class)
- *   — so a run covers whole classes: this format has no way to name one test
- *   class inside its container, and a caller's test class name is not sent.
- * - Content-Type/Accept: application/xml (not versioned vnd.sap.adt.api.abapunit.*)
- */
-async function startClassUnitTestRunLegacy(connection, classNames) {
-    const objectRefs = classNames
-        .map((name) => {
-        return `        <adtcore:objectReference adtcore:uri="${objects_1.CLASS.uri(name)}"/>`;
-    })
-        .join('\n');
-    const xml = `<?xml version="1.0" encoding="UTF-8"?><aunit:runConfiguration xmlns:aunit="http://www.sap.com/adt/aunit">
-  <external>
-    <coverage active="false"/>
-  </external>
-  <adtcore:objectSets xmlns:adtcore="http://www.sap.com/adt/core">
-    <objectSet kind="inclusive">
-      <adtcore:objectReferences>
-${objectRefs}
-      </adtcore:objectReferences>
-    </objectSet>
-  </adtcore:objectSets>
-</aunit:runConfiguration>`;
-    return connection.makeAdtRequest({
-        url: '/sap/bc/adt/abapunit/testruns',
-        method: 'POST',
-        timeout: 0,
-        data: xml,
-        headers: {
-            'Content-Type': CT_XML,
-            Accept: ACCEPT_XML,
-        },
-    });
-}