# Java, C#, Python, Go … — QATrax ohne Node.js

> SBOM und Testbericht mit den Werkzeugen der eigenen Sprache erzeugen und dann wie jeder Kunde hochladen.


**Autor**: Dr Hamid MADANI <drmdh@msn.com>

QATrax liest Ihren Code nicht. Es liest **zwei Standarddateien**, die alle Sprachen erzeugen können:

- **die SBOM** Ihrer Version: CycloneDX oder SPDX, in JSON;
- **den Bericht Ihrer Tests**, so wie Ihr Werkzeug ihn schreibt: JUnit XML (das verbreitetste), NUnit, TRX, TestNG,
  Robot Framework, CTest, Cucumber JSON, Behave JSON, Allure 2, CTRF oder TAP.

Sie wechseln weder Werkzeug noch Format: Es sind auch die, die Xray, TestRail, Allure TestOps oder Azure
DevOps lesen.

Der übrige Weg ist für alle gleich: [Kurz gefasst](/docs/en-bref). Ihre Anforderungen und Ihr Testplan werden
einmalig festgelegt, wie bei jedem Kunden: Reiter [Anforderungen](/aller/exigences) und [Dev+Test-Plan](/aller/plan).

## 1. Ihre Tests nach Ihrem Plan benennen

Jeder Test trägt am Anfang seines Namens seine Referenz in Ihrem Plan (`T-MOD-01`). Die Sprachen lehnen den Bindestrich
in einem Funktionsnamen ab; schreiben Sie sie mit `_`: Sie wird erkannt. Bei BDD (Cucumber, Behave), mit Robot
Framework oder Allure genügt ein **Tag**, das der Referenz entspricht (`@T-MOD-01`).

| Sprache | Name des Tests |
|---|---|
| Java (JUnit) | `void test_T_MOD_01_aucune_vulnerabilite()` |
| C# (xUnit, NUnit, MSTest) | `public void test_T_MOD_01_aucune_vulnerabilite()` |
| Python (pytest) | `def test_T_MOD_01_aucune_vulnerabilite():` |
| Go | `func Test_T_MOD_01_aucune_vulnerabilite(t *testing.T)` |
| C++ (CTest) | `add_test(NAME T_MOD_01_aucune_vulnerabilite COMMAND …)` |
| Robot Framework | `T-MOD-01 Aucune vulnérabilité` (oder das Tag `[Tags]  T-MOD-01`) |
| Cucumber, Behave | `@T-MOD-01` über dem Szenario |

Einzelheiten des Formats: [Format der Ergebnisse](/docs/resultats).

## 2. SBOM und Bericht erzeugen

**Ein Werkzeug für alle Sprachen**: [Syft](https://github.com/anchore/syft) liest Ihr Verzeichnis und erzeugt die SBOM.

```bash
syft dir:. -o cyclonedx-json=sbom.cyclonedx.json
```

Sie können auch das CycloneDX-Werkzeug Ihrer Sprache verwenden:

| Sprache | SBOM (CycloneDX JSON) | Testbericht (so wie er ist) |
|---|---|---|
| **Java — Maven** | `mvn org.cyclonedx:cyclonedx-maven-plugin:makeAggregateBom` → `target/bom.json` | `mvn test` → `target/surefire-reports/TEST-*.xml` |
| **Java — Gradle** | Plugin `org.cyclonedx.bom`, dann `./gradlew cyclonedxBom` → `build/reports/` | `./gradlew test` → `build/test-results/test/TEST-*.xml` |
| **C# — .NET** | das Werkzeug `CycloneDX` (`dotnet tool install --global CycloneDX`), oder Syft | `dotnet test --logger trx` → `TestResults/*.trx` (TRX), oder `TestResult.xml` von NUnit, oder das JUnit von `JunitXml.TestLogger` |
| **Python** | `pip install cyclonedx-bom`, dann `cyclonedx-py environment --output-format JSON --output-file sbom.cyclonedx.json` | `pytest --junitxml=resultats.xml` |
| **Java — TestNG** | wie Maven oder Gradle | `testng-results.xml` (nativ) |
| **Go** | Syft | `go test -v ./... 2>&1 \| go-junit-report > resultats.xml` |
| **C, C++ — CMake** | Syft | `ctest -T Test` → `Testing/<date>/Test.xml` (oder `ctest --output-junit resultats.xml`) |
| **Robot Framework** | Syft (oder das CycloneDX-Werkzeug von Python) | `robot …` → `output.xml` |
| **BDD — Cucumber, Behave** | das Werkzeug der Sprache | `--format json:cucumber.json`; `behave -f json -o behave.json` |
| **Allure (jede Sprache)** | das Werkzeug der Sprache | `allure-results/`: `jq -s . allure-results/*-result.json > allure.json` für ein einziges Hochladen |
| **Andere** | Syft, oder `trivy fs --format cyclonedx --output sbom.cyclonedx.json .` | jedes Werkzeug, das eines dieser Formate schreibt, JUnit XML oder TAP |

## 3. Die beiden Dateien hochladen

**Über die Oberfläche.** Reiter [Ablauf](/aller/parcours): Laden Sie die SBOM in Schritt ③ hoch, dann den Bericht in Schritt ② (oder im
Reiter [Ausführungen](/aller/executions)). Der Bericht wird
der oben auf der Seite gewählten Version zugeordnet.

**Über Ihre CI.** Erstellen Sie einen Schlüssel im Reiter [Projekte](/aller/projets), Spalte **CI-Schlüssel**, und senden Sie dann die beiden Dateien mit `curl`.
**Geben Sie die Version an** (`version=`), in beiden Sendungen: Sie ordnet Ihre Tests in die Akte dieser
Version ein.

```bash
V=1.4.0   # die Version, die Sie ausliefern
curl -fsS -X POST "$QATRAX_URL/sbom?p=$QATRAX_PROJET&version=$V" \
  -H "Authorization: Bearer $QATRAX_CLE" -H "content-type: application/json" \
  --data-binary @sbom.cyclonedx.json
curl -fsS -X POST "$QATRAX_URL/runs?p=$QATRAX_PROJET&version=$V&format=json" \
  -H "Authorization: Bearer $QATRAX_CLE" -H "content-type: application/xml" \
  --data-binary @resultats.xml
```

Der `content-type` spielt kaum eine Rolle: Das Format wird am Inhalt erkannt (`.trx`, `output.xml`, `Test.xml`, `cucumber.json` …
werden auf dieselbe Weise gesendet). Wenn Sie mehrere Berichtsdateien haben (eine pro Testklasse bei Maven und
Gradle, eine pro Test bei Allure), senden Sie sie einzeln, oder fassen Sie die Allure-Ergebnisse in einem Array zusammen.

Die Antwort nennt das gelesene Format, die Zahl der in Ihrem Plan erkannten Tests und die nicht erkannten.

## 3a. Optional: der versiegelte Validierungsbericht, wie unter Node.js

Wenn Ihre CI Node.js hat (Version 18 oder höher, in den meisten Images vorhanden), kann `@mostajs/mjs-unit` den Bericht
Ihres Werkzeugs **lesen**. Es führt keinen Test erneut aus. Es erstellt daraus den **versiegelten Validierungsbericht**, verknüpft mit
Ihrer SBOM und Ihrem Plan, und sendet ihn mit dem Plan und der SBOM. Sie müssen kein JavaScript schreiben.

```bash
# Java (Maven): die Surefire-Berichte; .NET: TestResults (die .trx); Robot: output.xml; Allure: allure-results
export MJS_DEPUIS=target/surefire-reports MJS_SBOM=target/bom.json MJS_PLAN=plan.json
export QATRAX_URL=… QATRAX_CLE=… QATRAX_PROJET=…
npx -y -p @mostajs/mjs-unit mjs-unit-menu --choix=3   # liest die Berichte, schreibt den versiegelten Validierungsbericht
npx -y -p @mostajs/mjs-unit mjs-unit-menu --choix=4   # sendet den Plan, die SBOM, dann den Validierungsbericht
```

Mit dem Validierungsbericht nimmt qatrax zwei zusätzliche Prüfungen vor: Der Bericht wurde nach seinem Einlesen nicht verändert,
und es ist tatsächlich die hochgeladene SBOM, die geprüft wurde.

## 4. Ausstellen

Es ist dasselbe Ende wie für jeden Kunden: Reiter [SBOM/Schwachstellen](/aller/vulnerabilites), bewerten Sie jede; dann Reiter [Lieferobjekt](/aller/livrable) →
**Ausstellen und versiegeln**.

## Was sich gegenüber Node.js ändert

Urteil und Zertifikat sind dieselben. Ein einziger Unterschied: der **versiegelte Validierungsbericht**. Wenn Sie
Ihr JUnit oder Ihr TAP direkt senden (`curl`), nimmt qatrax die beiden Prüfungen des Validierungsberichts nicht vor. Es nimmt sie vor,
wenn Sie `mjs-unit` im Lesemodus verwenden (§ 3a).
