abapgit-agent 1.17.4 → 1.17.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abapgit-agent",
-  "version": "1.17.4",
+  "version": "1.17.6",
   "description": "ABAP Git Agent - Pull and activate ABAP code via abapGit from any git repository",
   "files": [
     "bin/",

package/src/commands/pull.js

@@ -525,11 +525,30 @@ Examples:
           // 3. Amend last commit
           execSync('git commit --amend --no-edit', { cwd: process.cwd() });
 
-          // 4. Push with force-with-lease; if no upstream, set it automatically
+          // 4. Push with force-with-lease; fetch first so tracking ref is current
+          //    (the remote may have been force-pushed by another process between our last
+          //    fetch and this push — a fetch makes --force-with-lease reliable)
           let pushed = false;
           try {
-            execSync('git push --force-with-lease', { cwd: process.cwd(), stdio: 'pipe' });
-            pushed = true;
+            try { execSync('git fetch origin', { cwd: process.cwd(), stdio: 'pipe' }); } catch (_) { /* no remote is fine */ }
+            // Retry the push up to 3 times on transient server errors (e.g. GitHub Enterprise 500)
+            let pushErr;
+            for (let attempt = 1; attempt <= 3; attempt++) {
+              try {
+                execSync('git push --force-with-lease', { cwd: process.cwd(), stdio: 'pipe' });
+                pushed = true;
+                break;
+              } catch (err) {
+                pushErr = err;
+                const msg = (err.stderr || err.stdout || err.message || '').toString();
+                const transient = /internal server error|remote rejected|\b5\d\d\b|connection reset|timed? ?out/i.test(msg);
+                if (attempt < 3 && transient) {
+                  execSync('sleep 2', { stdio: 'pipe' });
+                  continue;
+                }
+                throw err;
+              }
+            }
           } catch (pushErr) {
             const msg = (pushErr.stderr || pushErr.stdout || pushErr.message || '').toString();
             if (msg.includes('no upstream branch') || msg.includes('has no upstream')) {

package/src/commands/unit.js

@@ -24,6 +24,11 @@ function escapeXml(str) {
  * Maps to JUnit schema:
  *   <testsuites>
  *     <testsuite name="ZCL_MY_TEST" tests="10" failures="2" errors="0">
+ *       <properties>
+ *         <property name="coverage.rate" value="67"/>
+ *         <property name="coverage.lines.total" value="120"/>
+ *         <property name="coverage.lines.covered" value="80"/>
+ *       </properties>
  *       <testcase name="TEST_METHOD_1" classname="ZCL_MY_TEST"/>
  *       <testcase name="TEST_METHOD_2" classname="ZCL_MY_TEST">
  *         <failure type="FAILURE" message="...">detail</failure>
@@ -33,53 +38,59 @@ function escapeXml(str) {
  *
  * One testsuite per test class file. Each failed test method becomes a <failure>.
  * Passing methods are listed as empty <testcase> elements (Jenkins counts them).
+ * Coverage stats (if present) are emitted as <properties> on the testsuite.
  */
 function buildUnitJUnit(results) {
   const suites = results.map(res => {
-    const success      = res.SUCCESS      || res.success;
     const testCount    = res.TEST_COUNT    || res.test_count    || 0;
     const passedCount  = res.PASSED_COUNT  || res.passed_count  || 0;
     const failedCount  = res.FAILED_COUNT  || res.failed_count  || 0;
     const errors       = res.ERRORS        || res.errors        || [];
     const className    = res._className    || 'UNKNOWN';  // injected by caller
+    const coverageStats = res.COVERAGE_STATS || res.coverage_stats;
+
+    const lines = [];
+
+    // Coverage <properties> block — only emitted when coverage data is present
+    if (coverageStats) {
+      const rate    = coverageStats.COVERAGE_RATE  || coverageStats.coverage_rate  || 0;
+      const total   = coverageStats.TOTAL_LINES    || coverageStats.total_lines    || 0;
+      const covered = coverageStats.COVERED_LINES  || coverageStats.covered_lines  || 0;
+      lines.push('    <properties>');
+      lines.push(`      <property name="coverage.rate"          value="${rate}"/>`);
+      lines.push(`      <property name="coverage.lines.total"   value="${total}"/>`);
+      lines.push(`      <property name="coverage.lines.covered" value="${covered}"/>`);
+      lines.push('    </properties>');
+    }
 
-    // Build a set of failed method names for quick lookup
-    const failedMethods = new Set(
-      errors.map(e => (e.CLASS_NAME || e.class_name || '') + '=>' + (e.METHOD_NAME || e.method_name || ''))
-    );
-
-    const testcases = [];
-
-    // Emit one <testcase> per failed test
+    // One <testcase> per failed test
     for (const err of errors) {
       const errClassName  = err.CLASS_NAME  || err.class_name  || className;
       const methodName    = err.METHOD_NAME || err.method_name || '?';
       const errorKind     = err.ERROR_KIND  || err.error_kind  || 'FAILURE';
       const errorText     = err.ERROR_TEXT  || err.error_text  || 'Test failed';
-      testcases.push(
+      lines.push(
         `    <testcase name="${escapeXml(methodName)}" classname="${escapeXml(errClassName)}">\n` +
         `      <failure type="${escapeXml(errorKind)}" message="${escapeXml(errorText)}">${escapeXml(errorText)}</failure>\n` +
         `    </testcase>`
       );
     }
 
-    // Emit empty <testcase> elements for passing tests (Jenkins shows total count)
-    // We can't enumerate them individually (ABAP doesn't return passing method names),
-    // so emit one aggregate passing testcase when passedCount > 0
+    // Aggregate passing testcase (ABAP doesn't return individual passing method names)
     if (passedCount > 0) {
-      testcases.push(
+      lines.push(
         `    <testcase name="(${passedCount} passing test(s))" classname="${escapeXml(className)}"/>`
       );
     }
 
     if (testCount === 0) {
-      testcases.push(`    <testcase name="(no tests)" classname="${escapeXml(className)}"/>`);
+      lines.push(`    <testcase name="(no tests)" classname="${escapeXml(className)}"/>`);
     }
 
     return (
       `  <testsuite name="${escapeXml(className)}" ` +
       `tests="${Math.max(testCount, 1)}" failures="${failedCount}" errors="0">\n` +
-      testcases.join('\n') + '\n' +
+      lines.join('\n') + '\n' +
       `  </testsuite>`
     );
   });
@@ -235,21 +246,23 @@ module.exports = {
     if (args.includes('--help') || args.includes('-h')) {
       console.log(`
 Usage:
-  abapgit-agent unit --files <file1>,<file2>,... [--coverage] [--junit-output <file>] [--json]
+  abapgit-agent unit --files <file1>,<file2>,... [options]
 
 Description:
   Run AUnit tests for ABAP test class files (.testclasses.abap).
   Objects must be already active in the ABAP system (run pull first).
 
 Parameters:
-  --files <file1,...>     Comma-separated .testclasses.abap files (required).
-  --coverage              Include code coverage data in output.
-  --junit-output <file>   Write results as JUnit XML to this file.
-  --json                  Output as JSON.
+  --files <file1,...>          Comma-separated .testclasses.abap files (required).
+  --coverage                   Include code coverage data in output.
+  --coverage-threshold <N>     Fail/warn when coverage is below N percent (0–100). Default: 0 (off).
+  --coverage-mode <warn|fail>  Action when below threshold: warn = UNSTABLE, fail = error. Default: fail.
+  --junit-output <file>        Write results as JUnit XML to this file.
+  --json                       Output as JSON.
 
 Examples:
   abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap
-  abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap --coverage
+  abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap --coverage --coverage-threshold 80
   abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap --junit-output reports/unit.xml
 `);
       return;
@@ -260,18 +273,21 @@ Examples:
     const filesArgIndex = args.indexOf('--files');
     if (filesArgIndex === -1 || filesArgIndex + 1 >= args.length) {
       console.error('Error: --files parameter required');
-      console.error('Usage: abapgit-agent unit --files <file1>,<file2>,... [--coverage] [--junit-output <file>] [--json]');
-      console.error('Example: abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap');
-      console.error('Example: abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap --coverage');
-      console.error('Example: abapgit-agent unit --files src/zcl_my_test.clas.testclasses.abap --junit-output reports/unit.xml');
+      console.error('Usage: abapgit-agent unit --files <file1>,<file2>,... [--coverage] [--coverage-threshold <N>] [--junit-output <file>] [--json]');
       process.exit(1);
     }
 
     const files = args[filesArgIndex + 1].split(',').map(f => f.trim());
 
-    // Check for coverage option
+    // Coverage options
     const coverage = args.includes('--coverage');
 
+    const coverageThresholdIdx = args.indexOf('--coverage-threshold');
+    const coverageThreshold = coverageThresholdIdx !== -1 ? parseInt(args[coverageThresholdIdx + 1], 10) : 0;
+
+    const coverageModeIdx = args.indexOf('--coverage-mode');
+    const coverageMode = coverageModeIdx !== -1 ? args[coverageModeIdx + 1] : 'fail';
+
     // Parse optional --junit-output parameter
     const junitArgIndex = args.indexOf('--junit-output');
     const junitOutput = junitArgIndex !== -1 ? args[junitArgIndex + 1] : null;
@@ -327,6 +343,29 @@ Examples:
       }
     }
 
+    // Coverage threshold enforcement — aggregated across all files
+    if (coverage && coverageThreshold > 0) {
+      const totalLines   = results.reduce((s, r) => s + ((r.COVERAGE_STATS || r.coverage_stats)?.TOTAL_LINES   || (r.COVERAGE_STATS || r.coverage_stats)?.total_lines   || 0), 0);
+      const coveredLines = results.reduce((s, r) => s + ((r.COVERAGE_STATS || r.coverage_stats)?.COVERED_LINES || (r.COVERAGE_STATS || r.coverage_stats)?.covered_lines || 0), 0);
+
+      if (totalLines === 0) {
+        if (!jsonOutput) console.warn('⚠️  Coverage data unavailable — threshold not enforced');
+      } else {
+        const rate = Math.round((coveredLines / totalLines) * 100);
+        if (rate < coverageThreshold) {
+          const msg = `Coverage ${rate}% is below threshold ${coverageThreshold}%`;
+          if (coverageMode === 'warn') {
+            if (!jsonOutput) console.warn(`⚠️  ${msg}`);
+          } else {
+            if (!jsonOutput) console.error(`❌ ${msg}`);
+            hasErrors = true;
+          }
+        } else {
+          if (!jsonOutput) console.log(`✅ Coverage ${rate}% meets threshold ${coverageThreshold}%`);
+        }
+      }
+    }
+
     // JSON output mode
     if (jsonOutput) {
       console.log(JSON.stringify(results, null, 2));

package/src/commands/upgrade.js

@@ -109,7 +109,7 @@ Examples:
     if (flags.version && !flags.abapOnly) {
       const versionExists = await this.validateVersionExists(flags.version);
       if (!versionExists) {
-        console.error(`❌ Error: Version ${flags.version} not found in npm registry`);
+        console.error(`Error: Version ${flags.version} not found in npm registry`);
         console.error('   Please check available versions at: https://www.npmjs.com/package/abapgit-agent?activeTab=versions');
         process.exit(1);
       }