@rayutek/abap-adt-api 6.2.1-pkg-1.0.0

package/build/api/transports.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTransportConfiguration = exports.transportConfigurations = exports.transportReference = exports.systemUsers = exports.transportAddUser = exports.transportSetOwner = exports.transportRelease = exports.transportDelete = exports.setTransportsConfig = exports.createTransportsConfig = exports.transportsByConfig = exports.userTransports = exports.createTransport = exports.transportInfo = exports.TransportDateFilter = void 0;
+const AdtException_1 = require("../AdtException");
+const utilities_1 = require("../utilities");
+var TransportDateFilter;
+(function (TransportDateFilter) {
+    TransportDateFilter[TransportDateFilter["SinceYesterday"] = 0] = "SinceYesterday";
+    TransportDateFilter[TransportDateFilter["SincleTwoWeeks"] = 1] = "SincleTwoWeeks";
+    TransportDateFilter[TransportDateFilter["SinceFourWeeks"] = 2] = "SinceFourWeeks";
+    TransportDateFilter[TransportDateFilter["DateRange"] = 3] = "DateRange";
+})(TransportDateFilter = exports.TransportDateFilter || (exports.TransportDateFilter = {}));
+function extractLocks(raw) {
+    const lock = raw && raw.CTS_OBJECT_LOCK;
+    if (!lock)
+        return;
+    try {
+        const holder = lock.LOCK_HOLDER;
+        const TASKS = (0, utilities_1.xmlArray)(holder, "TASK_HEADERS").map((x) => x.CTS_TASK_HEADER);
+        return {
+            HEADER: holder.REQ_HEADER,
+            OBJECT_KEY: (0, utilities_1.xmlNode)(lock, "OBJECT_KEY"),
+            TASKS
+        };
+    }
+    catch (_a) {
+        return;
+    }
+}
+function extractTransports(raw) {
+    return (0, utilities_1.xmlArray)(raw, "CTS_REQUEST").map((x) => x.REQ_HEADER);
+}
+async function transportInfo(h, URI, DEVCLASS = "", OPERATION = "I") {
+    (0, AdtException_1.ValidateObjectUrl)(URI);
+    const body = (0, utilities_1.JSON2AbapXML)({
+        DEVCLASS,
+        OPERATION,
+        URI
+    });
+    const headers = {
+        Accept: "application/vnd.sap.as+xml;charset=UTF-8;dataname=com.sap.adt.transport.service.checkData",
+        "Content-Type": "application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.transport.service.checkData"
+    };
+    const response = await h.request("/sap/bc/adt/cts/transportchecks", {
+        body,
+        method: "POST",
+        headers
+    });
+    // return parsePackageResponse(response.body)
+    // tslint:disable-next-line: prefer-const
+    let { REQUESTS, LOCKS, MESSAGES, ...header } = (0, utilities_1.parse)(response.body)["asx:abap"]["asx:values"].DATA;
+    if (MESSAGES) {
+        MESSAGES = (0, utilities_1.xmlArray)(MESSAGES, "CTS_MESSAGE").map((m) => {
+            // tslint:disable-next-line: prefer-const
+            let { VARIABLES, ...rest } = m;
+            VARIABLES =
+                (VARIABLES && (0, utilities_1.xmlArray)(m, "VARIABLES", "CTS_VARIABLE")).map((v) => v.VARIABLE) || [];
+            return { VARIABLES, ...rest };
+        });
+        MESSAGES.filter((m) => m.SEVERITY.match(/[EAX]/)).some((e) => {
+            throw (0, AdtException_1.adtException)(e.TEXT);
+        });
+    }
+    const TRANSPORTS = extractTransports(REQUESTS);
+    return { ...header, LOCKS: extractLocks(LOCKS), TRANSPORTS };
+}
+exports.transportInfo = transportInfo;
+async function createTransport(h, REF, REQUEST_TEXT, DEVCLASS, OPERATION = "I", transportLayer = "") {
+    var _a;
+    (0, AdtException_1.ValidateObjectUrl)(REF);
+    const body = (0, utilities_1.JSON2AbapXML)({ DEVCLASS, REQUEST_TEXT, REF, OPERATION });
+    const qs = transportLayer ? { transportLayer } : {};
+    const response = await h.request("/sap/bc/adt/cts/transports", {
+        body,
+        qs,
+        headers: {
+            Accept: "text/plain",
+            "Content-Type": "application/vnd.sap.as+xml; charset=UTF-8; dataname=com.sap.adt.CreateCorrectionRequest"
+        },
+        method: "POST"
+    });
+    const transport = (_a = response.body) === null || _a === void 0 ? void 0 : _a.split("/").pop();
+    return transport || "";
+}
+exports.createTransport = createTransport;
+const parseTask = (t) => {
+    const task = {
+        ...(0, utilities_1.xmlNodeAttr)(t),
+        links: (0, utilities_1.xmlArray)(t, "atom:link").map(utilities_1.xmlNodeAttr),
+        objects: (0, utilities_1.xmlArray)(t, "tm:abap_object").map(utilities_1.xmlNodeAttr)
+    };
+    if (task["tm:desc"])
+        task["tm:desc"] = task["tm:desc"];
+    return task;
+};
+const parseRequest = (r) => {
+    const request = {
+        ...parseTask(r),
+        tasks: (0, utilities_1.xmlArray)(r, "tm:task").map(parseTask)
+    };
+    return request;
+};
+const parseTargets = (s) => ({
+    ...(0, utilities_1.xmlNodeAttr)(s),
+    modifiable: (0, utilities_1.xmlArray)(s, "tm:modifiable", "tm:request").map(parseRequest),
+    released: (0, utilities_1.xmlArray)(s, "tm:released", "tm:request").map(parseRequest)
+});
+async function userTransports(h, user, targets = true) {
+    const response = await h.request("/sap/bc/adt/cts/transportrequests", {
+        qs: { user, targets }
+    });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    const workbench = (0, utilities_1.xmlArray)(raw, "tm:root", "tm:workbench", "tm:target").map(parseTargets);
+    const customizing = (0, utilities_1.xmlArray)(raw, "tm:root", "tm:customizing", "tm:target").map(parseTargets);
+    const retval = { workbench, customizing };
+    return retval;
+}
+exports.userTransports = userTransports;
+async function transportsByConfig(h, configUri, targets = true) {
+    const response = await h.request("/sap/bc/adt/cts/transportrequests", {
+        qs: { configUri, targets }
+    });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    const workbench = (0, utilities_1.xmlArray)(raw, "tm:root", "tm:workbench", "tm:target").map(parseTargets);
+    const customizing = (0, utilities_1.xmlArray)(raw, "tm:root", "tm:customizing", "tm:target").map(parseTargets);
+    const retval = { workbench, customizing };
+    return retval;
+}
+exports.transportsByConfig = transportsByConfig;
+const serializeTransportConfig = (cfg) => {
+    const w = (k, v) => `<configuration:property key="${k}">${v}</configuration:property>`;
+    const p = (v, k) => w(k, v[k]);
+    const td = (d) => `${(0, utilities_1.toSapDate)(new Date(d))}`;
+    const datelimit = cfg.DateFilter === TransportDateFilter.DateRange
+        ? `${w("FromDate", td(cfg.FromDate))}${w("ToDate", td(cfg.ToDate))}`
+        : "";
+    return "".concat(`<configuration:configuration xmlns:configuration="http://www.sap.com/adt/configuration"> <configuration:properties>`, p(cfg, "WorkbenchRequests"), p(cfg, "CustomizingRequests"), p(cfg, "TransportOfCopies"), p(cfg, "DateFilter"), p(cfg, "Modifiable"), p(cfg, "Released"), p(cfg, "User"), datelimit, `</configuration:properties> </configuration:configuration>`);
+};
+async function createTransportsConfig(h) {
+    const headers = { Accept: "application/vnd.sap.adt.configuration.v1+xml" };
+    const uri = "/sap/bc/adt/cts/transportrequests/searchconfiguration/configurations";
+    const response = await h.request(uri, { method: "POST", headers });
+    return parseTransportConfig(response.body);
+}
+exports.createTransportsConfig = createTransportsConfig;
+async function setTransportsConfig(h, uri, etag, config) {
+    const body = serializeTransportConfig(config);
+    const headers = {
+        Accept: "application/vnd.sap.adt.configuration.v1+xml",
+        "Content-Type": "application/vnd.sap.adt.configuration.v1+xml",
+        "If-Match": etag
+    };
+    const response = await h.request(uri, { method: "PUT", headers, body });
+    return parseTransportConfig(response.body);
+}
+exports.setTransportsConfig = setTransportsConfig;
+function validateTransport(transportNumber) {
+    if (transportNumber.length !== 10 || !transportNumber.match(/^[a-z]\w\wk/i))
+        (0, AdtException_1.adtException)("Invalid transport number:" + transportNumber);
+}
+async function transportDelete(h, transportNumber) {
+    validateTransport(transportNumber);
+    await h.request("/sap/bc/adt/cts/transportrequests/" + transportNumber, {
+        method: "DELETE",
+        headers: { Accept: "application/*" }
+    });
+}
+exports.transportDelete = transportDelete;
+async function transportRelease(h, transportNumber, ignoreLocks = false, IgnoreATC = false) {
+    validateTransport(transportNumber);
+    const action = IgnoreATC
+        ? "relObjigchkatc"
+        : ignoreLocks
+            ? "relwithignlock"
+            : "newreleasejobs";
+    const response = await h.request(`/sap/bc/adt/cts/transportrequests/${transportNumber}/${action}`, {
+        method: "POST",
+        headers: { Accept: "application/*" }
+    });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    const reports = (0, utilities_1.xmlArray)(raw, "tm:root", "tm:releasereports", "chkrun:checkReport").map((r) => {
+        return {
+            ...(0, utilities_1.xmlNodeAttr)(r),
+            messages: (0, utilities_1.xmlArray)(r, "chkrun:checkMessageList", "chkrun:checkMessage").map(utilities_1.xmlNodeAttr)
+        };
+    });
+    return reports;
+}
+exports.transportRelease = transportRelease;
+async function transportSetOwner(h, transportNumber, targetuser) {
+    validateTransport(transportNumber);
+    const body = `<?xml version="1.0" encoding="ASCII"?><tm:root xmlns:tm="http://www.sap.com/cts/adt/tm" tm:number="${transportNumber}" tm:targetuser="${targetuser}" tm:useraction="changeowner"/>`;
+    const response = await h.request("/sap/bc/adt/cts/transportrequests/" + transportNumber, {
+        method: "PUT",
+        headers: { Accept: "application/*" },
+        qs: { targetuser },
+        body
+    });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    return (0, utilities_1.xmlNodeAttr)((0, utilities_1.xmlNode)(raw, "tm:root"));
+}
+exports.transportSetOwner = transportSetOwner;
+async function transportAddUser(h, transportNumber, user) {
+    validateTransport(transportNumber);
+    const body = `<?xml version="1.0" encoding="ASCII"?>
+  <tm:root xmlns:tm="http://www.sap.com/cts/adt/tm" tm:number="${transportNumber}"
+  tm:targetuser="${user}" tm:useraction="newtask"/>`;
+    const response = await h.request("/sap/bc/adt/cts/transportrequests/" + transportNumber + "/tasks", {
+        method: "POST",
+        body,
+        headers: { Accept: "application/*", "Content-Type": "text/plain" }
+    });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    return (0, utilities_1.xmlNodeAttr)((0, utilities_1.xmlNode)(raw, "tm:root"));
+}
+exports.transportAddUser = transportAddUser;
+async function systemUsers(h) {
+    const response = await h.request("/sap/bc/adt/system/users", {
+        headers: { Accept: "application/atom+xml;type=feed" }
+    });
+    const raw = (0, utilities_1.parse)(response.body);
+    return (0, utilities_1.xmlArray)(raw, "atom:feed", "atom:entry").map((r) => ({ id: r["atom:id"], title: r["atom:title"] }));
+}
+exports.systemUsers = systemUsers;
+// tslint:disable: variable-name
+async function transportReference(h, pgmid, obj_wbtype, obj_name, tr_number = "") {
+    const response = await h.request("/sap/bc/adt/cts/transportrequests/reference", {
+        headers: { Accept: "application/*" },
+        qs: { obj_name, obj_wbtype, pgmid, tr_number }
+    });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    const link = (0, utilities_1.xmlNodeAttr)((0, utilities_1.xmlNode)(raw, "tm:root", "atom:link"));
+    return link.href;
+}
+exports.transportReference = transportReference;
+const parseTransportConfigItemList = (body) => {
+    const raw = (0, utilities_1.fullParse)(body, { parseAttributeValue: false });
+    return (0, utilities_1.xmlArray)(raw, "configurations:configurations", "configuration:configuration").map((conf) => {
+        const { "atom:link": { "@_href": link, "@_etag": etag }, ...rest } = conf;
+        const { createdAt, changedAt, ...attrs } = (0, utilities_1.xmlNodeAttr)(rest);
+        const item = {
+            ...attrs,
+            link,
+            etag,
+            createdAt: Date.parse(createdAt),
+            changedAt: Date.parse(changedAt)
+        };
+        return item;
+    });
+};
+async function transportConfigurations(h) {
+    const headers = { Accept: "application/vnd.sap.adt.configurations.v1+xml" };
+    const url = "/sap/bc/adt/cts/transportrequests/searchconfiguration/configurations";
+    const response = await h.request(url, { headers });
+    return parseTransportConfigItemList(response.body);
+}
+exports.transportConfigurations = transportConfigurations;
+const parseTransportConfig = (r) => {
+    const raw = (0, utilities_1.fullParse)(r, { parseAttributeValue: false });
+    const props = (0, utilities_1.xmlArray)(raw, "configuration:configuration", "configuration:properties", "configuration:property").map((p) => {
+        return { key: p["@_key"], value: p["#text"] };
+    });
+    const cfg = {};
+    for (const { key, value } of props)
+        cfg[key] = value;
+    const WorkbenchRequests = cfg.WorkbenchRequests;
+    const TransportOfCopies = cfg.TransportOfCopies;
+    const Released = cfg.Released;
+    const User = cfg.User;
+    const CustomizingRequests = cfg.CustomizingRequests;
+    const FromDate = cfg.FromDate && (0, utilities_1.parseSapDate)(`${cfg.FromDate}`);
+    const ToDate = cfg.ToDate && (0, utilities_1.parseSapDate)(`${cfg.ToDate}`);
+    const DateFilter = cfg.DateFilter;
+    const Modifiable = cfg.Modifiable;
+    return {
+        WorkbenchRequests,
+        TransportOfCopies,
+        Released,
+        User,
+        CustomizingRequests,
+        FromDate,
+        ToDate,
+        DateFilter,
+        Modifiable
+    };
+};
+async function getTransportConfiguration(h, url) {
+    const headers = { Accept: "application/vnd.sap.adt.configuration.v1+xml" };
+    const response = await h.request(url, { headers });
+    return parseTransportConfig(response.body);
+}
+exports.getTransportConfiguration = getTransportConfiguration;

package/build/api/unittest.d.ts

@@ -0,0 +1,81 @@
+import * as t from "io-ts";
+import { AdtHTTP } from "../AdtHTTP";
+export interface UnitTestStackEntry {
+    "adtcore:uri": string;
+    "adtcore:type": string;
+    "adtcore:name": string;
+    "adtcore:description": string;
+}
+export declare enum UnitTestAlertKind {
+    exception = "exception",
+    failedAssertion = "failedAssertion",
+    warning = "warning"
+}
+export declare enum UnitTestSeverity {
+    critical = "critical",
+    fatal = "fatal",
+    tolerable = "tolerable",
+    tolerant = "tolerant"
+}
+export interface UnitTestAlert {
+    kind: UnitTestAlertKind;
+    severity: UnitTestSeverity;
+    details: string[];
+    stack: UnitTestStackEntry[];
+    title: string;
+}
+export interface UnitTestMethod {
+    "adtcore:uri": string;
+    "adtcore:type": string;
+    "adtcore:name": string;
+    executionTime: number;
+    uriType: string;
+    navigationUri?: string;
+    unit: string;
+    alerts: UnitTestAlert[];
+}
+export interface UnitTestClass {
+    "adtcore:uri": string;
+    "adtcore:type": string;
+    "adtcore:name": string;
+    uriType: string;
+    navigationUri?: string;
+    durationCategory: string;
+    riskLevel: string;
+    testmethods: UnitTestMethod[];
+    alerts: UnitTestAlert[];
+}
+declare const markerCodec: t.TypeC<{
+    kind: t.StringC;
+    keepsResult: t.BooleanC;
+    location: t.TypeC<{
+        uri: t.StringC;
+        query: t.UnionC<[t.UndefinedC, t.RecordC<t.StringC, t.StringC>]>;
+        range: t.TypeC<{
+            start: t.TypeC<{
+                line: t.NumberC;
+                column: t.NumberC;
+            }>;
+            end: t.TypeC<{
+                line: t.NumberC;
+                column: t.NumberC;
+            }>;
+        }>;
+        hashparms: t.UnionC<[t.UndefinedC, t.RecordC<t.StringC, t.StringC>]>;
+    }>;
+}>;
+export type UnitTestOccurrenceMarker = t.TypeOf<typeof markerCodec>;
+export interface UnitTestRunFlags {
+    harmless: boolean;
+    dangerous: boolean;
+    critical: boolean;
+    short: boolean;
+    medium: boolean;
+    long: boolean;
+}
+export declare const DefaultUnitTestRunFlags: UnitTestRunFlags;
+export declare function runUnitTest(h: AdtHTTP, url: string, flags?: UnitTestRunFlags): Promise<UnitTestClass[]>;
+export declare function unitTestEvaluation(h: AdtHTTP, clas: UnitTestClass, flags?: UnitTestRunFlags): Promise<UnitTestMethod[]>;
+export declare function unitTestOccurrenceMarkers(h: AdtHTTP, uri: string, source: string): Promise<UnitTestOccurrenceMarker[]>;
+export {};
+//# sourceMappingURL=unittest.d.ts.map

package/build/api/unittest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unittest.d.ts","sourceRoot":"","sources":["../../src/api/unittest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAA;AAE1B,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AAIpC,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,qBAAqB,EAAE,MAAM,CAAA;CAC9B;AAED,oBAAY,iBAAiB;IAC3B,SAAS,cAAc;IACvB,eAAe,oBAAoB;IACnC,OAAO,YAAY;CACpB;AACD,oBAAY,gBAAgB;IAC1B,QAAQ,aAAa;IACrB,KAAK,UAAU;IACf,SAAS,cAAc;IACvB,QAAQ,aAAa;CACtB;AACD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,iBAAiB,CAAA;IACvB,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,KAAK,EAAE,kBAAkB,EAAE,CAAA;IAC3B,KAAK,EAAE,MAAM,CAAA;CACd;AACD,MAAM,WAAW,cAAc;IAC7B,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,MAAM,CAAA;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,aAAa,EAAE,CAAA;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAA;IACrB,cAAc,EAAE,MAAM,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,cAAc,EAAE,CAAA;IAC7B,MAAM,EAAE,aAAa,EAAE,CAAA;CACxB;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;EAIf,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,WAAW,CAAC,CAAA;AA2BnE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,OAAO,CAAA;IACjB,SAAS,EAAE,OAAO,CAAA;IAClB,QAAQ,EAAE,OAAO,CAAA;IACjB,KAAK,EAAE,OAAO,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,OAAO,CAAA;CACd;AAED,eAAO,MAAM,uBAAuB,EAAE,gBAOrC,CAAA;AAED,wBAAsB,WAAW,CAC/B,CAAC,EAAE,OAAO,EACV,GAAG,EAAE,MAAM,EACX,KAAK,GAAE,gBAA0C,4BA4ClD;AAED,wBAAsB,kBAAkB,CACtC,CAAC,EAAE,OAAO,EACV,IAAI,EAAE,aAAa,EACnB,KAAK,GAAE,gBAA0C,6BAuClD;AAED,wBAAsB,yBAAyB,CAC7C,CAAC,EAAE,OAAO,EACV,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,wBAAwB,EAAE,CAAC,CAqBrC"}

package/build/api/unittest.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unitTestOccurrenceMarkers = exports.unitTestEvaluation = exports.runUnitTest = exports.DefaultUnitTestRunFlags = exports.UnitTestSeverity = exports.UnitTestAlertKind = void 0;
+const t = __importStar(require("io-ts"));
+const __1 = require("..");
+const utilities_1 = require("../utilities");
+const urlparser_1 = require("./urlparser");
+var UnitTestAlertKind;
+(function (UnitTestAlertKind) {
+    UnitTestAlertKind["exception"] = "exception";
+    UnitTestAlertKind["failedAssertion"] = "failedAssertion";
+    UnitTestAlertKind["warning"] = "warning";
+})(UnitTestAlertKind = exports.UnitTestAlertKind || (exports.UnitTestAlertKind = {}));
+var UnitTestSeverity;
+(function (UnitTestSeverity) {
+    UnitTestSeverity["critical"] = "critical";
+    UnitTestSeverity["fatal"] = "fatal";
+    UnitTestSeverity["tolerable"] = "tolerable";
+    UnitTestSeverity["tolerant"] = "tolerant";
+})(UnitTestSeverity = exports.UnitTestSeverity || (exports.UnitTestSeverity = {}));
+const markerCodec = t.type({
+    kind: t.string,
+    keepsResult: t.boolean,
+    location: urlparser_1.uriParts
+});
+const parseDetail = (alert) => (0, utilities_1.xmlArray)(alert, "details", "detail").reduce((result, d) => {
+    const main = (d && d["@_text"]) || "";
+    const children = (0, utilities_1.xmlArray)(d, "details", "detail")
+        .map((dd) => (dd && `\n\t${dd["@_text"]}`) || "")
+        .join("");
+    return main ? [...result, main + children] : result;
+}, []);
+const parseStack = (alert) => (0, utilities_1.xmlArray)(alert, "stack", "stackEntry").map(x => {
+    const entry = (0, utilities_1.xmlNodeAttr)(x);
+    entry["adtcore:description"] = entry["adtcore:description"];
+    return entry;
+});
+const parseAlert = (alert) => ({
+    ...(0, utilities_1.xmlNodeAttr)(alert),
+    details: parseDetail(alert),
+    stack: parseStack(alert),
+    title: (alert === null || alert === void 0 ? void 0 : alert.title) || ""
+});
+const parseMethod = (method) => ({
+    ...(0, utilities_1.xmlNodeAttr)(method),
+    alerts: (0, utilities_1.xmlArray)(method, "alerts", "alert").map(parseAlert)
+});
+exports.DefaultUnitTestRunFlags = {
+    harmless: true,
+    dangerous: false,
+    critical: false,
+    short: true,
+    medium: false,
+    long: false
+};
+async function runUnitTest(h, url, flags = exports.DefaultUnitTestRunFlags) {
+    const headers = { "Content-Type": "application/*", Accept: "application/*" };
+    const body = `<?xml version="1.0" encoding="UTF-8"?>
+  <aunit:runConfiguration xmlns:aunit="http://www.sap.com/adt/aunit">
+  <external>
+    <coverage active="false"/>
+  </external>
+  <options>
+    <uriType value="semantic"/>
+    <testDeterminationStrategy sameProgram="true" assignedTests="false"/>
+    <testRiskLevels harmless="${flags.harmless}" dangerous="${flags.dangerous}" critical="${flags.critical}"/>
+    <testDurations short="${flags.short}" medium="${flags.medium}" long="${flags.long}"/>
+    <withNavigationUri enabled="true"/>    
+  </options>
+  <adtcore:objectSets xmlns:adtcore="http://www.sap.com/adt/core">
+    <objectSet kind="inclusive">
+      <adtcore:objectReferences>
+        <adtcore:objectReference adtcore:uri="${url}"/>
+      </adtcore:objectReferences>
+    </objectSet>
+  </adtcore:objectSets>
+</aunit:runConfiguration>`;
+    const response = await h.request("/sap/bc/adt/abapunit/testruns", {
+        method: "POST",
+        headers,
+        body
+    });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    const classes = (0, utilities_1.xmlFlatArray)(raw, "aunit:runResult", "program", "testClasses", "testClass").map(c => {
+        return {
+            ...(0, utilities_1.xmlNodeAttr)(c),
+            alerts: (0, utilities_1.xmlArray)(c, "alerts", "alert").map(parseAlert),
+            testmethods: (0, utilities_1.xmlFlatArray)(c, "testMethods", "testMethod").map(parseMethod)
+        };
+    });
+    return classes;
+}
+exports.runUnitTest = runUnitTest;
+async function unitTestEvaluation(h, clas, flags = exports.DefaultUnitTestRunFlags) {
+    const headers = { "Content-Type": "application/*l", Accept: "application/*" };
+    const references = clas.testmethods
+        .map(m => `<adtcore:objectReference adtcore:uri="${m["adtcore:uri"]}" />`)
+        .join("\n");
+    const body = `<?xml version="1.0" encoding="UTF-8"?>
+  <aunit:runConfiguration xmlns:aunit="http://www.sap.com/adt/aunit">
+      <options>
+          <uriType value="${clas.uriType}"></uriType>
+          <testDeterminationStrategy sameProgram="true" assignedTests="false"></testDeterminationStrategy>
+          <testRiskLevels harmless="${flags.harmless}" dangerous="${flags.dangerous}" critical="${flags.critical}"/>
+          <testDurations short="${flags.short}" medium="${flags.medium}" long="${flags.long}"/>      
+          <withNavigationUri enabled="true"></withNavigationUri>
+      </options>
+      <adtcore:objectSets xmlns:adtcore="http://www.sap.com/adt/core">
+          <objectSet kind="inclusive">
+              <adtcore:objectReferences>
+              ${references}
+              </adtcore:objectReferences>
+          </objectSet>
+      </adtcore:objectSets>
+  </aunit:runConfiguration>`;
+    const response = await h.request("/sap/bc/adt/abapunit/testruns/evaluation", {
+        method: "POST",
+        headers,
+        body
+    });
+    const raw = (0, utilities_1.fullParse)(response.body);
+    return (0, utilities_1.xmlArray)(raw, "aunit:runResult", "program", "testClasses", "testClass", "testMethods", "testMethod").map(parseMethod);
+}
+exports.unitTestEvaluation = unitTestEvaluation;
+async function unitTestOccurrenceMarkers(h, uri, source) {
+    const headers = { "Content-Type": "text/plain", Accept: "application/*" };
+    const response = await h.request("/sap/bc/adt/abapsource/occurencemarkers", {
+        method: "POST",
+        headers,
+        body: source,
+        qs: { uri }
+    });
+    const raw = (0, utilities_1.fullParse)(response.body, { removeNSPrefix: true });
+    const markers = (0, utilities_1.xmlArray)(raw, "occurrenceInfo", "occurrences", "occurrence").map(o => {
+        const { kind, keepsResult } = (0, utilities_1.xmlNodeAttr)(o);
+        const { uri } = (0, utilities_1.xmlNodeAttr)(o === null || o === void 0 ? void 0 : o.objectReference);
+        return { kind, keepsResult, location: (0, urlparser_1.parseUri)(uri) };
+    });
+    return (0, __1.validateParseResult)(t.array(markerCodec).decode(markers));
+}
+exports.unitTestOccurrenceMarkers = unitTestOccurrenceMarkers;

package/build/api/urlparser.d.ts

@@ -0,0 +1,34 @@
+import { Clean } from "../utilities";
+import * as t from "io-ts";
+declare const range: t.TypeC<{
+    start: t.TypeC<{
+        line: t.NumberC;
+        column: t.NumberC;
+    }>;
+    end: t.TypeC<{
+        line: t.NumberC;
+        column: t.NumberC;
+    }>;
+}>;
+export declare const uriParts: t.TypeC<{
+    uri: t.StringC;
+    query: t.UnionC<[t.UndefinedC, t.RecordC<t.StringC, t.StringC>]>;
+    range: t.TypeC<{
+        start: t.TypeC<{
+            line: t.NumberC;
+            column: t.NumberC;
+        }>;
+        end: t.TypeC<{
+            line: t.NumberC;
+            column: t.NumberC;
+        }>;
+    }>;
+    hashparms: t.UnionC<[t.UndefinedC, t.RecordC<t.StringC, t.StringC>]>;
+}>;
+export type Range = Clean<t.TypeOf<typeof range>>;
+export type UriParts = Clean<t.TypeOf<typeof uriParts>>;
+export declare const rangeToString: (range: Range) => string;
+export declare const uriPartsToString: (parts: UriParts) => string;
+export declare function parseUri(sourceuri: string): UriParts;
+export {};
+//# sourceMappingURL=urlparser.d.ts.map

package/build/api/urlparser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlparser.d.ts","sourceRoot":"","sources":["../../src/api/urlparser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAgB,MAAM,cAAc,CAAA;AAElD,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAO3B,QAAA,MAAM,KAAK;;;;;;;;;EAGT,CAAA;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;EAKnB,CAAA;AAEF,MAAM,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,KAAK,CAAC,CAAC,CAAA;AACjD,MAAM,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAA;AAEvD,eAAO,MAAM,aAAa,UAAW,KAAK,WACoD,CAAA;AAS9F,eAAO,MAAM,gBAAgB,UAAW,QAAQ,WAM/C,CAAA;AAED,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,CA4BpD"}

package/build/api/urlparser.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseUri = exports.uriPartsToString = exports.rangeToString = exports.uriParts = void 0;
+const utilities_1 = require("../utilities");
+const t = __importStar(require("io-ts"));
+const location = t.type({
+    line: t.number,
+    column: t.number
+});
+const range = t.type({
+    start: location,
+    end: location
+});
+exports.uriParts = t.type({
+    uri: t.string,
+    query: t.union([t.undefined, t.record(t.string, t.string)]),
+    range: range,
+    hashparms: t.union([t.undefined, t.record(t.string, t.string)]),
+});
+const rangeToString = (range) => `#start=${range.start.line},${range.start.column};end=${range.end.line},${range.end.column}`;
+exports.rangeToString = rangeToString;
+const serializeKv = (r) => {
+    const rec = r || {};
+    return Object.keys(rec).map(k => `${encodeURIComponent(k)}=${encodeURIComponent(rec[k])}`);
+};
+const isNullRange = (r) => r.start.line === 0 && r.start.column === 0 && r.end.line === 0 && r.end.column === 0;
+const uriPartsToString = (parts) => {
+    const range = isNullRange(parts.range) ? "" : (0, exports.rangeToString)(parts.range);
+    const parms = serializeKv(parts.hashparms).join(";");
+    const query = serializeKv(parts.query).join("&");
+    const hash = `${range ? range : ""}${parms ? `${range ? ";" : "#"}${parms}` : ``}`;
+    return `${parts.uri}${query ? `?${query}` : ``}${hash}`;
+};
+exports.uriPartsToString = uriPartsToString;
+function parseUri(sourceuri) {
+    const [uri, qs, hash] = (0, utilities_1.parts)(sourceuri, /([^\?#]*)(?:\?([^#]*))?(?:#(.*))?/);
+    //
+    const query = (qs || "").split(/&/).reduce((acc, cur) => {
+        const [key, val] = cur.split("=");
+        if (key)
+            acc[decodeURIComponent(key)] = decodeURIComponent(val);
+        return acc;
+    }, {});
+    const { start, end, ...hashparms } = (hash || "")
+        .split(/;/)
+        .reduce((acc, cur) => {
+        const [key, val] = cur.split("=");
+        if (key)
+            acc[decodeURIComponent(key)] = decodeURIComponent(val);
+        return acc;
+    }, {});
+    const parsePos = (x) => {
+        const [line, column] = x ? x.split(",").map(utilities_1.toInt) : [0, 0];
+        return { line: line || 0, column: column || 0 };
+    };
+    const st = parsePos(start);
+    const range = {
+        start: st,
+        end: end ? parsePos(end) : st
+    };
+    return { range, uri, query, hashparms };
+}
+exports.parseUri = parseUri;