Zum Inhalt springen
Von C/AL zu AL: der Kurs für NAV-EntwicklerEin Kurs der decoso GmbH & Co. KGErstgespräch
Kursübersicht › Seite 9 von 11

Qualität: Tests, Code-Analyse, Debugging, Leistung

Automatische Tests, Code-Analyse, Debugging und Leistungsmessung für AL-Apps. Mit Übung an der Beispiel-App.

Stand November 2026 · Version 29

Autor: Elvis Schmidt, decoso GmbH & Co. KG

Lernziele dieser Seite Nach dieser Seite kannst du eine Test-App neben deiner App anlegen, Test-Codeunits mit Handlern und Testseiten schreiben, Tests mit eingeschränkten Berechtigungen laufen lassen, die Code-Analyse mit einem eigenen Ruleset steuern, mit dem Debugger und dem Snapshot-Debugger Fehler in Sandbox und Produktion finden, die häufigsten Leistungsbremsen im Datenzugriff vermeiden und mit Telemetrie sehen, was deine App beim Kunden tut.

1Was sich gegenüber NAV 2017 ändert

Test-Codeunits, Handler und Testseiten gab es in NAV 2017 bereits, sie wurden in Kundenprojekten aber selten benutzt. In Business Central werden sie wichtig, weil sich die Plattform unter deiner App monatlich ändert: Nur automatisierte Tests sagen dir vor dem Update, ob deine App mit der nächsten Version noch funktioniert. Neu sind außerdem die Code-Analyse beim Tippen, der Debugger in VS Code und die Telemetrie.

ThemaNAV 2017Business Central (AL)
TestsTest-Codeunits im selben Objektbestand, Test Toolkit als FOB, Page 130401 „CAL Test Tool“Eigene Test-App mit Abhängigkeit zur Haupt-App, Testbibliotheken als Apps, Page 130451 „AL Test Tool“
TestlaufVon Hand im ClientIm Client, aus VS Code, per PowerShell und automatisch in der Pipeline (Seite 10)
Code-QualitätRichtlinien auf Papier, Review von HandAnalyzer (CodeCop, UICop, PerTenantExtensionCop, AppSourceCop) melden Verstöße beim Tippen und im Build
DebuggerEigener Debugger-Client, Start über die SitzungslisteIn VS Code integriert: Haltepunkte im Quelltext, F5
Fehlersuche in ProduktionDebugger an Produktivsitzung hängenSnapshot-Debugging: Aufzeichnung, die du nachträglich durchgehst
SQL-AnalyseSQL Server Profiler, direkte AbfragenKein SQL-Zugriff in der Cloud; SQL-Anweisungen im Debugger, Leistungsprofiler, Telemetrie
DatenzugriffImmer alle Felder geladenTeilsätze mit SetLoadFields, steuerbare Leseisolation
ÜberwachungWindows-Ereignisanzeige auf dem ServerTelemetrie in Azure Application Insights, Auswertung mit KQL

2Die Test-App: Aufbau im Repository

Tests gehören nicht in die App, die du auslieferst. Sie liegen in einer zweiten App, die von der ersten abhängt. Der Kunde bekommt nur die Haupt-App; die Test-App läuft in deiner Sandbox und in der Pipeline.

abc-kundenapp/                      <- Git-Repository
├── abc-kundenapp.code-workspace    <- Workspace mit beiden Ordnern
├── app/                            <- Haupt-App (IDs 50100–50149)
│   ├── app.json
│   └── src/...
└── test/                           <- Test-App (IDs 50150–50199)
    ├── app.json
    ├── .vscode/launch.json
    └── src/
        ├── ABCVisitTests.Codeunit.al
        └── ABCVisitPermTests.Codeunit.al

test/app.json

{
  "id": "7b1e4c92-5a3d-4f8e-b6c1-9d2a7e5f3b10",
  "name": "ABC Kundenapp Tests",
  "publisher": "Meine Firma GmbH",
  "version": "1.1.0.0",
  "dependencies": [
    {
      "id": "3f2c8a51-7d4e-4b6a-9c1f-2e5d8a7b6c40",
      "name": "ABC Kundenapp",
      "publisher": "Meine Firma GmbH",
      "version": "1.1.0.0"
    },
    {
      "id": "dd0be2ea-f733-4d65-bb34-a28f4624fb14",
      "name": "Library Assert",
      "publisher": "Microsoft",
      "version": "26.0.0.0"
    },
    {
      "id": "5d86850b-0d76-4eca-bd7b-951ad998e997",
      "name": "Tests-TestLibraries",
      "publisher": "Microsoft",
      "version": "26.0.0.0"
    }
  ],
  "platform": "26.0.0.0",
  "application": "26.0.0.0",
  "idRanges": [ { "from": 50150, "to": 50199 } ],
  "runtime": "15.0",
  "target": "Cloud"
}
PunktErklärung
Eigene idDie Test-App ist eine eigenständige App mit eigener GUID. Erzeuge sie mit AL: Go! im Ordner test oder per GUID-Generator.
Abhängigkeit zur Haupt-AppDie id muss exakt die aus app/app.json sein. Im Workspace löst VS Code die Abhängigkeit direkt auf den Nachbarordner auf.
TestbibliothekenMicrosoft liefert sie als Apps (Abschnitt 6). Die GUIDs findest du in der Erweiterungsverwaltung oder im Ordner .alpackages.
Eigener ID-BereichGetrennt von der Haupt-App, damit Test-Objekte nie Nummern für Produktivobjekte belegen.
Kein Präfix-Zwang, keine ÜbersetzungDie Test-App wird nicht ausgeliefert. Das Präfix beizubehalten schadet trotzdem nicht.

Die Test-App sieht von der Haupt-App nur, was öffentlich ist. Prozeduren mit internal und Objekte mit Access = Internal (Seite 5) erreichst du nur, wenn die Haupt-App es ausdrücklich erlaubt. Dazu trägst du in app/app.json ein:

"internalsVisibleTo": [
  {
    "id": "7b1e4c92-5a3d-4f8e-b6c1-9d2a7e5f3b10",
    "name": "ABC Kundenapp Tests",
    "publisher": "Meine Firma GmbH"
  }
]

3Testumgebung einrichten

Tests laufen nur in Sandbox-Umgebungen, nie in Produktion. Die Umgebung braucht die Testbibliotheken und das Testwerkzeug.

UmgebungEinrichtung
DockerBeim Anlegen des Containers -includeTestToolkit angeben; mit -includeTestLibrariesOnly werden nur die Bibliotheken ohne Microsofts eigene Tests installiert (schneller, kleiner). Nachträglich geht es mit Import-TestToolkitToBcContainer.
Online-SandboxIn der Erweiterungsverwaltung die Apps „Test Runner“, „Library Assert“, „Any“, „Library Variable Storage“, „Permissions Mock“ und „Tests-TestLibraries“ installieren. Sie sind in Sandboxes bereitgestellt, aber nicht installiert.
# Docker: Container mit Testbibliotheken (Ergänzung zu Seite 2)
New-BcContainer -containerName bcdev `
    -artifactUrl (Get-BcArtifactUrl -type Sandbox -country de) `
    -auth UserPassword -credential $credential `
    -accept_eula -updateHosts `
    -includeTestToolkit -includeTestLibrariesOnly

Danach lädst du im Ordner test die Symbole (AL: Download Symbols). Veröffentliche zuerst die Haupt-App, dann die Test-App. Bequemer ist der Befehl AL: Publish full dependency tree for active project, der beide in der richtigen Reihenfolge veröffentlicht.

Nie gegen eine Sandbox mit echten Kundendaten testen, an der andere arbeiten. Tests legen Daten an, buchen und ändern Einrichtungen. Die Isolation (Abschnitt 9) rollt das zwar zurück, aber nur, wenn alles richtig konfiguriert ist. Nimm einen Container oder eine eigene Sandbox mit CRONUS-Daten.

4Aufbau einer Test-Codeunit

codeunit 50150 "ABC Visit Tests"
{
    Subtype = Test;
    TestPermissions = Disabled;

    var
        Assert: Codeunit "Library Assert";
        LibrarySales: Codeunit "Library - Sales";
        IsInitialized: Boolean;

    [Test]
    procedure InsertVisitUpdatesLastVisitOnCustomer()
    var
        Customer: Record Customer;
        Visit: Record "ABC Customer Visit";
    begin
        // [SCENARIO] Inserting a visit updates the last visit date on the customer
        Initialize();

        // [GIVEN] A customer without visits
        LibrarySales.CreateCustomer(Customer);

        // [WHEN] A visit is inserted for the work date
        CreateVisit(Visit, Customer."No.", WorkDate());

        // [THEN] The customer shows the work date as last visit
        Customer.Get(Customer."No.");
        Assert.AreEqual(WorkDate(), Customer."ABC Letzter Besuch", 'Last visit date was not updated.');
    end;

    local procedure Initialize()
    begin
        if IsInitialized then
            exit;
        // einmalige Vorbereitung für alle Tests dieser Codeunit
        IsInitialized := true;
        Commit();
    end;

    local procedure CreateVisit(var Visit: Record "ABC Customer Visit"; CustomerNo: Code[20]; VisitDate: Date)
    begin
        Visit.Init();
        Visit.Validate("Customer No.", CustomerNo);
        Visit.Validate("Visit Date", VisitDate);
        Visit.Insert(true);
    end;
}
BausteinErklärung
Subtype = TestMacht die Codeunit zur Test-Codeunit. Sie lässt sich nur über einen Test Runner ausführen.
[Test]Kennzeichnet eine Testprozedur. Sie hat keine Parameter und keinen Rückgabewert. Jede Testprozedur ist ein eigener Test mit eigenem Ergebnis.
ProzedurnameBeschreibt das erwartete Verhalten. Er ist das Erste, was du im Fehlerprotokoll liest.
[SCENARIO], [GIVEN], [WHEN], [THEN]Reine Kommentare, aber feste Konvention von Microsoft: Ausgangslage, Aktion, erwartetes Ergebnis. Halte dich daran, die Tests bleiben lesbar.
Initialize()Gemeinsame Vorbereitung, die nur beim ersten Test läuft. Das Commit() am Ende sorgt dafür, dass diese Vorbereitung beim Zurückrollen einzelner Tests erhalten bleibt.
HilfsprozedurenOhne [Test]. Lagere Datenerzeugung dorthin aus, damit die Tests selbst kurz bleiben.
TestPermissionsSteuert, mit welchen Rechten die Tests laufen (Abschnitt 10).

Ein Test gilt als bestanden, wenn die Prozedur ohne Fehler endet. Jeder Fehler, auch ein unerwarteter TestField-Fehler tief im Standard, lässt ihn scheitern.

5Assert und asserterror

Codeunit „Library Assert“

MethodePrüft
AreEqual(Erwartet, Tatsächlich, Meldung)Gleichheit zweier Werte
AreNotEqual(...)Ungleichheit
AreNearlyEqual(Erwartet, Tatsächlich, Toleranz, Meldung)Dezimalwerte mit Rundungstoleranz
IsTrue(Bedingung, Meldung), IsFalse(...)Boolesche Bedingung
RecordIsEmpty(Rec), RecordIsNotEmpty(Rec)Ob es Sätze im Filter gibt
RecordCount(Rec, Anzahl)Anzahl der Sätze im Filter
ExpectedError(Text)Ob der zuletzt abgefangene Fehler den Text enthält
ExpectedErrorCode(Code)Fehlercode statt Text, z. B. 'TestField' oder 'Dialog'
Fail(Meldung)Lässt den Test ausdrücklich scheitern

Die Reihenfolge der Parameter ist immer: erst der erwartete, dann der tatsächliche Wert. Schreibe die Meldung so, dass sie ohne den Quelltext verständlich ist.

Erwartete Fehler mit asserterror

Ein Test muss auch prüfen, dass etwas Verbotenes wirklich abgelehnt wird. asserterror dreht die Logik um: Die folgende Anweisung muss einen Fehler auslösen, sonst scheitert der Test.

[Test]
procedure LastVisitInFutureIsRejected()
var
    Customer: Record Customer;
begin
    // [SCENARIO] A last visit date in the future is not allowed
    Initialize();
    LibrarySales.CreateCustomer(Customer);

    // [WHEN] The last visit is set to tomorrow
    asserterror Customer.Validate("ABC Letzter Besuch", CalcDate('<+1D>', Today()));

    // [THEN] The expected error is raised
    Assert.ExpectedError('The last visit cannot be in the future.');
end;
Immer den Fehler prüfen. Ein asserterror ohne anschließendes ExpectedError besteht bei jedem Fehler, auch bei einem Tippfehler in deinen Testdaten. Außerdem rollt asserterror die Transaktion bis zum letzten Commit zurück; Daten, die du davor im Test angelegt hast, sind danach weg.

6Testdaten und Bibliotheken

Ein guter Test erzeugt die Daten, die er braucht, selbst. Er verlässt sich nicht darauf, dass es in CRONUS den Debitor 10000 gibt. Microsoft liefert dafür Bibliotheken, die du über die Abhängigkeit „Tests-TestLibraries“ bekommst.

CodeunitBeispiele
"Library - Sales"CreateCustomer, CreateSalesHeader, CreateSalesLine, PostSalesDocument
"Library - Purchase"CreateVendor, CreatePurchHeader, PostPurchaseDocument
"Library - Inventory"CreateItem, CreateItemJournalLine
"Library - ERM"Sachkonten, Buchungsgruppen, Fibu-Buch.-Blätter
"Library - Random"RandInt, RandDec, RandDate, RandText
"Library - Utility"GenerateGUID, GenerateRandomCode, Nummernserien
"Library - Variable Storage"Warteschlange, um Werte zwischen Test und Handler auszutauschen (Abschnitt 7)
"Library - Report Dataset"Bericht ausführen und das Dataset als XML prüfen
Any (eigene App)Schlanke Alternative für Zufallswerte

Für deine eigenen Tabellen schreibst du dir eine kleine Bibliothek nach demselben Muster, etwa codeunit 50159 "ABC Library - Visit" mit CreateVisit, CreateVisitSetup und so weiter. Dann steht die Datenerzeugung an einer Stelle, und ein neues Pflichtfeld bricht nicht fünfzig Tests.

Zufallswerte mit Bedacht. Microsofts Bibliotheken liefern Zufallswerte mit festem Startwert, die Tests sind also wiederholbar. Nutze Zufall für Werte, die für den Test egal sind (Name, Menge), und feste Werte für das, was du prüfst.

7UI-Handler

Tests laufen ohne Oberfläche. Trifft der Code auf ein Message, Confirm oder eine modale Seite, scheitert der Test mit „Unhandled UI“. Du musst jede solche Stelle mit einem Handler beantworten. Das zwingt dich, die Dialoge deiner App bewusst zu testen.

AttributFängt abSignatur
[MessageHandler]Message(Message: Text[1024])
[ConfirmHandler]Confirm(Question: Text[1024]; var Reply: Boolean)
[StrMenuHandler]StrMenu(Options: Text[1024]; var Choice: Integer; Instruction: Text[1024])
[PageHandler]Nicht modale Seite (Page.Run)(var TestPage: TestPage "X")
[ModalPageHandler]Modale Seite (Page.RunModal, Lookups)(var TestPage: TestPage "X")
[RequestPageHandler]Anforderungsseite eines Berichts(var RequestPage: TestRequestPage "X")
[ReportHandler]Berichtslauf(var Report: Report "X")
[SendNotificationHandler]Notification.Send(var Notification: Notification): Boolean
[HyperlinkHandler]Hyperlink(Url: Text[1024])
[Test]
[HandlerFunctions('TopCustomersMessageHandler')]
procedure TopCustomersShowsCustomerWithVisits()
var
    Customer: Record Customer;
    Visit: Record "ABC Customer Visit";
    VisitStatistics: Codeunit "ABC Visit Statistics";
begin
    // [SCENARIO] The top customers message lists a customer that has visits
    Initialize();

    // [GIVEN] A customer with two visits in the last year
    LibrarySales.CreateCustomer(Customer);
    CreateVisit(Visit, Customer."No.", WorkDate());
    CreateVisit(Visit, Customer."No.", WorkDate() - 10);
    ExpectedCustomerNo := Customer."No.";

    // [WHEN] The statistics are shown
    VisitStatistics.ShowTopCustomers();

    // [THEN] Verified in the message handler
end;

[MessageHandler]
procedure TopCustomersMessageHandler(Message: Text[1024])
begin
    Assert.IsTrue(Message.Contains(ExpectedCustomerNo), 'Customer is missing in the top customers message.');
end;

Dazu gehört eine globale Variable ExpectedCustomerNo: Code[20]. Für mehrere Werte nimmst du die Codeunit "Library - Variable Storage" mit Enqueue im Test und Dequeue im Handler.

RegelErklärung
Handler müssen benutzt werdenEin in HandlerFunctions genannter Handler, der nicht aufgerufen wurde, lässt den Test scheitern. So merkst du, wenn ein erwarteter Dialog ausbleibt.
Mehrere HandlerDurch Komma getrennt: [HandlerFunctions('ConfirmYes,PostedMessage')].
Ein Handler je ArtPro Test nur ein ConfirmHandler; er bekommt alle Rückfragen der Reihe nach. Unterscheide über den Fragetext oder eine Warteschlange.
Fehler brauchen keinen HandlerError fängst du mit asserterror ab.

8Testseiten (TestPage)

Eine TestPage-Variable bedient eine Page wie ein Anwender, nur ohne Browser: öffnen, Felder füllen, Aktionen auslösen. Dabei laufen alle Page-Trigger, Feldvalidierungen und Editable-Regeln. Damit testest du die Logik, die auf der Page liegt und die ein reiner Tabellentest nicht erreicht.

[Test]
procedure VisitCanBeEnteredOnListPage()
var
    Customer: Record Customer;
    Visit: Record "ABC Customer Visit";
    VisitList: TestPage "ABC Customer Visits";
begin
    // [SCENARIO] A user can enter a visit on the list page
    Initialize();
    LibrarySales.CreateCustomer(Customer);

    // [WHEN] The user enters a new line
    VisitList.OpenNew();
    VisitList."Customer No.".SetValue(Customer."No.");
    VisitList."Visit Date".SetValue(WorkDate());
    VisitList.Description.SetValue('Entered by test');
    VisitList.Close();

    // [THEN] Exactly one visit exists for the customer
    Visit.SetRange("Customer No.", Customer."No.");
    Assert.RecordCount(Visit, 1);
end;
MethodeBedeutung
OpenView(), OpenEdit(), OpenNew()Seite im Ansichts-, Bearbeitungs- oder Neuanlagemodus öffnen
GoToRecord(Rec), GoToKey(...)Auf einen bestimmten Datensatz springen
First(), Next(), Last(), New()Navigation in Listen
Filter.SetFilter(Feld, Wert)Filter wie über die Filterleiste
Feld.SetValue(Wert)Wert eingeben, löst OnValidate aus
Feld.Value, Feld.AsInteger(), AsDecimal(), AsDate()Angezeigten Wert lesen
Feld.AssertEquals(Wert)Wert prüfen
Feld.Visible(), Enabled(), Editable()Zustand des Steuerelements prüfen
Feld.Lookup(), Drilldown()Lookup oder DrillDown auslösen (braucht meist einen ModalPageHandler)
Aktion.Invoke()Aktion ausführen
Teilseite.Feld...Zugriff auf Parts, etwa Belegzeilen
Trap()Fängt die nächste Seite ab, die der Code mit Page.Run öffnet
Close(), OK().Invoke(), Cancel().Invoke()Seite schließen

Angesprochen werden die Namen der Steuerelemente aus der Page, also der erste Teil von field(Name; Rec.Feld), nicht die Feldnamen der Tabelle. Felder aus Page Extensions erreichst du genauso über ihren Steuerelementnamen. Felder, die auf der Seite nicht sichtbar oder nicht editierbar sind, lassen sich wie beim Anwender nicht füllen.

Faustregel: Geschäftslogik testest du über Records und Codeunits, das ist schneller und stabiler. Testseiten nimmst du für das, was nur die Oberfläche kann: Sichtbarkeit, Editierbarkeit, Aktionen, Zusammenspiel von Kopf und Zeilen.

9Isolation und Transaktionen

Tests dürfen sich nicht gegenseitig beeinflussen und sollen die Datenbank so hinterlassen, wie sie sie vorgefunden haben. Dafür sorgt der Test Runner, eine Codeunit mit Subtype = TestRunner, über die Eigenschaft TestIsolation.

TestIsolationWirkung
CodeunitAlle Änderungen werden nach jeder Test-Codeunit zurückgerollt, auch bereits ausgeführte Commits. Das ist der Standard des mitgelieferten Runners.
FunctionZurückrollen nach jeder einzelnen Testprozedur. Sauberer, aber langsamer.
DisabledNichts wird zurückgerollt. Nur für Sonderfälle.

Den Runner musst du nicht selbst schreiben; die App „Test Runner“ bringt fertige mit, und im AL Test Tool wählst du den gewünschten aus. Innerhalb eines Tests steuert zusätzlich ein Attribut das Transaktionsverhalten:

[Test]
[TransactionModel(TransactionModel::AutoRollback)]
procedure SomethingWithoutCommit()
begin
    ...
end;
WertBedeutung
AutoCommitStandard. Am Ende der Prozedur wird festgeschrieben (und vom Runner je nach Isolation wieder zurückgerollt). Der getestete Code darf Commit aufrufen.
AutoRollbackAlles wird am Ende zurückgerollt. Ruft der getestete Code Commit auf, gibt es einen Fehler.
NoneDer Test läuft ohne umgebende Schreibtransaktion, wie ein Aufruf aus der Oberfläche. Nötig für Tests mit Testseiten, die einen sauberen Transaktionszustand erwarten.

Trotz Isolation gilt: Schreibe jeden Test so, dass er allein und in beliebiger Reihenfolge läuft. Was ein Test voraussetzt, legt er selbst an.

10Tests mit Berechtigungen

Auf Seite 8 hast du mit einem zweiten Benutzer von Hand geprüft, ob deine Berechtigungssätze reichen. Das lässt sich automatisieren. Die Codeunit „Permissions Mock“ (eigene App von Microsoft) tauscht innerhalb eines Tests die wirksamen Berechtigungssätze aus.

codeunit 50151 "ABC Visit Perm. Tests"
{
    Subtype = Test;
    TestPermissions = Disabled;

    var
        Assert: Codeunit "Library Assert";
        LibrarySales: Codeunit "Library - Sales";
        PermissionsMock: Codeunit "Permissions Mock";

    [Test]
    procedure EditSetCanInsertVisitAndUpdatesCustomerIndirectly()
    var
        Customer: Record Customer;
        Visit: Record "ABC Customer Visit";
    begin
        // [GIVEN] A customer, created with full permissions
        LibrarySales.CreateCustomer(Customer);

        // [GIVEN] A user with read access to standard data and the edit set
        PermissionsMock.Set('D365 READ');
        PermissionsMock.Assign('ABC Visit - Edit');

        // [WHEN] The user inserts a visit
        Visit.Init();
        Visit.Validate("Customer No.", Customer."No.");
        Visit.Validate("Visit Date", WorkDate());
        Visit.Insert(true);

        // [THEN] The customer was updated through the indirect permission
        Customer.Get(Customer."No.");
        Assert.AreEqual(WorkDate(), Customer."ABC Letzter Besuch", 'Indirect modify permission did not work.');

        PermissionsMock.ClearAssignments();
    end;

    [Test]
    procedure ReadSetCannotInsertVisit()
    var
        Customer: Record Customer;
        Visit: Record "ABC Customer Visit";
    begin
        LibrarySales.CreateCustomer(Customer);

        // [GIVEN] A user with read-only sets
        PermissionsMock.Set('D365 READ');
        PermissionsMock.Assign('ABC Visit - Read');

        // [WHEN] The user tries to insert a visit
        Visit.Init();
        Visit.Validate("Customer No.", Customer."No.");
        Visit.Validate("Visit Date", WorkDate());
        asserterror Visit.Insert(true);

        // [THEN] A permission error is raised
        Assert.AreNotEqual('', GetLastErrorText(), 'Insert should have failed.');

        PermissionsMock.ClearAssignments();
    end;
}
MethodeBedeutung
Set(Name)Ersetzt alle wirksamen Sätze durch diesen einen
Assign(Name)Fügt einen weiteren Satz hinzu
ClearAssignments()Stellt die vollen Rechte wieder her

Der zweite Test ist schwächer, als er aussieht: Er besteht bei jedem Fehler. Besser ist eine Prüfung auf den Fehlercode oder einen Textbestandteil der Berechtigungsmeldung. Sieh dir dazu in deiner Version einmal GetLastErrorCode() im Debugger an und prüfe dann mit Assert.ExpectedErrorCode.

Die Eigenschaft TestPermissions an der Test-Codeunit ist der ältere Mechanismus: Disabled lässt alles mit vollen Rechten laufen, Restrictive und NonRestrictive arbeiten mit vordefinierten Rechtegruppen des Runners. Mit dem Permissions Mock bist du genauer, weil du deine eigenen Sätze prüfst.

11Tests ausführen

WegVorgehenGeeignet für
AL Test Tool im ClientSuche „AL Test Tool“ (Page 130451) oder ?page=130451; „Test-Codeunits abrufen“, auswählen, „Ausführen“. Ergebnis je Prozedur mit Fehlertext und Aufrufliste.Einstieg, einzelne Tests
VS CodeDie AL-Erweiterung zeigt Tests in neueren Versionen im Test-Explorer; verbreitet ist außerdem die Erweiterung „AL Test Runner“ (James Pearson), die Tests direkt aus dem Editor startet und das Ergebnis an der Prozedur anzeigt.Tägliche Entwicklung
Debuggerlaunch.json der Test-App mit "startupObjectId": 130451, "startupObjectType": "Page"; Haltepunkt in den Test setzen, F5.Fehlersuche im Test
PowerShellRun-TestsInBcContainer aus BcContainerHelperSkripte, Pipeline
AL-Go für GitHubErkennt Test-Apps im Repository, baut einen Container, führt alle Tests bei jedem Pull Request aus (Seite 10)Automatische Absicherung
# Alle Tests der Test-App im Container ausführen
Run-TestsInBcContainer -containerName bcdev `
    -credential $credential `
    -extensionId "7b1e4c92-5a3d-4f8e-b6c1-9d2a7e5f3b10" `
    -detailed
Arbeitsrhythmus: Erst den Test schreiben, der das gewünschte Verhalten beschreibt, und ihn scheitern sehen. Dann den Code schreiben, bis der Test besteht. Ein Test, den du nie hast scheitern sehen, beweist nichts. Bei jedem Fehler, den ein Kunde meldet, schreibst du zuerst einen Test, der ihn nachstellt.

12Was testen, was nicht?

Lohnt sichLohnt sich kaum
Eigene Berechnungen und Prüfungen
Event Subscriber auf Buchungsroutinen: Beleg anlegen, buchen, Ergebnis prüfen
Durchreichen eigener Felder in gebuchte Belege und Posten
Berechtigungssätze
Import- und Exportformate (Stream hinein, Ergebnis prüfen)
API-Pages über Testseiten oder direkte Record-Logik
Jeder gemeldete Fehler als Regressionstest
Den Standard selbst (das testet Microsoft)
Reine Layoutfragen von Pages und Berichten
Triviale Felder ohne Logik
Externe Webdienste direkt (stattdessen die eigene Verarbeitung mit gespeicherten Antworten testen)

Für Webaufrufe (Seite 6) baust du den Code so, dass das Senden und das Verarbeiten der Antwort getrennte Prozeduren sind. Die Verarbeitung testest du mit einem festen JSON-Text. Sauberer wird es mit einem Interface für den Aufruf, das der Test durch eine Attrappe ersetzt (Seite 5). Neuere Versionen kennen zusätzlich einen [HttpClientHandler], der ausgehende Aufrufe im Test abfängt.

Der wichtigste Nutzen in der Cloud: Du lässt deine Tests gegen die nächste Business-Central-Version laufen, bevor Microsoft sie beim Kunden einspielt. Vorschauversionen stehen als Docker-Artefakte und als Sandbox-Vorschau bereit; AL-Go kann das regelmäßig automatisch tun (Seite 10).

13Code-Analyse: die Cops

Auf Seite 2 hast du in .vscode/settings.json die Analyzer eingeschaltet. Sie prüfen den Code beim Tippen und im Build und zeigen Meldungen im Fenster „Probleme“ (Strg+Umschalt+M).

AnalyzerPräfixPrüftEinsatz
CompilerALSyntax, Typen, veraltete ElementeImmer
CodeCopAAStil und gute Praxis im CodeImmer
UICopAWRegeln für den Web-Client: Aktionen, Bilder, SeitentypenImmer
PerTenantExtensionCopPTETechnische Vorgaben für Per-Tenant-Extensions: ID-Bereich, Präfix, BerechtigungenKundenspezifische Apps
AppSourceCopASVorgaben für AppSource, vor allem Verbot inkompatibler Änderungen gegenüber der VorversionAppSource-Apps; nicht zusammen mit PTE-Cop
LinterCop (Community)LCZusätzliche Regeln, z. B. fehlende SetLoadFields-Kandidaten, KomplexitätOptional, wird als Analyzer-DLL eingebunden

Regeln, die Umsteiger am häufigsten treffen

RegelInhalt
AA0005begin..end nur um zusammengesetzte Anweisungen
AA0008Prozeduraufrufe mit Klammern: Rec.Insert(), Today()
AA0021Reihenfolge der Variablendeklarationen (Record, Report, Codeunit … vor einfachen Typen)
AA0072Variablennamen sollen den Objektnamen enthalten
AA0073Temporäre Variablen beginnen mit Temp
AA0074Labels mit Endung nach Verwendungszweck (Msg, Err, Qst, Lbl, Tok, Txt)
AA0137Unbenutzte Variable
AA0139Möglicher Überlauf bei Zuweisung an ein kürzeres Textfeld
AA0175, AA0181, AA0233Falsche Find-Methode: gefundenen Satz nicht benutzt, FindSet ohne Next, FindFirst mit Next
AA0210Filter auf Feldern ohne Schlüssel
AA0216, AA0217Texte in Error, Message, StrSubstNo als Label statt als Literal
AA0218, AA0219ToolTip vorhanden und beginnt mit „Specifies“
AA0228Unbenutzte lokale Prozedur
AL0432Verwendung eines veralteten Elements (ObsoleteState = Pending)
AL0604, AL0606Stillschweigendes oder ausdrückliches WITH
PTE0004Tabelle ohne passende Berechtigung in einem Berechtigungssatz der App (Seite 8)

Viele Meldungen behebt VS Code selbst: Cursor auf die Stelle, Strg+., und die Glühbirne bietet eine Korrektur an, teils für das ganze Projekt.

14Rulesets und Pragmas

Nicht jede Regel passt zu jedem Team. Mit einem Ruleset stellst du je Regel ein, ob sie Fehler, Warnung, Hinweis oder ausgeschaltet ist. Die Datei hast du auf Seite 2 angelegt.

{
  "name": "ABC Ruleset",
  "description": "Regeln fuer die ABC Kundenapp",
  "rules": [
    { "id": "AA0072", "action": "None",    "justification": "Kurze Variablennamen sind bei uns erlaubt." },
    { "id": "AA0137", "action": "Error",   "justification": "Unbenutzte Variablen werden nicht eingecheckt." },
    { "id": "AA0218", "action": "Error",   "justification": "Jedes Feld braucht einen ToolTip." },
    { "id": "AL0432", "action": "Warning", "justification": "Veraltetes sichtbar halten, aber Build nicht brechen." },
    { "id": "PTE0004","action": "Error",   "justification": "Keine Tabelle ohne Berechtigungssatz." }
  ]
}
actionWirkung
ErrorBuild scheitert
WarningGelbe Meldung
InfoBlauer Hinweis
HiddenNur im Editor als Punktlinie
NoneRegel abgeschaltet
DefaultVorgabe des Analyzers

Über includedRuleSets kann ein Ruleset ein anderes einbinden, etwa ein gemeinsames Firmen-Ruleset für alle Repositories. Das Ruleset liegt im Repository, also gelten für alle Entwickler und für die Pipeline dieselben Regeln.

Einzelne Stellen ausnehmen

#pragma warning disable AL0432
        Visit."Contact No." := FindContactNo(Visit."Contact Person");   // veraltetes Feld, hier gewollt
#pragma warning restore AL0432

Ein Pragma gilt von disable bis restore. Schreibe immer dazu, warum. Für eine ganze App gibt es in app.json die Liste "suppressWarnings"; sie ist das gröbste Mittel und versteckt auch neue Fälle.

Strategie für ein neues Projekt: Mit allen Regeln als Warnung starten, die Warnungen auf null bringen und dann schrittweise die wichtigsten auf Error stellen. Ein Projekt mit dreihundert ignorierten Warnungen ist so gut wie eines ohne Analyse: Die eine wichtige neue Warnung sieht niemand.

15Debugger

Der Debugger sitzt in VS Code. Haltepunkt mit F9 in eine Zeile setzen, F5 drücken, im Browser die Stelle auslösen. VS Code hält an und zeigt Variablen, Aufrufliste und den aktuellen Datensatz.

TasteWirkung
F5Veröffentlichen und mit Debugger starten
Strg+F5Veröffentlichen ohne Debugger
Strg+Umschalt+F5Debuggen ohne erneutes Veröffentlichen
Alt+F5Schnelles Veröffentlichen nur der geänderten Objekte (RAD) mit Debugger
F10 / F11 / Umschalt+F11Prozedurschritt / Einzelschritt hinein / hinaus
F5 (im Halt)Weiterlaufen bis zum nächsten Haltepunkt
Umschalt+F5Debuggen beenden

Was der Debugger kann

FunktionBeschreibung
Bedingte HaltepunkteRechtsklick auf den Haltepunkt, Bedingung eingeben, z. B. Customer."No." = '10000'. Unverzichtbar in Schleifen.
ProtokollpunkteSchreiben eine Meldung in die Debugkonsole, ohne anzuhalten.
Standardcode debuggenMit F12 in die Base Application springen und dort Haltepunkte setzen; F11 läuft in Microsoft-Code hinein.
VariablenLokale und globale Variablen, bei Records alle Felder, Filter, aktueller Schlüssel und ob der Satz temporär ist. Werte lassen sich nicht ändern.
ÜberwachenAusdrücke dauerhaft im Blick behalten.
DatenbankstatistikUnter den Variablen: Zahl der SQL-Anweisungen und gelesenen Zeilen seit Start, dazu die letzten SQL-Anweisungen im Wortlaut. Das ist dein Ersatz für den SQL Profiler.
Bei Fehler anhaltenHält an der Zeile an, die den Fehler auslöst, auch ohne Haltepunkt.
Bei Schreibzugriff anhaltenHält bei jedem Insert, Modify, Delete an. Hilft bei der Frage „Wer ändert dieses Feld?“.

Einstellungen in launch.json

{
  "name": "Sandbox DEV",
  "type": "al",
  "request": "launch",
  "environmentType": "Sandbox",
  "environmentName": "DEV",
  "tenant": "contoso.onmicrosoft.com",
  "startupObjectId": 50100,
  "startupObjectType": "Page",
  "breakOnError": "ExcludeTry",
  "breakOnRecordWrite": "None",
  "enableSqlInformationDebugger": true,
  "enableLongRunningSqlStatements": true,
  "longRunningSqlStatementsThreshold": 500,
  "numberOfSqlStatements": 10
},
{
  "name": "An laufende Sitzung anhaengen",
  "type": "al",
  "request": "attach",
  "environmentType": "Sandbox",
  "environmentName": "DEV",
  "tenant": "contoso.onmicrosoft.com",
  "breakOnNext": "WebServiceClient"
}

Die zweite Konfiguration hängt den Debugger an die nächste Sitzung der angegebenen Art an, ohne etwas zu veröffentlichen. Mit "breakOnNext": "WebServiceClient" debuggst du so einen API-Aufruf aus Seite 7, mit "Background" einen Lauf der Aufgabenwarteschlange, mit "WebClient" die nächste Browser-Sitzung.

Grenzen: Der Debugger funktioniert nur in Sandbox-Umgebungen und nur für den Benutzer, der ihn startet. Eine angehaltene Sitzung hält ihre Datenbanksperren; in einer gemeinsam genutzten Sandbox blockierst du damit Kollegen. Mit [NonDebuggable] markierte Prozeduren und Variablen (Seite 6) zeigt er nicht an.

16Snapshot-Debugging und Fehlersuche beim Kunden

In der Produktion darfst du keine Sitzung anhalten. Stattdessen zeichnest du den Ablauf auf und gehst ihn anschließend in VS Code durch wie eine Aufnahme.

{
  "name": "Snapshot PROD",
  "type": "al",
  "request": "snapshotInitialize",
  "environmentType": "Production",
  "environmentName": "Production",
  "tenant": "kunde.onmicrosoft.com",
  "breakOnNext": "WebClient",
  "userId": "anwender@kunde.de",
  "executionContext": "DebugAndProfile",
  "snapshotVerbosity": "SnapPoint"
}
SchrittVorgehen
1. Snappoints setzenWie Haltepunkte, aber als „Snappoint“. An diesen Stellen wird der Zustand der Variablen festgehalten.
2. Aufzeichnung startenF7. Die nächste Sitzung des genannten Benutzers wird aufgezeichnet.
3. Fehler nachstellenDer Anwender (oder du mit seinem Vorgehen) führt den Ablauf im Browser aus. Er merkt nichts außer etwas geringerer Geschwindigkeit.
4. Aufzeichnung beendenAlt+F7. Die Snapshot-Datei wird heruntergeladen.
5. AbspielenUmschalt+F7, Snapshot wählen. VS Code zeigt den Ablauf; du springst von Snappoint zu Snappoint und siehst Variablen und Aufrufliste.

Der Benutzer, der aufzeichnet, braucht den Berechtigungssatz D365 SNAPSHOT DEBUG, und du brauchst die Symbole und den Quellcode genau der Version, die beim Kunden läuft. Dafür hast du auf Seite 8 den Git-Tag gesetzt. Mit "executionContext": "Profile" entsteht statt eines Debug-Snapshots ein Leistungsprofil (Abschnitt 18).

Weitere Hilfen ohne Entwicklerwerkzeug

WerkzeugWoNutzen
SeitenprüfungStrg+Alt+F1Tabelle, Felder, Filter, beteiligte Erweiterungen der aktuellen Seite
Letzter Fehler„Hilfe und Support“ → ProblembehandlungFehlertext mit AL-Aufrufliste; der Anwender kann sie kopieren und dir schicken
EreignisaufzeichnungSuche „Ereignisaufzeichnung“Welche Events löst ein Ablauf aus? (Seite 5)
LeistungsprofilerSuche „Leistungsprofiler“Ablauf aufzeichnen, Zeitanteile je App und Prozedur sehen
DatenbanksperrenSuche „Datenbanksperren“Wer sperrt gerade was?
TabelleninformationenSuche „Tabelleninformationen“Satzanzahl und Größe je Tabelle
Effektive BerechtigungenBenutzerkarteWoher kommt ein Recht, wo fehlt es? (Seite 8)
TelemetrieApplication InsightsFehler, lange Abfragen, Sperren im Rückblick (Abschnitt 19)

17Leistung: Datenzugriff

In NAV 2017 konntest du langsamen Code mit einem stärkeren Server und einem Index direkt auf dem SQL Server retten. In der Cloud teilst du dir die Ressourcen, es gibt Zeitlimits, und an den SQL Server kommst du nicht heran. Leistung entsteht im AL-Code.

Teilsätze mit SetLoadFields

Standardmäßig lädt jede Leseoperation alle Felder der Tabelle und, per Join, alle Felder aller Table Extensions. Bei einer Tabelle wie Debitor mit mehreren installierten Apps ist das viel. SetLoadFields beschränkt das Laden auf die genannten Felder.

Vorher

if Customer.FindSet() then
    repeat
        Total += Customer."Credit Limit (LCY)";
    until Customer.Next() = 0;

Nachher

Customer.SetLoadFields("Credit Limit (LCY)");
if Customer.FindSet() then
    repeat
        Total += Customer."Credit Limit (LCY)";
    until Customer.Next() = 0;
RegelErklärung
Vor dem Lesen setzenSetLoadFields wirkt auf das nächste Get, Find… oder Next.
Immer geladenPrimärschlüssel, Systemfelder und Felder mit gesetztem Filter.
NachladenGreifst du auf ein nicht geladenes Feld zu, lädt die Plattform es nach. Das funktioniert, kostet aber eine zusätzliche Abfrage je Datensatz. In einer Schleife ist das schlimmer als gar kein SetLoadFields.
SchreibenVor Modify, Delete, Rename oder TransferFields lädt die Plattform den ganzen Satz nach. Für Schleifen, die ändern, bringt es wenig.
Übergabe an andere ProzedurenVorsicht: Die aufgerufene Prozedur weiß nicht, welche Felder fehlen. Nutze Teilsätze dort, wo du den ganzen Lesevorgang überblickst.
Berichte und PagesLaden von sich aus nur die verwendeten Felder; dort musst du nichts tun.

Die richtige Lesemethode

AbsichtRichtigFalsch
Gibt es einen Satz?if not Rec.IsEmpty() thenif Rec.FindFirst() then, if Rec.Count() > 0 then
Genau einen Satz lesenGet oder FindFirst / FindLastFindSet, Find('-')
Alle Sätze durchlaufenFindSet() mit Next()FindFirst mit Next
Durchlaufen und ändernFindSet(true)FindSet() ohne Sperrabsicht, dann Modify
Summe bildenCalcSums, FlowField, QuerySchleife mit Addition
Alle Sätze gleich ändernModifyAll, DeleteAllSchleife mit Modify / Delete
Zwei Tabellen verknüpft auswertenQuery (Seite 7)Verschachtelte Schleifen
Anzahl für eine AnzeigeCount nur wenn nötig, sonst IsEmptyCount in jeder Zeile einer Liste
// Summe ohne Schleife
CustLedgerEntry.SetRange("Customer No.", CustomerNo);
CustLedgerEntry.SetRange(Open, true);
CustLedgerEntry.CalcSums("Sales (LCY)");
Total := CustLedgerEntry."Sales (LCY)";

Schlüssel und Filter

Filterst oder sortierst du regelmäßig nach einem Feld, braucht die Tabelle einen passenden Schlüssel. In eigenen Tabellen legst du ihn im Abschnitt keys an, für Standardtabellen in der Table Extension (nur über Standardfelder oder nur über eigene Felder, Seite 3). SetCurrentKey bestimmt nur die Sortierung; welchen Index der SQL Server zum Filtern nimmt, entscheidet er selbst. Zu viele Schlüssel bremsen das Schreiben, lege also nur an, was du brauchst.

Weitere Bremsen

BremseAbhilfe
Code im OnAfterGetRecord einer ListenseiteLäuft für jede sichtbare Zeile. Nichts Teures dort; Werte als FlowField oder im OnAfterGetCurrRecord berechnen.
Viele FlowFields auf einer ListeJedes ist eine Unterabfrage je Zeile. Nur zeigen, was gebraucht wird; passende SumIndexFields anlegen.
FactBox mit schwerer BerechnungPage Background Task (Seite 5): Die Seite öffnet sofort, der Wert kommt nach.
Subscriber auf Datenbank-Events vielgenutzter TabellenLäuft bei jedem Schreibzugriff. Als Erstes if Rec.IsTemporary() then exit; und die billigste Bedingung prüfen.
Wiederholtes Lesen der Einrichtung in SchleifenEinmal vor der Schleife lesen oder in einer SingleInstance-Codeunit zwischenspeichern.
Einzelne Insert-Aufrufe mit ZwischenabfragenDie Plattform bündelt aufeinanderfolgende Inserts. Ein Find auf dieselbe Tabelle oder die Abfrage des Rückgabewerts von Insert unterbricht die Bündelung.
Zwischenergebnisse in echten TabellenTemporäre Tabellen, Listen und Dictionaries leben im Speicher.
Große Auswertungen auf der HauptdatenbankDataAccessIntent = ReadOnly an Berichten, Queries und API-Pages (Seite 7).
Texte in Schleifen zusammensetzenTextBuilder (Seite 6).

18Leistung: Sperren und Profiler

Sperren

Die meisten Klagen über „Business Central hängt“ sind Sperren: Eine Sitzung hält Datensätze fest, andere warten und laufen in die Zeitüberschreitung. Die Grundregeln sind dieselben wie früher, die Mittel sind feiner geworden.

RegelErklärung
Transaktionen kurz haltenErst lesen, rechnen und prüfen, dann gebündelt schreiben. Keine Webaufrufe und keine Dialoge in einer offenen Schreibtransaktion.
LockTable spät und seltenNach LockTable sperrt jedes Lesen dieser Tabelle bis zum Transaktionsende. Am Anfang einer langen Routine ist das eine Vollbremsung für alle.
Immer in derselben Reihenfolge sperrenZwei Routinen, die dieselben Tabellen in umgekehrter Reihenfolge sperren, erzeugen Deadlocks.
Leseisolation gezielt wählenRec.ReadIsolation stellt je Record-Variable ein, wie gelesen wird, statt per LockTable die ganze Tabelle zu betreffen.
Nummernserien und EinrichtungssätzeKlassische Engstellen: Wer die Nummernserienzeile ändert, sperrt sie für alle. So spät wie möglich in der Transaktion ziehen.
// Nur zählen oder anzeigen: nicht auf fremde Schreibsperren warten
Visit.ReadIsolation := IsolationLevel::ReadUncommitted;
VisitCount := Visit.Count();

// Lesen mit Änderungsabsicht: nur diese Sätze sperren
Visit.ReadIsolation := IsolationLevel::UpdLock;
Visit.SetRange("Customer No.", CustomerNo);
if Visit.FindSet() then ...
WertBedeutung
DefaultVerhalten der Plattform je nach Transaktionszustand
ReadUncommittedLiest auch noch nicht festgeschriebene Daten anderer, wartet nie. Für Anzeigen und Schätzungen.
ReadCommittedLiest nur Festgeschriebenes, hält keine Sperren
RepeatableReadGelesene Sätze bleiben bis zum Transaktionsende für andere unveränderbar
UpdLockGelesene Sätze werden zum Ändern reserviert, wie früher nach LockTable

Profiler

Miss, bevor du optimierst. Zwei Werkzeuge zeigen dir, wo die Zeit bleibt.

WerkzeugVorgehenErgebnis
Leistungsprofiler im ClientSeite „Leistungsprofiler“ öffnen, Aufzeichnung starten, Ablauf ausführen, stoppenZeit je App und je Prozedur; die Datei lässt sich herunterladen und in VS Code öffnen. Auch der Kunde kann das selbst tun und dir die Datei schicken.
AL-Profiler in VS CodeSnapshot-Konfiguration mit "executionContext": "Profile", F7 / Alt+F7, dann AL: Generate profile file.alcpuprofile-Datei mit Aufrufbaum, Eigenzeit und Gesamtzeit je Prozedur, Sprung in den Quelltext

Lies das Ergebnis von oben: Welche App verbraucht den größten Anteil, welche Prozedur darin, wie oft wurde sie aufgerufen? Eine Prozedur mit zehntausend Aufrufen und wenig Eigenzeit deutet auf eine Schleife hin, die es nicht geben sollte. Ergänzend zeigt dir die Datenbankstatistik im Debugger (Abschnitt 15), wie viele SQL-Anweisungen ein Ablauf erzeugt. Zähle sie vor und nach deiner Änderung.

19Telemetrie

Telemetrie ist der Ersatz für die Ereignisanzeige des Servers, nur viel reicher. Business Central sendet technische Ereignisse an eine Azure-Application-Insights-Ressource, die du auswertest.

EbeneEinrichtungWer sieht was?
UmgebungIm Admin Center an der Umgebung die Verbindungszeichenfolge eintragenKunde oder betreuender Partner: alles, was in dieser Umgebung passiert, über alle Apps
AppIn app.json: "applicationInsightsConnectionString": "InstrumentationKey=...;IngestionEndpoint=..."Der Herausgeber: alles, was seine App betrifft, über alle Kunden hinweg

Was von selbst ankommt

SignalNutzen
Lang laufende SQL-AbfragenMit SQL-Text und AL-Aufrufliste: Du siehst, welche Zeile deines Codes die Abfrage ausgelöst hat
Lang laufende AL-MethodenKandidaten für die Optimierung
Sperrzeitüberschreitungen und DeadlocksWer hat gewartet, wer hat gesperrt
FehlerdialogeWelche Fehlermeldungen sehen Anwender wie oft
Lebenszyklus von ErweiterungenInstallation, Upgrade und deren Fehlschläge (Seite 8)
Webdienst- und API-AufrufeDauer, Statuscode, Endpunkt
Ausgehende HTTP-AufrufeDauer und Ergebnis deiner HttpClient-Aufrufe
AufgabenwarteschlangeStart, Ende, Fehler
BerichteLaufzeit, Zeilenzahl, Layouttyp
BerechtigungsfehlerFehlende Rechte je Objekt

Eigene Signale senden

local procedure LogVisitCreated(Visit: Record "ABC Customer Visit")
var
    Dimensions: Dictionary of [Text, Text];
begin
    Dimensions.Add('VisitType', Format(Visit."Visit Type"));

    Session.LogMessage(
        'ABC0001',                              // eigene, eindeutige Ereignis-ID
        'Customer visit created',               // fester Text ohne Kundendaten
        Verbosity::Normal,
        DataClassification::SystemMetadata,
        TelemetryScope::ExtensionPublisher,
        Dimensions);
end;
ParameterErklärung
Ereignis-IDFrei wählbar, mit deinem Präfix. Führe eine Liste im Repository, damit jede ID nur eine Bedeutung hat.
VerbosityCritical, Error, Warning, Normal, Verbose
DataClassificationNur SystemMetadata wird tatsächlich gesendet. Das ist Absicht: keine Kundendaten in die Telemetrie.
TelemetryScopeExtensionPublisher: nur an die Ressource aus app.json. All: zusätzlich an die Ressource der Umgebung.
DimensionenZusätzliche Werte als Text. In Application Insights erscheinen sie mit dem Präfix al, hier also alVisitType.
Keine personenbezogenen oder geschäftlichen Daten senden. Keine Debitorennamen, Beträge, Belegnummern, E-Mail-Adressen. Erlaubt sind technische Angaben: Art des Vorgangs, Anzahl, Dauer, Enum-Werte, Objektnummern.

Die System Application bietet darüber eine bequemere Schicht, die Codeunit „Feature Telemetry“ mit LogUsage, LogUptake und LogError. Damit misst du, ob eine Funktion entdeckt, eingerichtet und benutzt wird.

Auswerten mit KQL

// Wie oft wurden Besuche angelegt, je Tag und Besuchsart?
traces
| where timestamp > ago(30d)
| where customDimensions.eventId == 'ABC0001'
| summarize Anzahl = count() by bin(timestamp, 1d), tostring(customDimensions.alVisitType)

// Die langsamsten SQL-Abfragen aus meiner App in den letzten 7 Tagen
traces
| where timestamp > ago(7d)
| where customDimensions.eventId == 'RT0005'
| where customDimensions.extensionName == 'ABC Kundenapp'
| project timestamp,
          Dauer = customDimensions.executionTime,
          SQL = customDimensions.sqlStatement,
          Aufrufliste = customDimensions.alStackTrace
| order by timestamp desc

Die Abfragen laufen im Azure-Portal unter „Protokolle“ der Application-Insights-Ressource. Microsoft stellt fertige Power-BI-Berichte für Umgebungs- und App-Telemetrie bereit sowie eine Sammlung von Beispielabfragen auf GitHub. Auf Signale lassen sich Warnungen legen, etwa eine E-Mail, wenn ein Upgrade deiner App fehlschlägt.

20Übung: Die Besuchsverwaltung absichern

Schritt 1 – Test-App anlegen

Lege im Repository den Ordner test an, erzeuge darin mit AL: Go! ein Projekt und ersetze app.json durch die Fassung aus Abschnitt 2 (eigene GUID behalten). Lösche die Beispieldatei. Kopiere launch.json aus dem Ordner app und setze "startupObjectId": 130451. Nimm den Ordner in die Workspace-Datei auf:

{
  "folders": [
    { "path": "app" },
    { "path": "test" }
  ]
}

Schritt 2 – Testbibliotheken bereitstellen

Richte die Umgebung nach Abschnitt 3 ein, lade im Ordner test die Symbole und veröffentliche zuerst die Haupt-App.

Schritt 3 – Funktionstests test/src/ABCVisitTests.Codeunit.al

Übernimm codeunit 50150 "ABC Visit Tests" aus Abschnitt 4 und ergänze die Tests aus den Abschnitten 5, 7 und 8 samt der globalen Variablen ExpectedCustomerNo: Code[20]. Veröffentliche die Test-App, öffne das AL Test Tool, rufe die Test-Codeunits ab und führe sie aus.

TestPrüft
InsertVisitUpdatesLastVisitOnCustomerTabellentrigger aus Seite 3
LastVisitInFutureIsRejectedFeldvalidierung aus Seite 2
TopCustomersShowsCustomerWithVisitsQuery und Meldung aus Seite 7, mit Handler
VisitCanBeEnteredOnListPagePage aus Seite 4 über eine Testseite

Schritt 4 – Einen Test scheitern sehen

Kommentiere in der Haupt-App die Zeile aus, die „ABC Letzter Besuch“ am Debitor setzt, veröffentliche und führe die Tests aus. Der erste Test muss rot werden. Sieh dir Meldung und Aufrufliste im Test Tool an, nimm die Änderung zurück und prüfe, dass wieder alles grün ist.

Schritt 5 – Berechtigungstests test/src/ABCVisitPermTests.Codeunit.al

Ergänze in test/app.json die Abhängigkeit auf die App „Permissions Mock“ (ID, Name und Version aus der Erweiterungsverwaltung übernehmen), lade die Symbole neu und übernimm codeunit 50151 aus Abschnitt 10. Entferne danach probeweise in der Haupt-App die Zeile tabledata Customer = m aus dem Satz „ABC Visit - Edit“: Der erste Berechtigungstest muss scheitern.

Schritt 6 – Ruleset schärfen

Ersetze den Inhalt von app/abc.ruleset.json durch das Ruleset aus Abschnitt 14. Baue mit Strg+Umschalt+B und behebe alle Fehler. Für die Test-App legst du ein eigenes, lockereres Ruleset an (ToolTips und Übersetzungsregeln sind dort unnötig).

Schritt 7 – Debugger und SQL-Statistik

Setze in ShowTopCustomers (Codeunit 50111) einen Haltepunkt auf VisitsPerCustomer.Open() und einen auf Message. Starte mit F5, löse die Aktion „Top Customers“ aus und notiere aus der Datenbankstatistik die Zahl der SQL-Anweisungen zwischen den beiden Haltepunkten. Schreibe zum Vergleich in der Test-App eine Prozedur, die dasselbe mit zwei verschachtelten Schleifen über Debitoren und Besuche ermittelt, und vergleiche die Zahl.

Schritt 8 – SetLoadFields einsetzen

Im Verarbeitungsbericht report 50101 "ABC Update Last Visit" (Seite 7) wird je Debitor der letzte Besuch gelesen, gebraucht wird nur das Datum:

Visit.SetLoadFields("Visit Date");
Visit.SetRange("Customer No.", Customer."No.");
Visit.SetCurrentKey("Customer No.", "Visit Date");
if not Visit.FindLast() then
    CurrReport.Skip();

Prüfe im Debugger an den letzten SQL-Anweisungen, dass die Abfrage auf die Besuchstabelle jetzt nur noch wenige Spalten nennt.

Schritt 9 – Telemetrie

Lege in Azure eine Application-Insights-Ressource an (kostenloses Kontingent genügt) und trage ihre Verbindungszeichenfolge in app/app.json ein. Ergänze LogVisitCreated aus Abschnitt 19 in codeunit 50105 "ABC Visit Subscribers" und rufe sie aus einem Subscriber auf OnAfterInsertEvent der Besuchstabelle auf (zuerst if Rec.IsTemporary() then exit;). Lege einige Besuche an, warte einige Minuten und führe die erste KQL-Abfrage aus Abschnitt 19 aus.

Die Verbindungszeichenfolge ist kein Geheimnis im engeren Sinn, sie erlaubt nur das Senden. Trotzdem gehört in ein öffentliches Repository keine echte. Für diese Übung reicht ein privates Repository; auf Seite 10 siehst du, wie die Pipeline solche Werte beim Bauen einsetzt.

Schritt 10 – Einchecken

git add .
git commit -m "Test-App, Berechtigungstests, Ruleset, SetLoadFields, Telemetrie"
git push

21Typische Fallen

FalleWas passiertAbhilfe
Tests in der Haupt-AppTestcode und Abhängigkeit zu Testbibliotheken landen beim Kunden; Installation scheitert in ProduktionEigene Test-App
Test verlässt sich auf CRONUS-DatenLäuft lokal, scheitert in der Pipeline oder in der nächsten VersionDaten im Test selbst erzeugen
asserterror ohne Prüfung des FehlersTest besteht auch bei falschem FehlerImmer Assert.ExpectedError oder ExpectedErrorCode
Dialog ohne Handler„Unhandled UI“Passenden Handler ergänzen und in HandlerFunctions nennen
Handler genannt, aber nicht ausgelöstTest scheitert am EndeRichtig so: Der erwartete Dialog fehlt. Code oder Test korrigieren
Erwarteter und tatsächlicher Wert vertauschtIrreführende FehlermeldungErst erwartet, dann tatsächlich
Tests hängen voneinander abEinzeln rot, zusammen grün (oder umgekehrt)Jeder Test legt seine Voraussetzungen selbst an
internal-Prozedur aus der Test-App aufgerufenCompilerfehlerinternalsVisibleTo in der Haupt-App
Nur als SUPER getestetBerechtigungsfehler erst beim KundenTests mit Permissions Mock
Warnungen ignoriertWichtige neue Warnung geht unter; veraltete Elemente fallen erst beim Update aufWarnungen auf null, wichtige Regeln als Fehler
Pragma ohne restoreRegel bleibt für den Rest der Datei ausImmer paarweise, mit Begründung
Debugger in gemeinsamer Sandbox angehaltenKollegen warten auf deine SperrenEigener Container oder eigene Sandbox
SetLoadFields und dann doch andere Felder gelesenZusätzliche Abfrage je Datensatz, langsamer als vorherAlle gebrauchten Felder nennen; im Debugger die SQL-Zahl prüfen
FindFirst in einer Schleife mit NextJeder Next wird eine eigene AbfrageFindSet
Count für die Frage „gibt es etwas?“Zählt alle SätzeIsEmpty
LockTable am Anfang einer langen RoutineAlle anderen Benutzer wartenSpät sperren, ReadIsolation gezielt setzen
Optimiert ohne zu messenAufwand an der falschen StelleProfiler und SQL-Statistik vorher und nachher
Kundendaten in der TelemetrieDatenschutzverstoßNur technische Angaben, SystemMetadata
Telemetrie eingerichtet, nie angesehenProbleme bleiben unbemerkt bis zur BeschwerdeWarnungen auf Upgrade-Fehler und lange Abfragen, regelmäßiger Blick in den Bericht

22Selbsttest und Zusammenfassung

Selbsttest

  1. Warum liegen Tests in einer eigenen App, und wie erreicht die Test-App internal-Prozeduren der Haupt-App?
  2. Was macht asserterror, und warum brauchst du danach immer eine weitere Prüfung?
  3. Dein Test scheitert mit „Unhandled UI: Confirm“. Was fehlt?
  4. Wann nimmst du eine Testseite statt eines direkten Zugriffs auf Records?
  5. Wie prüfst du automatisiert, dass ein Benutzer mit deinem Edit-Satz einen Besuch anlegen kann?
  6. Was bewirkt "action": "Error" im Ruleset, und wann nimmst du ein Pragma?
  7. Du sollst einen Fehler untersuchen, der nur in der Produktion bei einer bestimmten Anwenderin auftritt. Wie gehst du vor?
  8. Was tut SetLoadFields, und wann macht es den Code langsamer?
  9. Welche Methode nimmst du für „gibt es einen Satz?“, „lies den letzten Satz“, „durchlaufe alle Sätze“?
  10. Was darf in ein eigenes Telemetriesignal, was nicht?
Lösungen anzeigen
  1. Damit Testcode und Testbibliotheken nicht beim Kunden landen. Zugriff auf Internes gibt die Haupt-App über internalsVisibleTo in ihrer app.json.
  2. Die folgende Anweisung muss einen Fehler auslösen, sonst scheitert der Test. Da jeder beliebige Fehler genügt, prüfst du mit Assert.ExpectedError oder ExpectedErrorCode, dass es der richtige war.
  3. Eine Prozedur mit [ConfirmHandler], die die Rückfrage beantwortet, und ihr Name im Attribut [HandlerFunctions('...')] am Test.
  4. Wenn die zu prüfende Logik auf der Page liegt: Sichtbarkeit, Editierbarkeit, Aktionen, Page-Trigger, Zusammenspiel von Kopf und Zeilen. Reine Geschäftslogik testest du über Records und Codeunits.
  5. Im Test mit der Codeunit „Permissions Mock“ die wirksamen Sätze auf einen Standardsatz plus den Edit-Satz setzen, den Besuch anlegen und das Ergebnis prüfen; danach die Zuweisung zurücksetzen.
  6. Die Regel lässt den Build scheitern. Ein Pragma nimmst du, um eine einzelne, begründete Stelle auszunehmen, ohne die Regel insgesamt abzuschalten.
  7. Snapshot-Debugging: Quellcode der ausgelieferten Version auschecken, Snappoints setzen, Aufzeichnung für die Benutzerin starten, Ablauf ausführen lassen, Aufzeichnung beenden und in VS Code durchgehen. Ergänzend die Aufrufliste des letzten Fehlers und die Telemetrie.
  8. Es beschränkt das Laden auf die genannten Felder. Langsamer wird es, wenn du danach doch auf nicht geladene Felder zugreifst: Dann lädt die Plattform je Datensatz nach.
  9. IsEmpty; FindLast; FindSet mit Next.
  10. Erlaubt sind technische Angaben wie Vorgangsart, Anzahl, Dauer, Enum-Werte. Nicht erlaubt sind personenbezogene und geschäftliche Daten wie Namen, Beträge, Belegnummern.

Zusammenfassung

Qualität ist in Business Central kein Abschluss am Projektende, sondern läuft mit: Eine Test-App neben der Haupt-App prüft Logik, Oberfläche und Berechtigungen automatisch, und zwar auch gegen die nächste Plattformversion. Die Analyzer mit einem gemeinsamen Ruleset halten den Code einheitlich und fangen veraltete Elemente früh ab. Der Debugger in VS Code zeigt neben Variablen auch die SQL-Anweisungen, der Snapshot-Debugger macht Fehlersuche in der Produktion möglich. Leistung entsteht durch den richtigen Datenzugriff: passende Find-Methode, Teilsätze, Queries, kurze Transaktionen. Und die Telemetrie zeigt dir, was beim Kunden wirklich passiert, bevor er anruft.

Weiter mit Seite 10: Arbeiten mit Git-Branches und Pull Requests, AL-Go für GitHub mit Build- und Testpipeline, Versionierung und Auslieferung in den Tenant, Claude Code im Repository mit CLAUDE.md und AL-Werkzeugen, Umwandlung von altem C/AL-Code mit Txt2AL und der Weg der NAV-2017-Daten in die Cloud.

Testautomatisierung im Team einführen?Wir begleiten das im AL-Coaching.

Erstgespräch vereinbaren

Fehler gefunden? Bitte melden. Wir prüfen jede Meldung.