Tests: Add UnitTests folder

Tests/UnitTests/DocumentTests/CreditNoteTest.cs

@@ -0,0 +1,44 @@
+using Elwig.Documents;
+using Elwig.Helpers;
+using Elwig.Models.Dtos;
+using Microsoft.EntityFrameworkCore;
+
+namespace Tests.UnitTests.DocumentTests {
+    [TestFixture]
+    public class CreditNoteTest {
+
+        [Test]
+        public async Task Test_01_VirtualCreditNote() {
+            using var ctx = new AppDbContext();
+            var m = await ctx.Members.FindAsync(101);
+            var p = await ctx.MemberPayments.Where(p => p.Year == 2020 && p.AvNr == 1).SingleAsync();
+            var data = await CreditNoteDeliveryData.ForPaymentVariant(ctx.CreditNoteDeliveryRows, ctx.PaymentVariants, 2020, 1);
+            using var doc = new CreditNote(ctx, p, data[m!.MgNr], false, false, false, false,
+                ctx.GetMemberUnderDelivery(2020, m!.MgNr).GetAwaiter().GetResult());
+            var text = await Utils.GeneratePdfText(doc);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("""
+                    MUSTERMANN Max
+                    Winzerstraße 1
+                    2223 Hohenruppersdorf
+                    """));
+                Assert.That(text, Contains.Substring("0123463"));  // Betriebsnummer
+                Assert.That(text, Contains.Substring("pauschaliert"));
+                Assert.That(text, Contains.Substring($"Wolkersdorf, am {Elwig.Helpers.Utils.Today:dd.MM.yyyy}"));
+                Assert.That(text, Contains.Substring("Traubengutschrift Max Mustermann – Probevariante"));
+                Assert.That(text, Contains.Substring("AT81 1234 5678 9012 3457"));
+                Assert.That(text, Contains.Substring("""
+                    20201001X001 1 Grüner Veltliner 73 15,0 ungeb.: 3 219 0,5000 - - 1 609,50
+                    20201001X003 1 Grüner Veltliner abgew. 75 15,4 ungeb.: 2 561 - -
+                    20201001X003 2 Grüner Veltliner Kabinett / abgew.
+                    87 17,6 ungeb.: 3 129 - -
+                    20201001X003 3 Grüner Veltliner abgew. 79 16,1 ungeb.: 1 280 - -
+                    20201001X005 1 Welschriesling 84 17,0 ungeb.: 3 192 - -
+                    20201001X005 2 Welschriesling 84 17,1 ungeb.: 2 190 - -
+                    """));
+                Assert.That(text, Contains.Substring("Gesamtbetrag: € 1 000,00"));
+                Assert.That(text, Contains.Substring("Auszahlungsbetrag: € 1 000,00"));
+            });
+        }
+    }
+}

Tests/UnitTests/DocumentTests/DeliveryAncmtListTest.cs

@@ -0,0 +1,30 @@
+using Elwig.Documents;
+using Elwig.Helpers;
+using Elwig.Models.Dtos;
+
+namespace Tests.UnitTests.DocumentTests {
+    [TestFixture]
+    public class DeliveryAncmtListTest {
+
+        [Test]
+        public async Task Test_01_AllAnnouncements2020() {
+            using var ctx = new AppDbContext();
+            var filter = "01.10.2020 – Matzen – GV Kabinettaktion";
+            var data = await DeliveryAncmtListData.FromQuery(ctx.DeliveryAnnouncements.Where(a => a.Year == 2020 && a.DsNr == 1), [filter]);
+            using var doc = new DeliveryAncmtList(filter, data);
+            var text = await Utils.GeneratePdfText(doc, true);
+            var table = Utils.ExtractTable(text);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("Anmeldeliste"));
+                Assert.That(text, Contains.Substring("01.10.2020 – Matzen – GV Kabinettaktion"));
+                Assert.That(table, Is.EqualTo(new string[][] {
+                    ["01.10.2020", "101 MUSTERMANN Max",       "Hohenruppersdorf", "Grüner Veltliner", "-",  "5 000"],
+                    ["01.10.2020", "102 WEINBAUER Wernhardt",  "Hohenruppersdorf", "Grüner Veltliner", "-", "10 000"],
+                    ["01.10.2020", "103 MUSTERBAUER Matthäus", "Wolkersdorf",      "Grüner Veltliner", "-",  "8 000"],
+                    ["01.10.2020", "104 WINZER Waltraud",      "Wolkersdorf",      "Grüner Veltliner", "-",  "2 000"],
+                    ["Gesamt:",        "Anmeldungen: 4",                                                    "25 000"],
+                }));
+            });
+        }
+    }
+}

Tests/UnitTests/DocumentTests/DeliveryConfirmationTest.cs

@@ -0,0 +1,44 @@
+using Elwig.Documents;
+using Elwig.Helpers;
+using Elwig.Models.Dtos;
+
+namespace Tests.UnitTests.DocumentTests {
+    [TestFixture]
+    public class DeliveryConfirmationTest {
+
+        [Test]
+        public async Task Test_01_SimpleDeliveryConfirmation() {
+            using var ctx = new AppDbContext();
+            var m = await ctx.Members.FindAsync(101);
+            var data = await DeliveryConfirmationDeliveryData.ForMember(ctx.DeliveryParts, 2020, m!);
+            using var doc = new DeliveryConfirmation(ctx, 2020, m!, data);
+            var text = await Utils.GeneratePdfText(doc);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("""
+                    MUSTERMANN Max
+                    Winzerstraße 1
+                    2223 Hohenruppersdorf
+                    """));
+                Assert.That(text, Contains.Substring("0123463"));  // Betriebsnummer
+                Assert.That(text, Contains.Substring("pauschaliert"));
+                Assert.That(text, Contains.Substring($"Wolkersdorf, am {Elwig.Helpers.Utils.Today:dd.MM.yyyy}"));
+                Assert.That(text, Contains.Substring("Anlieferungsbestätigung 2020"));
+                Assert.That(text, Contains.Substring("""
+                    20201001X001 1 Grüner Veltliner Qualitätswein 73 15,0 ungeb.: 3 219 3 219 ☑
+                    20201001X003 2 Grüner Veltliner Kabinett Wein 87 17,6 ungeb.: 3 129 3 129 ☑
+                    20201001X003 3 Grüner Veltliner Wein 79 16,1 ungeb.: 1 280 1 280 ☑
+                    20201001X003 1 Grüner Veltliner Wein 75 15,4 ungeb.: 2 561 2 561 ☑
+                    20201001X005 2 Welschriesling Kabinett 84 17,1 ungeb.: 2 190 2 190 ☑
+                    20201001X005 1 Welschriesling Kabinett 84 17,0 ungeb.: 3 192 3 192 ☑
+                    """));
+                Assert.That(text, Contains.Substring("Gesamt: 15 571"));
+                Assert.That(text, Contains.Substring("""
+                    Sortenaufteilung [kg] ohne Attr./Bewirt. Kabinett Gesamt
+                    Grüner Veltliner 7 060 3 129 10 189
+                    Welschriesling 5 382 - 5 382
+                    12 442 3 129 15 571
+                    """));
+            });
+        }
+    }
+}

Tests/UnitTests/DocumentTests/DeliveryDepreciationListTest.cs

@@ -0,0 +1,32 @@
+using Elwig.Documents;
+using Elwig.Helpers;
+using Elwig.Models.Dtos;
+
+namespace Tests.UnitTests.DocumentTests {
+    [TestFixture]
+    public class DeliveryDepreciationListTest {
+
+        [Test]
+        public async Task Test_01_DepreciatedDeliveries2020() {
+            using var ctx = new AppDbContext();
+            var data = await DeliveryJournalData.FromQuery(ctx.Deliveries.Where(d => d.Year == 2020).SelectMany(d => d.Parts).Where(d => d.QualId == "WEI"), ["Saison 2020"]);
+            using var doc = new DeliveryDepreciationList("Saison 2020", data);
+            var text = await Utils.GeneratePdfText(doc, true);
+            var table = Utils.ExtractTable(text);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("Abwertungsliste"));
+                Assert.That(text, Contains.Substring("Saison 2020"));
+                Assert.That(table, Is.EqualTo(new string[][] {
+                    ["101, MUSTERMANN Max",             "Teil-Lfrg.:", "3",             "81", "16,5",  "6 970"],
+                    ["20201001X003 1 01.10.2020 10:24", "Grüner Veltliner",             "75", "15,4",  "2 561"],
+                    ["20201001X003 2 01.10.2020 10:24", "Grüner Veltliner", "Kabinett", "87", "17,6",  "3 129"],
+                    ["20201001X003 3 01.10.2020 10:24", "Grüner Veltliner",             "79", "16,1",  "1 280"],
+                    ["103, MUSTERBAUER Matthäus",       "Teil-Lfrg.:", "2",             "79", "16,2",  "6 099"],
+                    ["20201002X001 1 02.10.2020 09:13", "Grüner Veltliner", "Bio",      "80", "16,3",  "3 198"],
+                    ["20201002X002 1 02.10.2020 09:28", "Grüner Veltliner", "Bio",      "78", "16,0",  "2 901"],
+                    ["Gesamt:",      "(Teil-)Lieferungen: 3 (5)",                       "80", "16,3", "13 069"],
+                }));
+            });
+        }
+    }
+}

Tests/UnitTests/DocumentTests/DeliveryJournalTest.cs

@@ -0,0 +1,48 @@
+using Elwig.Documents;
+using Elwig.Helpers;
+using Elwig.Models.Dtos;
+
+namespace Tests.UnitTests.DocumentTests {
+    [TestFixture]
+    public class DeliveryJournalTest {
+
+        [Test]
+        public async Task Test_01_AllDeliveries2020() {
+            using var ctx = new AppDbContext();
+            var data = await DeliveryJournalData.FromQuery(ctx.Deliveries.Where(d => d.Year == 2020).SelectMany(d => d.Parts), ["Saison 2020"]);
+            using var doc = new DeliveryJournal("Saison 2020", data);
+            var text = await Utils.GeneratePdfText(doc, true);
+            var table = Utils.ExtractTable(text);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("Lieferjournal"));
+                Assert.That(text, Contains.Substring("Saison 2020"));
+                Assert.That(table, Is.EqualTo(new string[][] {
+                    ["20201001X001", "1", "01.10.2020 09:03", "101 MUSTERMANN Max",       "Grüner Veltliner",   "73", "15,0",  "3 219"],
+                    ["20201001X002", "1", "01.10.2020 09:35", "102 WEINBAUER Wernhardt",  "Grüner Veltliner",   "86", "17,5",  "2 987"],
+                    ["20201001X002", "2", "01.10.2020 09:35", "102 WEINBAUER Wernhardt",  "Grüner Veltliner",   "87", "17,7",  "1 873"],
+                    ["20201001X003", "1", "01.10.2020 10:24", "101 MUSTERMANN Max",       "Grüner Veltliner",   "75", "15,4",  "2 561"],
+                    ["20201001X003", "2", "01.10.2020 10:24", "101 MUSTERMANN Max",       "Grüner Veltliner",   "87", "17,6",  "3 129"],
+                    ["20201001X003", "3", "01.10.2020 10:24", "101 MUSTERMANN Max",       "Grüner Veltliner",   "79", "16,1",  "1 280"],
+                    ["20201001X004", "1", "01.10.2020 11:13", "102 WEINBAUER Wernhardt",  "Grüner Veltliner",   "82", "16,7",  "4 002"],
+                    ["20201001X004", "2", "01.10.2020 11:13", "102 WEINBAUER Wernhardt",  "Grüner Veltliner",   "75", "15,3",    "481"],
+                    ["20201001X005", "1", "01.10.2020 12:45", "101 MUSTERMANN Max",       "Welschriesling",     "84", "17,0",  "3 192"],
+                    ["20201001X005", "2", "01.10.2020 12:45", "101 MUSTERMANN Max",       "Welschriesling",     "84", "17,1",  "2 190"],
+                    ["20201001X006", "1", "01.10.2020 13:18", "102 WEINBAUER Wernhardt",  "Grüner Veltliner",   "74", "15,2",  "1 732"],
+                    ["20201002X001", "1", "02.10.2020 09:13", "103 MUSTERBAUER Matthäus", "Grüner Veltliner",   "80", "16,3",  "3 198"],
+                    ["20201002X001", "2", "02.10.2020 09:13", "103 MUSTERBAUER Matthäus", "Grüner Veltliner",   "75", "15,4",  "2 134"],
+                    ["20201002X002", "1", "02.10.2020 09:28", "103 MUSTERBAUER Matthäus", "Grüner Veltliner",   "78", "16,0",  "2 901"],
+                    ["20201002X002", "2", "02.10.2020 09:28", "103 MUSTERBAUER Matthäus", "Grüner Veltliner",   "85", "17,3",  "3 321"],
+                    ["20201002X003", "1", "02.10.2020 10:11", "103 MUSTERBAUER Matthäus", "Welschriesling",     "85", "17,2",  "3 998"],
+                    ["20201003X001", "1", "03.10.2020 14:13", "104 WINZER Waltraud",      "Zweigelt",           "73", "15,0",  "1 212"],
+                    ["20201003X001", "2", "03.10.2020 14:13", "104 WINZER Waltraud",      "Zweigelt",           "74", "15,2",  "2 471"],
+                    ["20201003X001", "3", "03.10.2020 14:13", "104 WINZER Waltraud",      "Zweigelt",           "77", "15,7",    "842"],
+                    ["20201003X002", "1", "03.10.2020 14:39", "104 WINZER Waltraud",      "Zweigelt",           "84", "17,0",  "3 578"],
+                    ["20201003X002", "2", "03.10.2020 14:39", "104 WINZER Waltraud",      "Zweigelt",           "85", "17,2",  "3 862"],
+                    ["20201003X003", "1", "03.10.2020 15:15", "104 WINZER Waltraud",      "Blauer Portugieser", "89", "18,0",  "2 410"],
+                    ["20201003X003", "2", "03.10.2020 15:15", "104 WINZER Waltraud",      "Blauer Portugieser", "89", "18,1",  "2 313"],
+                    ["Gesamt:",           "(Teil-)Lieferungen: 12 (23)",                                        "82", "16,6", "58 886"],
+                }));
+            });
+        }
+    }
+}

Tests/UnitTests/DocumentTests/DeliveryNoteTest.cs

@@ -0,0 +1,143 @@
+using Elwig.Documents;
+using Elwig.Helpers;
+
+namespace Tests.UnitTests.DocumentTests {
+    [TestFixture]
+    public class DeliveryNoteTest {
+
+        [Test]
+        public async Task Test_01_OneDeliveryPart() {
+            using var ctx = new AppDbContext();
+            var d = await ctx.Deliveries.FindAsync(2020, 1);
+            using var doc = new DeliveryNote(d!, ctx);
+            var text = await Utils.GeneratePdfText(doc);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("""
+                    MUSTERMANN Max
+                    Winzerstraße 1
+                    2223 Hohenruppersdorf
+                    """));
+                Assert.That(text, Contains.Substring("0123463"));  // Betriebsnummer
+                Assert.That(text, Contains.Substring("pauschaliert"));
+                Assert.That(text, Contains.Substring($"Wolkersdorf, am {Elwig.Helpers.Utils.Today:dd.MM.yyyy}"));
+                Assert.That(text, Contains.Substring("Traubenübernahmeschein Nr. 20201001X001"));
+                Assert.That(text, Contains.Substring("Das Mitglied erklärt, dass die gelieferte Ware dem österreichischen Weingesetz entspricht"));
+                Assert.That(text, Contains.Substring("""
+                    1 Grüner Veltliner Qualitätswein 73 15,0 3 219
+                    Herkunft: Österreich / Weinland / Niederösterreich
+                    / Matzner Hügel / Hohenruppersdorf / KG Hohenruppersdorf
+                    Waage: 1, ID: 321 – 09:02, 01.10.2020
+                    Brutto: 3 219 kg – Tara: 0 kg – Netto: 3 219 kg – gerebelt gewogen
+                    """));
+            });
+        }
+
+        [Test]
+        public async Task Test_02_TwoDeliveryParts() {
+            using var ctx = new AppDbContext();
+            var d = await ctx.Deliveries.FindAsync(2020, 4);
+            using var doc = new DeliveryNote(d!, ctx);
+            var text = await Utils.GeneratePdfText(doc);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("""
+                    W&B Weinbauer GesbR
+                    WEINBAUER Wernhardt
+                    Winzerstraße 2
+                    2223 Hohenruppersdorf
+                    """));
+                Assert.That(text, Contains.Substring("0123471"));  // Betriebsnummer
+                Assert.That(text, Contains.Substring("pauschaliert"));
+                Assert.That(text, Contains.Substring($"Wolkersdorf, am {Elwig.Helpers.Utils.Today:dd.MM.yyyy}"));
+                Assert.That(text, Contains.Substring("Traubenübernahmeschein Nr. 20201001X004"));
+                Assert.That(text, Contains.Substring("Das Mitglied erklärt, dass die gelieferte Ware dem österreichischen Weingesetz entspricht"));
+                Assert.That(text, Contains.Substring("""
+                    1 Grüner Veltliner Qualitätswein 82 16,7 4 002
+                    Herkunft: Österreich / Weinland / Niederösterreich
+                    / Matzner Hügel / Hohenruppersdorf / KG Hohenruppersdorf
+                    Waage: ?, ID: ? (gerebelt gewogen)
+                    """));
+                Assert.That(text, Contains.Substring("""
+                    2 Grüner Veltliner Qualitätswein 75 15,3 481
+                    Herkunft: Österreich / Weinland / Niederösterreich
+                    / Matzner Hügel / Hohenruppersdorf / KG Hohenruppersdorf
+                    Waage: ?, ID: ? (gerebelt gewogen)
+                    """));
+                Assert.That(text, Contains.Substring("Gesamt: 81 16,5 4 483"));
+            });
+        }
+
+        [Test]
+        public async Task Test_03_DeliveryPartsWithAttribute() {
+            using var ctx = new AppDbContext();
+            var d = await ctx.Deliveries.FindAsync(2020, 3);
+            using var doc = new DeliveryNote(d!, ctx);
+            var text = await Utils.GeneratePdfText(doc);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("""
+                    MUSTERMANN Max
+                    Winzerstraße 1
+                    2223 Hohenruppersdorf
+                    """));
+                Assert.That(text, Contains.Substring("0123463"));  // Betriebsnummer
+                Assert.That(text, Contains.Substring("pauschaliert"));
+                Assert.That(text, Contains.Substring($"Wolkersdorf, am {Elwig.Helpers.Utils.Today:dd.MM.yyyy}"));
+                Assert.That(text, Contains.Substring("Traubenübernahmeschein Nr. 20201001X003"));
+                Assert.That(text, Contains.Substring("Das Mitglied erklärt, dass die gelieferte Ware dem österreichischen Weingesetz entspricht"));
+                Assert.That(text, Contains.Substring("""
+                    1 Grüner Veltliner Wein 75 15,4 2 561
+                    Herkunft: Österreich
+                    / Matzner Hügel / Hohenruppersdorf / KG Hohenruppersdorf
+                    Waage: ?, ID: ? (gerebelt gewogen)
+                    """));
+                Assert.That(text, Contains.Substring("""
+                    2 Grüner Veltliner Kabinett Wein 87 17,6 3 129
+                    Herkunft: Österreich
+                    / Matzner Hügel / Hohenruppersdorf / KG Hohenruppersdorf
+                    Waage: ?, ID: ? (gerebelt gewogen)
+                    """));
+                Assert.That(text, Contains.Substring("""
+                    3 Grüner Veltliner Wein 79 16,1 1 280
+                    Herkunft: Österreich
+                    / Matzner Hügel / Hohenruppersdorf / KG Hohenruppersdorf
+                    Waage: ?, ID: ? (gerebelt gewogen)
+                    """));
+                Assert.That(text, Contains.Substring("Gesamt: 81 16,5 6 970"));
+            });
+        }
+
+        [Test]
+        public async Task Test_04_DeliveryPartsWithCultivation() {
+            using var ctx = new AppDbContext();
+            var d = await ctx.Deliveries.FindAsync(2020, 7);
+            using var doc = new DeliveryNote(d!, ctx);
+            var text = await Utils.GeneratePdfText(doc);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("""
+                    MUSTERBAUER Matthäus
+                    Brünner Straße 10
+                    2120 Wolkersdorf im Weinviertel
+                    """));
+                Assert.That(text, Contains.Substring("0123480"));  // Betriebsnummer
+                Assert.That(text, Contains.Substring("pauschaliert"));
+                Assert.That(text, Contains.Substring($"Wolkersdorf, am {Elwig.Helpers.Utils.Today:dd.MM.yyyy}"));
+                Assert.That(text, Contains.Substring("Traubenübernahmeschein Nr. 20201002X001"));
+                Assert.That(text, Contains.Substring("Das Mitglied erklärt, dass die gelieferte Ware dem österreichischen Weingesetz entspricht"));
+                Assert.That(text, Contains.Substring("""
+                    1 Grüner Veltliner Wein 80 16,3 3 198
+                    Bewirtschaftung: Bio (AT-BIO-302)
+                    Herkunft: Österreich
+                    / Wolkersdorfer Hochleithen / Wolkersdorf im Weinviertel / KG Wolkersdorf
+                    Waage: ?, ID: ? (gerebelt gewogen)
+                    """));
+                Assert.That(text, Contains.Substring("""
+                    2 Grüner Veltliner Qualitätswein 75 15,4 2 134
+                    Bewirtschaftung: Bio (AT-BIO-302)
+                    Herkunft: Österreich / Weinland / Niederösterreich
+                    / Wolkersdorfer Hochleithen / Wolkersdorf im Weinviertel / KG Wolkersdorf
+                    Waage: ?, ID: ? (gerebelt gewogen)
+                    """));
+                Assert.That(text, Contains.Substring("Gesamt: 78 15,9 5 332"));
+            });
+        }
+    }
+}

Tests/UnitTests/DocumentTests/LetterheadTest.cs

@@ -0,0 +1,24 @@
+using Elwig.Documents;
+using Elwig.Helpers;
+
+namespace Tests.UnitTests.DocumentTests {
+    [TestFixture]
+    public class LetterheadTest {
+
+        [Test]
+        public async Task Test_01_SimpleLetterhead() {
+            using var ctx = new AppDbContext();
+            var m = await ctx.Members.FindAsync(104);
+            using var doc = new Letterhead(m!);
+            var text = await Utils.GeneratePdfText(doc);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("WG Test | Genossenschaftsstraße 1 | 2120 Wolkersdorf"));
+                Assert.That(text, Contains.Substring("""
+                    WINZER Waltraud
+                    Wiener Straße 15
+                    2120 Wolkersdorf im Weinviertel
+                    """));
+            });
+        }
+    }
+}

Tests/UnitTests/DocumentTests/MemberDataSheetTest.cs

@@ -0,0 +1,41 @@
+using Elwig.Documents;
+using Elwig.Helpers;
+
+namespace Tests.UnitTests.DocumentTests {
+    [TestFixture]
+    public class MemberDataSheetTest {
+
+        [Test]
+        public async Task Test_01_SimpleMember() {
+            using var ctx = new AppDbContext();
+            var m = await ctx.Members.FindAsync(104);
+            using var doc = new MemberDataSheet(m!, ctx);
+            var text = await Utils.GeneratePdfText(doc);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("""
+                    WINZER Waltraud
+                    Wiener Straße 15
+                    2120 Wolkersdorf im Weinviertel
+                    """));
+                Assert.That(text, Contains.Substring("Stammdatenblatt WINZER Waltraud"));
+                Assert.That(text, Contains.Substring("""
+                    Titel (vorangestellt) Vorname Nachname Titel (nachgestellt)
+                    Waltraud Winzer
+                    """));
+                Assert.That(text, Contains.Substring("Mitglieds-Nr.: 104"));
+                Assert.That(text, Contains.Substring("Adresse: Wiener Straße 15"));
+                Assert.That(text, Contains.Substring("PLZ/Ort: 2120 Wolkersdorf im Weinviertel (Wolkersdorf im Weinviertel)"));
+                Assert.That(text, Contains.Substring("Adresse: Wiener Straße 15"));
+                Assert.That(text, Contains.Substring("""
+                    Rechnungsadresse (optional)
+                    Name: Weinbau Waltraud Winzer GmbH
+                    Adresse: Hauptstraße 1
+                    PLZ/Ort: 2122 Riedenthal (Riedenthal)
+                    """));
+                Assert.That(text, Contains.Substring("IBAN: AT97 1234 5678 9012 3460"));
+                Assert.That(text, Contains.Substring("Betriebs-Nr.: 0123498"));
+                Assert.That(text, Contains.Substring("Stammgemeinde: Wolkersdorf"));
+            });
+        }
+    }
+}

Tests/UnitTests/DocumentTests/MemberListTest.cs

@@ -0,0 +1,27 @@
+using Elwig.Documents;
+using Elwig.Helpers;
+using Elwig.Models.Dtos;
+
+namespace Tests.UnitTests.DocumentTests {
+    [TestFixture]
+    public class MemberListTest {
+
+        [Test]
+        public async Task Test_01_TwoMembers() {
+            using var ctx = new AppDbContext();
+            var data = await MemberListData.FromQuery(ctx.Members, [], []);
+            using var doc = new MemberList("Alle Mitglieder", data);
+            var text = await Utils.GeneratePdfText(doc, true);
+            var table = Utils.ExtractTable(text);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("Mitgliederliste"));
+                Assert.That(text, Contains.Substring("Alle Mitglieder"));
+                Assert.That(table.Take(3), Is.EqualTo(new string[][] {
+                     ["101 MUSTERMANN Max",      "Winzerstraße 1", "2223", "Hohenruppersdorf", "0123463", "0", "Hohenruppersdorf"],
+                     ["102 WEINBAUER Wernhardt", "Winzerstraße 2", "2223", "Hohenruppersdorf", "0123471", "0", "Hohenruppersdorf"],
+                     [    "W&B Weinbauer GesbR", "Winzerstraße 2", "2223", "Hohenruppersdorf"],
+                }));
+            });
+        }
+    }
+}

Tests/UnitTests/DocumentTests/PaymentVariantSummaryTest.cs

@@ -0,0 +1,29 @@
+using Elwig.Documents;
+using Elwig.Helpers;
+using Elwig.Models.Dtos;
+
+namespace Tests.UnitTests.DocumentTests {
+    [TestFixture]
+    public class PaymentVariantSummaryTest {
+
+        [Test]
+        public async Task Test_01_PaymentVariant2020() {
+            using var ctx = new AppDbContext();
+            var v = (await ctx.PaymentVariants.FindAsync(2020, 1))!;
+            var data = await PaymentVariantSummaryData.ForPaymentVariant(v, ctx.PaymentVariantSummaryRows);
+            using var doc = new PaymentVariantSummary(v, data);
+            var text = await Utils.GeneratePdfText(doc, true);
+            var table = Utils.ExtractTable(text);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("Auszahlungsvariante"));
+                Assert.That(text, Contains.Substring(v.Name));
+                Assert.That(table.Skip(17).ToArray(), Is.EqualTo(new string[][] {
+                     [                   "Gradation",   "ungebunden",   "attributlos gebunden",    "gebunden",     "Gesamt" ],
+                     [                     "[°Oe]",   "[kg]", "[€/kg]",    "[kg]", "[€/kg]",    "[kg]", "[€/kg]",    "[€]"  ],
+                     ["Grüner Veltliner",            "3 219",                 "0",                 "0",           "1 609,50"],
+                     ["Qualitätswein",      "73",    "3 219", "0,5000",       "-",      "-",       "-",      "-", "1 609,50"]
+                }));
+            });
+        }
+    }
+}

Tests/UnitTests/DocumentTests/Setup.cs

@@ -0,0 +1,37 @@
+using Elwig.Helpers;
+using System.Reflection;
+using Microsoft.Data.Sqlite;
+using Elwig.Helpers.Printing;
+
+namespace Tests.UnitTests.DocumentTests {
+    [SetUpFixture]
+    public class Setup {
+
+        private SqliteConnection? Connection;
+
+        [OneTimeSetUp]
+        public async Task SetupDatabase() {
+            Connection = await AppDbContext.ConnectAsync();
+            await AppDbContext.ExecuteEmbeddedScript(Connection, Assembly.GetExecutingAssembly(), "Tests.Resources.Sql.DocumentInsert.sql");
+        }
+
+        [OneTimeTearDown]
+        public async Task TeardownDatabase() {
+            if (Connection == null) return;
+            await AppDbContext.ExecuteEmbeddedScript(Connection, Assembly.GetExecutingAssembly(), "Tests.Resources.Sql.DocumentDelete.sql");
+            await Connection.DisposeAsync();
+            Connection = null;
+        }
+
+        [OneTimeSetUp]
+        public async Task SetupPrinting() {
+            await Html.Init();
+            await Pdf.Init();
+        }
+
+        [OneTimeTearDown]
+        public async Task TeardownPrinting() {
+            await Pdf.Cleanup();
+        }
+    }
+}

Tests/UnitTests/DocumentTests/Utils.cs

@@ -0,0 +1,29 @@
+using Elwig.Documents;
+using NReco.PdfRenderer;
+using System.Text.RegularExpressions;
+
+namespace Tests.UnitTests.DocumentTests {
+    public static class Utils {
+
+        private static readonly string FileName = Path.Combine(Path.GetTempPath(), "test_document.pdf");
+
+        public static async Task<string> GeneratePdfText(Document doc, bool preserveLayout = false) {
+            await doc.Generate();
+            try {
+                doc.SaveTo(FileName);
+                var conv = new PdfToTextConverter { CustomArgs = preserveLayout ? "-layout " : "-raw " };
+                return conv.GenerateText(FileName);
+            } finally {
+                File.Delete(FileName);
+            }
+        }
+
+        public static string[][] ExtractTable(string text) {
+            return text.Split('\n')
+                .Select(row => Regex.Split(row, @"\s{2,}").Select(c => c.Trim()).Where(c => c.Length > 0).ToArray())
+                .Where(row => row.Length >= 3)
+                .Skip(1)
+                .ToArray();
+        }
+    }
+}

Tests/UnitTests/DocumentTests/WineQualityStatisticsTest.cs

@@ -0,0 +1,50 @@
+using Elwig.Documents;
+using Elwig.Helpers;
+using Elwig.Models.Dtos;
+
+namespace Tests.UnitTests.DocumentTests {
+    [TestFixture]
+    public class WineQualityStatisticsTest {
+
+        [Test]
+        public async Task Test_01_AllDeliveries2020() {
+            using var ctx = new AppDbContext();
+            var data = await WineQualityStatisticsData.FromQuery(ctx.Deliveries.Where(d => d.Year == 2020).SelectMany(d => d.Parts));
+            using var doc = new WineQualityStatistics("Saison 2020", data);
+            var text = await Utils.GeneratePdfText(doc);
+            Assert.Multiple(() => {
+                Assert.That(text, Contains.Substring("Qualitätsstatistik"));
+                Assert.That(text, Contains.Substring("Saison 2020"));
+                Assert.That(text, Contains.Substring("""
+                    Wein
+                    75 1 2 561
+                    78 1 2 901
+                    79 1 1 280
+                    80 1 3 198
+                    87 1 3 129
+                    """));
+                Assert.That(text, Contains.Substring("""
+                    Qualitätswein
+                    73 2 4 431
+                    74 2 4 203
+                    75 2 2 615
+                    77 1 842
+                    82 1 4 002
+                    """));
+                Assert.That(text, Contains.Substring("""
+                    Kabinett
+                    84 3 8 960
+                    85 3 11 181
+                    86 1 2 987
+                    87 1 1 873
+                    89 2 4 723
+                    """));
+                Assert.That(text, Contains.Substring(
+                    "80 5 " + "13 069 " +
+                    "- 0 0 " +
+                    "77 5 " + "11 568 " +
+                    "85 6 " + "17 561"));
+            });
+        }
+    }
+}

Tests/UnitTests/HelperTests/BillingTest.cs

@@ -0,0 +1,355 @@
+using Elwig.Helpers;
+using Elwig.Helpers.Billing;
+using Microsoft.Data.Sqlite;
+using System.Reflection;
+
+namespace Tests.UnitTests.HelperTests {
+    [TestFixture]
+    public class BillingTest {
+
+        private const int Year1 = 2020, Year2 = 2021;
+        private const int MgNr1 = 101, MgNr2 = 102, MgNr3 = 103, MgNr4 = 104;
+
+        private const decimal
+            GV_ungeb  = 0.50m,
+            GV_geb    = 0.60m,
+            GVB_ungeb = 0.54m,
+            GVB_geb   = 0.64m,
+            GVK_ungeb = 0.61m,
+            GVK_geb   = 0.71m,
+            WEI       = 0.10m;
+
+        private SqliteConnection? Connection;
+
+        [OneTimeSetUp]
+        public async Task SetupDatabase() {
+            Connection = await AppDbContext.ConnectAsync();
+            await AppDbContext.ExecuteEmbeddedScript(Connection, Assembly.GetExecutingAssembly(), "Tests.Resources.Sql.BillingInsert.sql");
+        }
+
+        [OneTimeTearDown]
+        public async Task TeardownDatabase() {
+            if (Connection == null) return;
+            await AppDbContext.ExecuteEmbeddedScript(Connection, Assembly.GetExecutingAssembly(), "Tests.Resources.Sql.BillingDelete.sql");
+            await Connection.DisposeAsync();
+            Connection = null;
+        }
+
+        [SetUp]
+        public async Task CreatePaymentVariant() {
+            var json = """
+                {
+                  "mode": "elwig",
+                  "version": 1,
+                  "payment": {
+                    "GV": "curve:0",
+                    "GV-B": "curve:1",
+                    "GV/K": "curve:2"
+                  },
+                  "quality": {"WEI": 0.1},
+                  "curves": [{
+                    "id": 0,
+                    "mode": "oe",
+                    "data": {"15kmw": 0.5},
+                    "geb": 0.1
+                  }, {
+                    "id": 1,
+                    "mode": "oe",
+                    "data": {"15kmw": 0.54},
+                    "geb": 0.1
+                  }, {
+                    "id": 2,
+                    "mode": "oe",
+                    "data": {"15kmw": 0.61},
+                    "geb": 0.1
+                  }]
+                }
+                """;
+            await InsertPaymentVariant(Year1, 1, json);
+            await InsertPaymentVariant(Year2, 1, json);
+        }
+
+        [TearDown]
+        public async Task CleanupDatabasePayment() {
+            if (Connection == null) return;
+            await AppDbContext.ExecuteBatch(Connection, """
+                DELETE FROM credit;
+                DELETE FROM payment_variant;
+                DELETE FROM delivery_part_bucket;
+                """);
+        }
+
+        private Task<Dictionary<string, AreaComBucket>> GetMemberAreaCommitmentBuckets(int year, int mgnr) {
+            using var ctx = new AppDbContext();
+            return ctx.GetMemberAreaCommitmentBuckets(year, mgnr, Connection);
+        }
+
+        private Task<Dictionary<string, int>> GetMemberDeliveryBuckets(int year, int mgnr) {
+            using var ctx = new AppDbContext();
+            return ctx.GetMemberDeliveryBuckets(year, mgnr, Connection);
+        }
+
+        private Task<Dictionary<string, int>> GetMemberPaymentBuckets(int year, int mgnr) {
+            using var ctx = new AppDbContext();
+            return ctx.GetMemberPaymentBuckets(year, mgnr, Connection);
+        }
+
+        private async Task<Dictionary<(string, string), (int, decimal)>> GetMemberDeliveryPrices(int year, int mgnr) {
+            var buckets = new Dictionary<(string, string), (int, decimal)>();
+            using (var cmd = Connection!.CreateCommand()) {
+                cmd.CommandText = $"""
+                    SELECT lsnr || '/' ||  d.dpnr, d.sortid || b.discr, b.value, p.price
+                    FROM v_delivery d
+                        LEFT JOIN payment_delivery_part_bucket p ON (p.year, p.did, p.dpnr) = (d.year, d.did, d.dpnr)
+                        LEFT JOIN delivery_part_bucket b ON (b.year, b.did, b.dpnr, b.bktnr) = (p.year, p.did, p.dpnr, p.bktnr)
+                    WHERE d.year = {year} AND mgnr = {mgnr}
+                    """;
+                using var reader = await cmd.ExecuteReaderAsync();
+                while (await reader.ReadAsync()) {
+                    var lsnr = reader.GetString(0);
+                    var bucket = reader.GetString(1);
+                    buckets[(lsnr, bucket)] = (reader.GetInt32(2), Utils.DecFromDb(reader.GetInt32(3), 4));
+                }
+            }
+            return buckets;
+        }
+
+        private Task InsertPaymentVariant(int year, int avnr, string data) {
+            return AppDbContext.ExecuteBatch(Connection!, $"""
+                INSERT INTO payment_variant (year, avnr, name, date, transfer_date, test_variant, calc_time, data)
+                VALUES ({year}, {avnr}, 'Test', '2021-01-15', NULL, TRUE, NULL, '{data}');
+                """);
+        }
+
+        [Test]
+        public async Task Test_01_NoActiveAreaComs() {
+            int mgnr = MgNr1, year = Year1;
+
+            var areaCom = await GetMemberAreaCommitmentBuckets(year, mgnr);
+            Assert.That(areaCom, Is.Empty);
+            var delivery = await GetMemberDeliveryBuckets(year, mgnr);
+            Assert.Multiple(() => {
+                Assert.That(delivery, Has.Count.EqualTo(3));
+                Assert.That(delivery["GV"],  Is.EqualTo(16_000));
+                Assert.That(delivery["GV_"], Is.EqualTo( 1_000));
+                Assert.That(delivery["GVK"], Is.EqualTo( 4_000));
+            });
+
+            BillingVariant b = new(year, 1);
+            await b.CalculateBuckets(false, false, false);
+            var payment = await GetMemberPaymentBuckets(year, mgnr);
+            Assert.Multiple(() => {
+                Assert.That(payment, Has.Count.EqualTo(1));
+                Assert.That(payment["GV_"], Is.EqualTo(17_000));
+            });
+
+            await b.Calculate();
+            var prices = await GetMemberDeliveryPrices(year, mgnr);
+            Assert.Multiple(() => {
+                Assert.That(prices, Has.Count.EqualTo(6));
+                // Kabinett
+                Assert.That(prices[("20201001X001/1", "GV_")], Is.EqualTo((4_000, GV_ungeb)));
+                // ohne Attribut
+                Assert.That(prices[("20201001X001/2", "GV_")], Is.EqualTo((4_000, GV_ungeb)));
+                // Bio
+                Assert.That(prices[("20201001X002/1", "GV_")], Is.EqualTo((4_000, GVB_ungeb)));
+                // Bio
+                Assert.That(prices[("20201001X002/2", "GV_")], Is.EqualTo((4_000, GVB_ungeb)));
+                // ohne Attribut
+                Assert.That(prices[("20201001X003/1", "GV_")], Is.EqualTo((  500, WEI)));
+                // ohne Attribut
+                Assert.That(prices[("20201001X003/2", "GV_")], Is.EqualTo((  500, GV_ungeb)));
+            });
+        }
+
+        [Test]
+        public async Task Test_02_SimpleNotStrictAreaComs() {
+            int mgnr = MgNr1, year = Year2;
+
+            var areaCom = await GetMemberAreaCommitmentBuckets(year, mgnr);
+            Assert.Multiple(() => {
+                Assert.That(areaCom, Has.Count.EqualTo(1));
+                Assert.That(areaCom["GV"], Is.EqualTo(new AreaComBucket(10_000, 5_000, 10_000)));
+            });
+            var delivery = await GetMemberDeliveryBuckets(year, mgnr);
+            Assert.Multiple(() => {
+                Assert.That(delivery, Has.Count.EqualTo(3));
+                Assert.That(delivery["GV"],  Is.EqualTo(16_000));
+                Assert.That(delivery["GV_"], Is.EqualTo( 1_000));
+                Assert.That(delivery["GVK"], Is.EqualTo( 4_000));
+            });
+
+            BillingVariant b = new(year, 1);
+            await b.CalculateBuckets(false, false, false, Connection);
+            var payment = await GetMemberPaymentBuckets(year, mgnr);
+            Assert.Multiple(() => {
+                Assert.That(payment, Has.Count.EqualTo(2));
+                Assert.That(payment["GV_"], Is.EqualTo( 7_000));
+                Assert.That(payment["GV"],  Is.EqualTo(10_000));
+            });
+
+            await b.Calculate(false, false, false);
+            var prices = await GetMemberDeliveryPrices(year, mgnr);
+            Assert.Multiple(() => {
+                Assert.That(prices, Has.Count.EqualTo(7));
+                // Kabinett
+                Assert.That(prices[("20211001X001/1", "GV")] , Is.EqualTo((4_000, GV_geb)));
+                // ohne Attribut
+                Assert.That(prices[("20211001X001/2", "GV")],  Is.EqualTo((4_000, GV_geb)));
+                // Bio
+                Assert.That(prices[("20211001X002/1", "GV_")], Is.EqualTo((4_000, GVB_ungeb)));
+                // Bio
+                Assert.That(prices[("20211001X002/2", "GV_")], Is.EqualTo((2_000, GVB_ungeb)));
+                Assert.That(prices[("20211001X002/2", "GV")],  Is.EqualTo((2_000, GVB_geb)));
+                // ohne Attribut
+                Assert.That(prices[("20211001X003/1", "GV_")], Is.EqualTo((  500, WEI)));
+                // ohne Attribut
+                Assert.That(prices[("20211001X003/2", "GV_")], Is.EqualTo((  500, GV_ungeb)));
+            });
+        }
+
+        [Test]
+        public async Task Test_03_SimpleNotStrictAreaComs_HonorGebunden() {
+            int mgnr = MgNr1, year = Year2;
+
+            var areaCom = await GetMemberAreaCommitmentBuckets(year, mgnr);
+            Assert.Multiple(() => {
+                Assert.That(areaCom, Has.Count.EqualTo(1));
+                Assert.That(areaCom["GV"], Is.EqualTo(new AreaComBucket(10_000, 5_000, 10_000)));
+            });
+            var delivery = await GetMemberDeliveryBuckets(year, mgnr);
+            Assert.Multiple(() => {
+                Assert.That(delivery, Has.Count.EqualTo(3));
+                Assert.That(delivery["GV"],  Is.EqualTo(16_000));
+                Assert.That(delivery["GV_"], Is.EqualTo( 1_000));
+                Assert.That(delivery["GVK"], Is.EqualTo( 4_000));
+            });
+
+            BillingVariant b = new(year, 1);
+            await b.CalculateBuckets(true, false, false, Connection);
+            var payment = await GetMemberPaymentBuckets(year, mgnr);
+            Assert.Multiple(() => {
+                Assert.That(payment, Has.Count.EqualTo(2));
+                Assert.That(payment["GV_"], Is.EqualTo(9_000));
+                Assert.That(payment["GV"],  Is.EqualTo(8_000));
+            });
+
+            await b.Calculate(true, false, false);
+            var prices = await GetMemberDeliveryPrices(year, mgnr);
+            Assert.Multiple(() => {
+                Assert.That(prices, Has.Count.EqualTo(6));
+                // Kabinett
+                Assert.That(prices[("20211001X001/1", "GV")],  Is.EqualTo((4_000, GV_geb)));
+                // ohne Attribut
+                Assert.That(prices[("20211001X001/2", "GV_")], Is.EqualTo((4_000, GV_ungeb)));
+                // Bio
+                Assert.That(prices[("20211001X002/1", "GV")],  Is.EqualTo((4_000, GVB_geb)));
+                // Bio
+                Assert.That(prices[("20211001X002/2", "GV_")], Is.EqualTo((4_000, GVB_ungeb)));
+                // ohne Attribut
+                Assert.That(prices[("20211001X003/1", "GV_")], Is.EqualTo((  500, WEI)));
+                // ohne Attribut
+                Assert.That(prices[("20211001X003/2", "GV_")], Is.EqualTo((  500, GV_ungeb)));
+            });
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_04_ComplexNotStrictAreaComs() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_05_ComplexNotStrictAreaComs_HonorGebunden() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_06_StrictAreaComs_NoFillLower_NotAllowed() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_07_StrictAreaComs_NoFillLower_Allowed() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_08_StrictAreaComs_NoFillLower_Allowed_AvoidUnderDeliveries() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_09_StrictAreaComs_FillLowerUntilObligation_NotAllowed() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_10_StrictAreaComs_FillLowerUntilObligation_Allowed() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_11_StrictAreaComs_FillLowerUntilObligation_Allowed_AvoidUnderDeliveries() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_12_StrictAreaComs_FillLowerUntilObligation_NotAllowed() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_13_StrictAreaComs_FillLowerUntilObligation_Allowed() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_14_StrictAreaComs_FillLowerUntilObligation_Allowed_AvoidUnderDeliveries() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_15_StrictAreaComs_FillLowerUntilRight_NotAllowed() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_16_StrictAreaComs_FillLowerUntilRight_Allowed() {
+            // TODO
+            return Task.CompletedTask;
+        }
+
+        [Test]
+        [Ignore("Not implemented yet")]
+        public Task Test_17_StrictAreaComs_FillLowerUntilRight_Allowed_AvoidUnderDeliveries() {
+            // TODO
+            return Task.CompletedTask;
+        }
+    }
+}

Tests/UnitTests/HelperTests/EbicsTest.cs

@@ -0,0 +1,121 @@
+using Elwig.Helpers;
+using Elwig.Helpers.Export;
+using Elwig.Models.Dtos;
+using Elwig.Models.Entities;
+using System.Reflection;
+using System.Xml;
+
+namespace Tests.UnitTests.HelperTests {
+    // see https://www.iso20022.org/iso-20022-message-definitions
+    // and https://www.iso20022.org/catalogue-messages/iso-20022-messages-archive?search=pain
+    [TestFixture]
+    public class EbicsTest {
+
+        public static readonly string FileName = Path.Combine(Path.GetTempPath(), "test_ebics.xml");
+        public static readonly string Iban = "AT123456789012345678";
+
+        private static void ValidateSchema(string xmlPath, int version, string? extra = null) {
+            XmlDocument xml = new();
+            xml.Load(xmlPath);
+            var schema = new XmlTextReader(Assembly.GetExecutingAssembly()
+                .GetManifestResourceStream($"Tests.Resources.Schemas.pain.001.001.{version:00}{extra}.xsd")!);
+            xml.Schemas.Add(null, schema);
+            xml.Validate(null);
+        }
+
+        private static async Task CreateXmlFile(int version, Ebics.AddressMode mode = Ebics.AddressMode.Full) {
+            var v = new PaymentVar() {
+                Year = 2020,
+                AvNr = 1,
+                Name = "Endauszahlung",
+                TransferDate = new DateOnly(2021, 6, 15),
+                Data = "",
+                DateString = "2021-01-31",
+            };
+            using var ctx = new AppDbContext();
+            var members = ctx.Members.ToList();
+            Assert.That(members, Has.Count.GreaterThan(0));
+            using var exporter = new Ebics(v, FileName, version, mode);
+            await exporter.ExportAsync(members.Select(m => new Transaction(m, 1234.56m, "EUR", m.MgNr % 100)));
+        }
+
+        [TearDown]
+        public static void RemoveXmlFile() {
+            File.Delete(FileName);
+        }
+
+        [Test]
+        [Ignore("Version has no need to be supported")]
+        public async Task Test_CustomerCreditTransferInitiationV01() {
+            await CreateXmlFile(1);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 1));
+        }
+
+        [Test]
+        [Ignore("Version has no need to be supported")]
+        public async Task Test_CustomerCreditTransferInitiationV02() {
+            await CreateXmlFile(2);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 2));
+        }
+
+        [Test]
+        public async Task Test_CustomerCreditTransferInitiationV03() {
+            await CreateXmlFile(3);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 3));
+        }
+
+        [Test]
+        public async Task Test_CustomerCreditTransferInitiationV03_AT() {
+            await CreateXmlFile(3, Ebics.AddressMode.Lines);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 3, ".AT"));
+        }
+
+        [Test]
+        public async Task Test_CustomerCreditTransferInitiationV04() {
+            await CreateXmlFile(4);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 4));
+        }
+
+        [Test]
+        public async Task Test_CustomerCreditTransferInitiationV05() {
+            await CreateXmlFile(5);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 5));
+        }
+
+        [Test]
+        public async Task Test_CustomerCreditTransferInitiationV06() {
+            await CreateXmlFile(6);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 6));
+        }
+
+        [Test]
+        public async Task Test_CustomerCreditTransferInitiationV07() {
+            await CreateXmlFile(7);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 7));
+        }
+
+        [Test]
+        public async Task Test_CustomerCreditTransferInitiationV08() {
+            await CreateXmlFile(8);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 8));
+        }
+
+        [Test]
+        public async Task Test_CustomerCreditTransferInitiationV09() {
+            await CreateXmlFile(9);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 9));
+        }
+
+        [Test]
+        public async Task Test_CustomerCreditTransferInitiationV10() {
+            await CreateXmlFile(10);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 10));
+        }
+
+        [Test]
+        public async Task Test_CustomerCreditTransferInitiationV11() {
+            await CreateXmlFile(11);
+            Assert.DoesNotThrow(() => ValidateSchema(FileName, 11));
+        }
+    }
+}

Tests/UnitTests/HelperTests/UtilsTest.cs

@@ -0,0 +1,151 @@
+using Elwig.Helpers;
+
+namespace Tests.UnitTests.HelperTests {
+    [TestFixture]
+    public class UtilsTest {
+
+        private static readonly double[,] Gradation = new double[,] {
+            { 14.0,  68.0 },
+            { 15.0,  73.0 },
+            { 17.1,  84.0 },
+            { 19.0,  94.0 },
+            { 21.0, 105.0 },
+            { 25.0, 127.0 },
+            { 27.1, 139.0 },
+            { 30.0, 156.0 },
+        };
+
+        [Test]
+        public void Test_KmwToOe() {
+            Assert.Multiple(() => {
+                for (int i = 0; i < Gradation.GetLength(0); i++) {
+                    Assert.That(Utils.KmwToOe(Gradation[i, 0]), Is.EqualTo(Gradation[i, 1]));
+                }
+            });
+        }
+
+        [Test]
+        public void Test_OeToKmw() {
+            Assert.Multiple(() => {
+                for (int i = 0; i < Gradation.GetLength(0); i++) {
+                    Assert.That(Utils.OeToKmw(Gradation[i, 1]), Is.EqualTo(Gradation[i, 0]));
+                }
+            });
+        }
+
+        [Test]
+        public void Test_DecFromDb() {
+            Assert.Multiple(() => {
+                Assert.That(Utils.DecFromDb(10670, 3), Is.EqualTo(10.67M));
+                Assert.That(Utils.DecFromDb(-1009999, 4), Is.EqualTo(-100.9999M));
+                Assert.That(Utils.DecFromDb(1, 2), Is.EqualTo(0.01M));
+            });
+        }
+
+        [Test]
+        public void Test_DecToDb() {
+            Assert.Multiple(() => {
+                Assert.That(Utils.DecToDb(219.48M, 2), Is.EqualTo(21948));
+                Assert.That(Utils.DecToDb(-1.2345M, 4), Is.EqualTo(-12345));
+                Assert.That(Utils.DecToDb(99190, 0), Is.EqualTo(99190));
+                Assert.That(Utils.DecToDb(817.9099M, 3), Is.EqualTo(817910));
+                Assert.That(Utils.DecToDb(-5618.944M, 2), Is.EqualTo(-561894));
+            });
+        }
+
+        [Test]
+        public void Test_Modulo() {
+            Assert.Multiple(() => {
+                Assert.That(Utils.Modulo("1", 2), Is.EqualTo(1));
+                Assert.That(Utils.Modulo("12", 11), Is.EqualTo(1));
+                Assert.That(Utils.Modulo("65", 16), Is.EqualTo(1));
+                Assert.That(Utils.Modulo("91746381048364", 10), Is.EqualTo(4));
+                Assert.That(Utils.Modulo("210501700012345678131468", 97), Is.EqualTo(1));
+                Assert.Throws<ArgumentException>(() => Utils.Modulo("", 4));
+                Assert.Throws<ArgumentException>(() => Utils.Modulo("1ab", 5));
+                Assert.Throws<ArgumentException>(() => Utils.Modulo("123", 1));
+                Assert.Throws<ArgumentException>(() => Utils.Modulo("456", 0));
+                Assert.Throws<ArgumentException>(() => Utils.Modulo("789", -1));
+            });
+        }
+
+        [Test]
+        public void Test_SplitAddress() {
+            Assert.Multiple(() => {
+                Assert.That(Utils.SplitAddress("Winzerstraße 1"), Is.EqualTo(("Winzerstraße", "1")));
+                Assert.That(Utils.SplitAddress("Auf dem Feld 12"), Is.EqualTo(("Auf dem Feld", "12")));
+                Assert.That(Utils.SplitAddress("Winzerstraße 5a"), Is.EqualTo(("Winzerstraße", "5a")));
+                Assert.That(Utils.SplitAddress("Winzerstraße 1-3/2"), Is.EqualTo(("Winzerstraße", "1-3/2")));
+                Assert.That(Utils.SplitAddress("Winzerstraße 3/4/5"), Is.EqualTo(("Winzerstraße", "3/4/5")));
+                Assert.That(Utils.SplitAddress("Winzerstraße 7/2/4/77"), Is.EqualTo(("Winzerstraße", "7/2/4/77")));
+                Assert.That(Utils.SplitAddress("Winzerstraße 95b"), Is.EqualTo(("Winzerstraße", "95b")));
+                Assert.That(Utils.SplitAddress("Winzerstraße 1, TOP 3"), Is.EqualTo(("Winzerstraße", "1, TOP 3")));
+            });
+        }
+
+        [Test]
+        public void Test_SplitName() {
+            Assert.Multiple(() => {
+                Assert.That(Utils.SplitName("Max Bauer", "Bauer"), Is.EqualTo(("Bauer", "Max")));
+                Assert.That(Utils.SplitName("Bauer Max", "Bauer"), Is.EqualTo(("Bauer", "Max")));
+                Assert.That(Utils.SplitName("Max und Moritz Bauer", "Bauer"), Is.EqualTo(("Bauer", "Max und Moritz")));
+                Assert.That(Utils.SplitName("Bauer Max und Moritz", "Bauer"), Is.EqualTo(("Bauer", "Max und Moritz")));
+                Assert.That(Utils.SplitName("Bauer GesbR", "Bauer"), Is.EqualTo(("Bauer", "GesbR")));
+                Assert.That(Utils.SplitName("Max und Moritz Bauer GesbR", "Bauer"), Is.EqualTo(("Bauer", "Max und Moritz GesbR")));
+                Assert.That(Utils.SplitName("Bauer Max und Moritz GesbR", "Bauer"), Is.EqualTo(("Bauer", "Max und Moritz GesbR")));
+                Assert.That(Utils.SplitName("Weingut Bauer", "Bauer"), Is.EqualTo(("Bauer", "Weingut")));
+                Assert.That(Utils.SplitName("Bauer Weingut", "Bauer"), Is.EqualTo(("Bauer", "Weingut")));
+                Assert.That(Utils.SplitName("Max und Moritz Bauer und Mustermann", "Bauer"), Is.EqualTo(("Bauer und Mustermann", "Max und Moritz")));
+                Assert.That(Utils.SplitName("Bauer und Mustermann Max und Moritz", "Bauer"), Is.EqualTo(("Bauer und Mustermann", "Max und Moritz")));
+                Assert.That(Utils.SplitName("ABC GesbR", "Bauer"), Is.EqualTo(((string, string?))("ABC GesbR", null)));
+            });
+        }
+
+        [Test]
+        public void Test_CalcCrc16Modbus() {
+            Assert.Multiple(() => {
+                Assert.That(Utils.CalcCrc16Modbus(""), Is.EqualTo(0xFFFF));
+                Assert.That(Utils.CalcCrc16Modbus("abcd"), Is.EqualTo(0x1D97));
+                Assert.That(Utils.CalcCrc16Modbus("ABCD"), Is.EqualTo(0x0F85));
+                // Matzen (SysTec IT3000A)
+                Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:03   01       0       0       0kg     1"), Is.EqualTo(43166));
+                Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:04   01       0       0       0kg     1"), Is.EqualTo(21615));
+                Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:05   01       0       0       0kg     1"), Is.EqualTo(40446));
+                Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:06   01       0       0       0kg     1"), Is.EqualTo(34638));
+                Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:07   01       0       0       0kg     1"), Is.EqualTo(20191));
+                Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:08   01       0       0       0kg     1"), Is.EqualTo(16047));
+                Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:09   01       0       0       0kg     1"), Is.EqualTo(63294));
+                Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:10   01       0       0       0kg     1"), Is.EqualTo(7718));
+                Assert.That(Utils.CalcCrc16Modbus("000011.08.2319:12   01       0       0       0kg     1"), Is.EqualTo(52487));
+                // Wolkersdorf, Waage 1 (SysTec IT6000E)
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:50   51       0       0       0kg     A"), Is.EqualTo(10187));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:50   61       0       0       0kg     A"), Is.EqualTo(20683));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:50   71       0       0       0kg     A"), Is.EqualTo(48586));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:50   81       0       0       0kg     A"), Is.EqualTo(22217));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:50   91       0       0       0kg     A"), Is.EqualTo(48072));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51  101       0       0       0kg     A"), Is.EqualTo(30119));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51  111       0       0       0kg     A"), Is.EqualTo(39078));
+                // Wolkersdorf, Waage 2 (SysTec IT6000E)
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51   41       0       0       0kg     B"), Is.EqualTo(539));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51   51       0       0       0kg     B"), Is.EqualTo(61210));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51   61       0       0       0kg     B"), Is.EqualTo(38938));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51   71       0       0       0kg     B"), Is.EqualTo(29979));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51   81       0       0       0kg     B"), Is.EqualTo(40472));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51   91       0       0       0kg     B"), Is.EqualTo(29465));
+                Assert.That(Utils.CalcCrc16Modbus("000004.09.2315:51  101       0       0       0kg     B"), Is.EqualTo(29927));
+                // Gr.Inzersdorf (L246/IT3)
+                Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49   11       0       0       0kg   001"), Is.EqualTo(27556));
+                Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49   21       0       0       0kg   001"), Is.EqualTo(7332));
+                Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49   31       0       0       0kg   001"), Is.EqualTo(61861));
+                Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49   41       0       0       0kg   001"), Is.EqualTo(62116));
+                Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49   51       0       0       0kg   001"), Is.EqualTo(8101));
+                Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49   61       0       0       0kg   001"), Is.EqualTo(26789));
+                Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:49   71      50       0      50kg   001"), Is.EqualTo(16188));
+                Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:50   81      35       0      35kg   001"), Is.EqualTo(12015));
+                Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:50   91      40       0      40kg   001"), Is.EqualTo(60047));
+                Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:50  101      40       0      40kg   001"), Is.EqualTo(60785));
+                Assert.That(Utils.CalcCrc16Modbus("000019.02.2410:50  111      45       0      45kg   001"), Is.EqualTo(35918));
+            });
+        }
+    }
+}

Tests/UnitTests/HelperTests/ValidatorTest.cs

@@ -0,0 +1,113 @@
+using Elwig.Helpers;
+using System.Windows.Controls;
+
+namespace Tests.UnitTests.HelperTests {
+    [TestFixture]
+    [Apartment(ApartmentState.STA)]
+    public class ValidatorTest {
+
+        private static TextBox TB(string value, int caret = 0) {
+            return new() {
+                Text = value,
+                CaretIndex = caret,
+            };
+        }
+
+        [Test]
+        public void Test_CheckInteger_Simple() {
+            Assert.Multiple(() => {
+                Assert.That(Validator.CheckInteger(TB(""), true).IsValid, Is.False);
+                Assert.That(Validator.CheckInteger(TB(""), false).IsValid, Is.True);
+                Assert.That(Validator.CheckInteger(TB("123"), true).IsValid, Is.True);
+                Assert.That(Validator.CheckInteger(TB("456"), false).IsValid, Is.True);
+                Assert.That(Validator.CheckInteger(TB("1234"), false, 4).IsValid, Is.True);
+                Assert.That(Validator.CheckInteger(TB("4567"), false, 3).IsValid, Is.True);
+            });
+        }
+
+        [Test]
+        public void Test_CheckInteger_Caret() {
+            var tb = TB("1a2b3c", 2);
+            Assert.Multiple(() => {
+                Assert.That(Validator.CheckInteger(tb, true).IsValid, Is.True);
+                Assert.That(tb.Text, Is.EqualTo("123"));
+                Assert.That(tb.CaretIndex, Is.EqualTo(1));
+            });
+        }
+
+        [Test]
+        public void Test_CheckInteger_MaxLen() {
+            var tb = TB("1a2b3c4d5e", 4);
+            Assert.Multiple(() => {
+                Assert.That(Validator.CheckInteger(tb, true, 3).IsValid, Is.True);
+                Assert.That(tb.Text, Is.EqualTo("123"));
+                Assert.That(tb.CaretIndex, Is.EqualTo(2));
+            });
+        }
+
+        [Test]
+        public void Test_CheckPhoneNumber_Simple() {
+            Assert.Multiple(() => {
+                Assert.That(Validator.CheckPhoneNumber(TB(""), true).IsValid, Is.False);
+                Assert.That(Validator.CheckPhoneNumber(TB("+43"), false).IsValid, Is.False);
+                Assert.That(Validator.CheckPhoneNumber(TB("066412345678"), true).IsValid, Is.True);
+                Assert.That(Validator.CheckPhoneNumber(TB("0ab66412cd345678"), true).IsValid, Is.True);
+            });
+        }
+
+        [Test]
+        public void Test_CheckPhoneNumber_Format_1() {
+            var tb = TB("066412345678", 5);
+            Assert.Multiple(() => {
+                Assert.That(Validator.CheckPhoneNumber(tb, true).IsValid, Is.True);
+                Assert.That(tb.Text, Is.EqualTo("+43 664 12345678"));
+                Assert.That(tb.CaretIndex, Is.EqualTo(9));
+            });
+        }
+
+        [Test]
+        public void Test_CheckPhoneNumber_Format_2() {
+            var tb = TB("0a2574b1c2d34..", 7);
+            Assert.Multiple(() => {
+                Assert.That(Validator.CheckPhoneNumber(tb, true).IsValid, Is.True);
+                Assert.That(tb.Text, Is.EqualTo("+43 2574 1234"));
+                Assert.That(tb.CaretIndex, Is.EqualTo(8));
+            });
+        }
+
+        [Test]
+        public void Test_CheckEmailAddress_Simple() {
+            Assert.Multiple(() => {
+                Assert.That(Validator.CheckEmailAddress(TB(""), true).IsValid, Is.False);
+                Assert.That(Validator.CheckEmailAddress(TB("name"), false).IsValid, Is.False);
+                Assert.That(Validator.CheckEmailAddress(TB("@"), false).IsValid, Is.False);
+                Assert.That(Validator.CheckEmailAddress(TB("@test.com"), false).IsValid, Is.False);
+                Assert.That(Validator.CheckEmailAddress(TB("name@a"), true).IsValid, Is.False);
+                Assert.That(Validator.CheckEmailAddress(TB("name@a.com."), true).IsValid, Is.False);
+                Assert.That(Validator.CheckEmailAddress(TB("name@a.com.a"), true).IsValid, Is.False);
+                Assert.That(Validator.CheckEmailAddress(TB("name@a.com"), true).IsValid, Is.True);
+                Assert.That(Validator.CheckEmailAddress(TB("my.name@hello#.com"), true).IsValid, Is.True);
+            });
+        }
+
+        [Test]
+        public void Test_CheckEmailAddress_Format_1() {
+            var tb = TB("my . name . is @heinz#.com", 17);
+            Assert.Multiple(() => {
+                Assert.That(Validator.CheckEmailAddress(tb, true).IsValid, Is.True);
+                Assert.That(tb.Text, Is.EqualTo("my.name.is@heinz.com"));
+                Assert.That(tb.CaretIndex, Is.EqualTo(12));
+            });
+        }
+
+        [Test]
+        public void Test_CheckEmailAddress_Format_2() {
+            var tb = TB("sabine.müsterfrau@heinz#.com.b", 30);
+            Assert.Multiple(() => {
+                Assert.That(Validator.CheckEmailAddress(tb, true).IsValid, Is.False);
+                Assert.That(tb.Text, Is.EqualTo("sabine.müsterfrau@heinz.com.b"));
+                Assert.That(tb.CaretIndex, Is.EqualTo(29));
+            });
+        }
+    }
+}

Tests/UnitTests/ServiceTests/DeliveryServiceTest.cs

@@ -0,0 +1,847 @@
+using Elwig.Helpers;
+using Elwig.Models.Entities;
+using Elwig.Services;
+using Elwig.ViewModels;
+using Microsoft.EntityFrameworkCore;
+
+namespace Tests.UnitTests.ServiceTests {
+    [TestFixture]
+    public class DeliveryServiceTest {
+
+        private static async Task InitViewModel(DeliveryAdminViewModel vm) {
+            using var ctx = new AppDbContext();
+            vm.MemberSource = await ctx.Members.ToListAsync();
+            vm.BranchSource = await ctx.Branches.ToListAsync();
+            vm.WineVarSource = await ctx.WineVarieties.ToListAsync();
+            List<object> attrs = (await ctx.WineAttributes.ToListAsync()).Cast<object>().ToList();
+            attrs.Insert(0, new NullItem());
+            vm.WineAttrSource = attrs;
+            List<object> cults = (await ctx.WineCultivations.ToListAsync()).Cast<object>().ToList();
+            cults.Insert(0, new NullItem());
+            vm.WineCultSource = cults;
+            vm.WineQualityLevelSource = await ctx.WineQualityLevels.ToListAsync();
+            vm.WineOriginSource = await ctx.WineOrigins.ToListAsync();
+            vm.WineKgSource = await ctx.Katastralgemeinden.ToListAsync();
+            vm.ModifiersSource = await ctx.Modifiers.Where(m => m.Year == 2022).ToListAsync();
+        }
+
+        private static async Task<Delivery?> GetDelivery(string lsnr) {
+            using var ctx = new AppDbContext();
+            return await ctx.Deliveries
+                .Where(d => d.LsNr == lsnr)
+                .Include(d => d.Parts)
+                .ThenInclude(p => p.PartModifiers)
+                .ThenInclude(m => m.Modifier)
+                .AsSplitQuery()
+                .FirstOrDefaultAsync();
+        }
+
+        private static DeliveryPart[] GetParts(Delivery d) {
+            return [.. d.Parts.OrderBy(p => p.DPNr)];
+        }
+
+        [Test]
+        public async Task TestCreate_01_Minimal() {
+            var vm = new DeliveryAdminViewModel();
+            await InitViewModel(vm);
+
+            vm.Date = "01.10.2022";
+            vm.Branch = vm.BranchSource.First();
+            vm.MgNr = 101;
+            vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
+            vm.SortId = "GV";
+            vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
+            vm.GradationKmw = 15.0;
+            vm.GradationOe = 73;
+            vm.Weight = 1234;
+            vm.IsManualWeighing = true;
+            vm.IsNetWeight = false;
+            vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
+            vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
+
+            var p1 = await vm.UpdateDeliveryPart(2022, null, null, false, false, true);
+            Assert.That(p1.Delivery.LsNr, Is.EqualTo("20221001X001"));
+
+            var d = await GetDelivery("20221001X001");
+
+            Assert.That(d, Is.Not.Null);
+            Assert.That(d.Parts, Has.Count.EqualTo(1));
+            var p = d.Parts.First();
+            Assert.That(p, Is.Not.Null);
+            Assert.Multiple(() => {
+                Assert.That(d.LsNr, Is.EqualTo("20221001X001"));
+                Assert.That(d.Date, Is.EqualTo(new DateOnly(2022, 10, 1)));
+                Assert.That(d.ZwstId, Is.EqualTo("X"));
+                Assert.That(d.MgNr, Is.EqualTo(101));
+                Assert.That(p.SortId, Is.EqualTo("GV"));
+                Assert.That(p.AttrId, Is.Null);
+                Assert.That(p.CultId, Is.Null);
+                Assert.That(p.Kmw, Is.EqualTo(15.0));
+                Assert.That(p.Oe, Is.EqualTo(73));
+                Assert.That(p.QualId, Is.EqualTo("QUW"));
+                Assert.That(p.Weight, Is.EqualTo(1234));
+                Assert.That(p.IsNetWeight, Is.False);
+                Assert.That(p.IsManualWeighing, Is.True);
+                Assert.That(p.HkId, Is.EqualTo("WLNO"));
+            });
+
+            vm = new DeliveryAdminViewModel();
+            await InitViewModel(vm);
+            Assert.DoesNotThrow(() => {
+                vm.FillInputs(d);
+                vm.FillInputs(p);
+            });
+            Assert.Multiple(() => {
+                Assert.That(vm.LsNr, Is.EqualTo("20221001X001"));
+                Assert.That(vm.Date, Is.EqualTo("01.10.2022"));
+                Assert.That(vm.Branch?.ZwstId, Is.EqualTo("X"));
+                Assert.That(vm.MgNr, Is.EqualTo(101));
+                Assert.That(vm.SortId, Is.EqualTo("GV"));
+                Assert.That(vm.WineAttr?.AttrId, Is.Null);
+                Assert.That(vm.WineCult?.CultId, Is.Null);
+                Assert.That(vm.GradationKmw, Is.EqualTo(15.0));
+                Assert.That(vm.WineQualityLevel?.QualId, Is.EqualTo("QUW"));
+                Assert.That(vm.Weight, Is.EqualTo(1234));
+                Assert.That(vm.IsNetWeight, Is.False);
+                Assert.That(vm.IsManualWeighing, Is.True);
+                Assert.That(vm.WineOrigin?.HkId, Is.EqualTo("WLNO"));
+            });
+        }
+
+        [Test]
+        public async Task TestCreate_02_Advanced() {
+            var vm = new DeliveryAdminViewModel();
+            await InitViewModel(vm);
+
+            vm.Date = "02.10.2022";
+            vm.Branch = vm.BranchSource.First();
+            vm.MgNr = 102;
+            vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
+            vm.SortId = "ZW";
+            vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
+            vm.WineAttr = vm.WineAttrSource.Skip(1).First() as WineAttr;
+            vm.WineCult = vm.WineCultSource.Skip(1).First() as WineCult;
+            vm.GradationKmw = 15.9;
+            vm.GradationOe = 78;
+            vm.Weight = 3456;
+            vm.IsManualWeighing = false;
+            vm.IsNetWeight = true;
+            vm.WeighingData = "{}";
+            vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
+            vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
+            vm.Modifiers.Add(vm.ModifiersSource.First());
+
+            var p1 = await vm.UpdateDeliveryPart(2022, null, null, false, false, true);
+            Assert.That(p1.Delivery.LsNr, Is.EqualTo("20221002X001"));
+
+            var d = await GetDelivery("20221002X001");
+
+            Assert.That(d, Is.Not.Null);
+            Assert.That(d.Parts, Has.Count.EqualTo(1));
+            var p = d.Parts.First();
+            Assert.That(p, Is.Not.Null);
+            Assert.Multiple(() => {
+                Assert.That(d.LsNr, Is.EqualTo("20221002X001"));
+                Assert.That(d.Date, Is.EqualTo(new DateOnly(2022, 10, 2)));
+                Assert.That(d.ZwstId, Is.EqualTo("X"));
+                Assert.That(d.MgNr, Is.EqualTo(102));
+                Assert.That(p.SortId, Is.EqualTo("ZW"));
+                Assert.That(p.AttrId, Is.Not.Null);
+                Assert.That(p.CultId, Is.Not.Null);
+                Assert.That(p.Kmw, Is.EqualTo(15.9));
+                Assert.That(p.Oe, Is.EqualTo(78));
+                Assert.That(p.QualId, Is.EqualTo("QUW"));
+                Assert.That(p.Weight, Is.EqualTo(3456));
+                Assert.That(p.IsNetWeight, Is.True);
+                Assert.That(p.IsManualWeighing, Is.False);
+                Assert.That(p.WeighingData, Is.EqualTo("{}"));
+                Assert.That(p.HkId, Is.EqualTo("WLNO"));
+                Assert.That(p.Modifiers.Count(), Is.EqualTo(1));
+            });
+
+            vm = new DeliveryAdminViewModel();
+            await InitViewModel(vm);
+            Assert.DoesNotThrow(() => {
+                vm.FillInputs(d);
+                vm.FillInputs(p);
+            });
+            Assert.Multiple(() => {
+                Assert.That(vm.LsNr, Is.EqualTo("20221002X001"));
+                Assert.That(vm.Date, Is.EqualTo("02.10.2022"));
+                Assert.That(vm.Branch?.ZwstId, Is.EqualTo("X"));
+                Assert.That(vm.MgNr, Is.EqualTo(102));
+                Assert.That(vm.SortId, Is.EqualTo("ZW"));
+                Assert.That(vm.WineAttr?.AttrId, Is.Not.Null);
+                Assert.That(vm.WineCult?.CultId, Is.Not.Null);
+                Assert.That(vm.GradationKmw, Is.EqualTo(15.9));
+                Assert.That(vm.WineQualityLevel?.QualId, Is.EqualTo("QUW"));
+                Assert.That(vm.Weight, Is.EqualTo(3456));
+                Assert.That(vm.IsNetWeight, Is.True);
+                Assert.That(vm.IsManualWeighing, Is.False);
+                Assert.That(vm.WeighingData, Is.EqualTo("{}"));
+                Assert.That(vm.WineOrigin?.HkId, Is.EqualTo("WLNO"));
+                Assert.That(vm.Modifiers, Has.Count.EqualTo(1));
+            });
+        }
+
+        [Test]
+        public async Task TestCreate_03_TwoParts() {
+            var vm = new DeliveryAdminViewModel();
+            await InitViewModel(vm);
+
+            vm.Date = "03.10.2022";
+            vm.Branch = vm.BranchSource.First();
+            vm.MgNr = 101;
+            vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
+            vm.SortId = "GV";
+            vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
+            vm.GradationKmw = 15.0;
+            vm.GradationOe = 73;
+            vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
+            vm.Weight = 1234;
+            vm.IsManualWeighing = true;
+            vm.IsNetWeight = true;
+            vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
+            var p1 = await vm.UpdateDeliveryPart(2022, null, null, false, false, true);
+
+            Assert.That(p1.Delivery.LsNr, Is.EqualTo("20221003X001"));
+            vm.FillInputs(p1.Delivery);
+
+            vm.SortId = "WR";
+            vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
+            vm.GradationKmw = 18.0;
+            vm.GradationOe = 89;
+            vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "KAB");
+            vm.Weight = 2345;
+            var p2 = await vm.UpdateDeliveryPart(p1.Year, p1.DId, null, false, false, true);
+
+            Assert.That(p2.Delivery.LsNr, Is.EqualTo("20221003X001"));
+
+            var d = await GetDelivery("20221003X001");
+
+            Assert.That(d, Is.Not.Null);
+            Assert.Multiple(() => {
+                Assert.That(d.Parts, Has.Count.EqualTo(2));
+                Assert.That(d.MgNr, Is.EqualTo(101));
+            });
+            var p = d.Parts.First();
+            Assert.That(p, Is.Not.Null);
+            Assert.Multiple(() => {
+                Assert.That(p.DPNr, Is.EqualTo(1));
+                Assert.That(p.SortId, Is.EqualTo("GV"));
+            });
+            p = d.Parts.Skip(1).First();
+            Assert.That(p, Is.Not.Null);
+            Assert.Multiple(() => {
+                Assert.That(p.DPNr, Is.EqualTo(2));
+                Assert.That(p.SortId, Is.EqualTo("WR"));
+            });
+        }
+
+        [Test]
+        public async Task TestCreate_04_ChangeMember() {
+            var vm = new DeliveryAdminViewModel();
+            await InitViewModel(vm);
+
+            vm.Date = "04.10.2022";
+            vm.Branch = vm.BranchSource.First();
+            vm.MgNr = 101;
+            vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
+            vm.SortId = "GV";
+            vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
+            vm.GradationKmw = 15.0;
+            vm.GradationOe = 73;
+            vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
+            vm.Weight = 1234;
+            vm.IsManualWeighing = true;
+            vm.IsNetWeight = true;
+            vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
+            var p1 = await vm.UpdateDeliveryPart(2022, null, null, false, false, true);
+
+            Assert.That(p1.Delivery.LsNr, Is.EqualTo("20221004X001"));
+            vm.FillInputs(p1.Delivery);
+
+            vm.MgNr = 102;
+            vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
+            vm.SortId = "GV";
+            vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
+            vm.GradationKmw = 15.0;
+            vm.GradationOe = 73;
+            vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
+            vm.Weight = 1234;
+            vm.IsManualWeighing = true;
+            vm.IsNetWeight = true;
+            vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
+
+            var p2 = await vm.UpdateDeliveryPart(p1.Year, p1.DId, null, false, false, true);
+
+            Assert.That(p2.Delivery.LsNr, Is.EqualTo("20221004X001"));
+
+            var d = await GetDelivery("20221004X001");
+
+            Assert.That(d, Is.Not.Null);
+            Assert.Multiple(() => {
+                Assert.That(d.Parts, Has.Count.EqualTo(2));
+                Assert.That(d.MgNr, Is.EqualTo(102));
+            });
+        }
+
+        [Test]
+        public async Task TestCreate_05_LNrChanged() {
+            var vm = new DeliveryAdminViewModel();
+            await InitViewModel(vm);
+
+            vm.Date = "29.09.2022";
+            vm.Branch = vm.BranchSource.First();
+            vm.LsNr = "20220929X001";  // "old" LNr, simulated change in DB
+            vm.MgNr = 101;
+            vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
+            vm.SortId = "GV";
+            vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
+            vm.GradationKmw = 15.0;
+            vm.GradationOe = 73;
+            vm.WineQualityLevel = vm.WineQualityLevelSource.First(l => l.QualId == "QUW");
+            vm.Weight = 1234;
+            vm.IsManualWeighing = true;
+            vm.IsNetWeight = true;
+            vm.WineOrigin = vm.WineOriginSource.First(o => o.HkId == "WLNO");
+            var p1 = await vm.UpdateDeliveryPart(2022, null, null, false, false, true);
+
+            Assert.That(p1.Delivery.LsNr, Is.EqualTo("20220929X002"));
+
+            var d = GetDelivery("20220929X002");
+            Assert.That(d, Is.Not.Null);
+        }
+
+        [Test]
+        public async Task TestUpdate_01_Simple() {
+            var vm = new DeliveryAdminViewModel();
+            await InitViewModel(vm);
+
+            var d = await GetDelivery("20231010X001");
+            Assert.That(d, Is.Not.Null);
+            var p = d.Parts.First();
+            Assert.That(p, Is.Not.Null);
+            Assert.DoesNotThrow(() => {
+                vm.FillInputs(d);
+                vm.FillInputs(p);
+            });
+
+            vm.SortId = "WR";
+            vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
+            vm.GradationKmw = 15.9;
+            vm.GradationOe = 79;
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.UpdateDeliveryPart(vm, p.Year, p.DId, p.DPNr, false, false, true));
+
+            d = await GetDelivery("20231010X001");
+            Assert.That(d, Is.Not.Null);
+            p = d.Parts.First();
+            Assert.That(p, Is.Not.Null);
+
+            vm = new DeliveryAdminViewModel();
+            await InitViewModel(vm);
+            Assert.DoesNotThrow(() => {
+                vm.FillInputs(d);
+                vm.FillInputs(p);
+            });
+            Assert.Multiple(() => {
+                Assert.That(vm.SortId, Is.EqualTo("WR"));
+                Assert.That(vm.GradationKmw, Is.EqualTo(15.9));
+            });
+        }
+
+        [Test]
+        public async Task TestUpdate_02_Member() {
+            var vm = new DeliveryAdminViewModel();
+            await InitViewModel(vm);
+
+            var d = await GetDelivery("20231010X002");
+            Assert.That(d, Is.Not.Null);
+            var p = d.Parts.First();
+            Assert.That(p, Is.Not.Null);
+            Assert.DoesNotThrow(() => {
+                vm.FillInputs(d);
+                vm.FillInputs(p);
+            });
+            Assert.That(d.MgNr, Is.EqualTo(101));
+
+            vm.SortId = "GV";
+            vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
+            vm.MgNr = 102;
+            vm.Member = vm.MemberSource.First(m => m.MgNr == vm.MgNr);
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.UpdateDeliveryPart(vm, p.Year, p.DId, p.DPNr, false, false, true));
+
+            d = await GetDelivery("20231010X002");
+            Assert.That(d, Is.Not.Null);
+            Assert.That(d.MgNr, Is.EqualTo(102));
+        }
+
+        [Test]
+        public async Task TestUpdate_03_DateAndTime() {
+            var vm = new DeliveryAdminViewModel();
+            await InitViewModel(vm);
+
+            var d = await GetDelivery("20231015X001");
+            Assert.That(d, Is.Null);
+            d = await GetDelivery("20231010X003");
+            Assert.That(d, Is.Not.Null);
+            var p = d.Parts.First();
+            Assert.That(p, Is.Not.Null);
+            Assert.DoesNotThrow(() => {
+                vm.FillInputs(d);
+                vm.FillInputs(p);
+            });
+            Assert.That(d.MgNr, Is.EqualTo(101));
+
+            vm.SortId = "GV";
+            vm.WineVar = vm.WineVarSource.First(v => v.SortId == vm.SortId);
+            vm.Date = "15.10.2023";
+            vm.Time = "12:00";
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.UpdateDeliveryPart(vm, p.Year, p.DId, p.DPNr, true, true, false));
+
+            d = await GetDelivery("20231010X003");
+            Assert.That(d, Is.Null);
+            d = await GetDelivery("20231015X001");
+            Assert.That(d, Is.Not.Null);
+        }
+
+        [Test]
+        public async Task TestSplit_01_Depreciate_One() {
+            var d = await GetDelivery("20231001X001");
+            Assert.That(d, Is.Not.Null);
+            Assert.Multiple(() => {
+                var ps = GetParts(d);
+                Assert.That(ps, Has.Length.EqualTo(3));
+                Assert.That(ps[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps[0].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.DepreciateDelivery(d.Year, d.DId, [1000, 0, 0]));
+            d = await GetDelivery("20231001X001");
+            Assert.That(d, Is.Not.Null);
+            Assert.Multiple(() => {
+                var ps = GetParts(d);
+                Assert.That(ps, Has.Length.EqualTo(3));
+                Assert.That(ps[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps[0].QualId, Is.EqualTo("WEI"));
+                Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
+            });
+        }
+
+        [Test]
+        public async Task TestSplit_02_Depreciate_Partial() {
+            var d = await GetDelivery("20231001X002");
+            Assert.That(d, Is.Not.Null);
+            Assert.Multiple(() => {
+                var ps = GetParts(d);
+                Assert.That(ps, Has.Length.EqualTo(3));
+                Assert.That(ps[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps[0].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.DepreciateDelivery(d.Year, d.DId, [600, 0, 0]));
+            d = await GetDelivery("20231001X002");
+            Assert.That(d, Is.Not.Null);
+            Assert.Multiple(() => {
+                var ps = GetParts(d);
+                Assert.That(ps, Has.Length.EqualTo(4));
+                Assert.That(ps[0].Weight, Is.EqualTo(400));
+                Assert.That(ps[0].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[3].Weight, Is.EqualTo(600));
+                Assert.That(ps[3].QualId, Is.EqualTo("WEI"));
+            });
+        }
+
+        [Test]
+        public async Task TestSplit_03_Depreciate_Mixed() {
+            var d = await GetDelivery("20231001X003");
+            Assert.That(d, Is.Not.Null);
+            Assert.Multiple(() => {
+                var ps = GetParts(d);
+                Assert.That(ps, Has.Length.EqualTo(3));
+                Assert.That(ps[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps[0].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.DepreciateDelivery(d.Year, d.DId, [1000, 700, -5]));
+            d = await GetDelivery("20231001X003");
+            Assert.That(d, Is.Not.Null);
+            Assert.Multiple(() => {
+                var ps = GetParts(d);
+                Assert.That(ps, Has.Length.EqualTo(4));
+                Assert.That(ps[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps[0].QualId, Is.EqualTo("WEI"));
+                Assert.That(ps[1].Weight, Is.EqualTo(300));
+                Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[2].Weight, Is.EqualTo(1000));
+                Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[3].Weight, Is.EqualTo(700));
+                Assert.That(ps[3].QualId, Is.EqualTo("WEI"));
+            });
+        }
+
+        [Test]
+        public async Task TestSplit_04_Depreciate_Complete() {
+            var d = await GetDelivery("20231001X004");
+            Assert.That(d, Is.Not.Null);
+            Assert.Multiple(() => {
+                var ps = GetParts(d);
+                Assert.That(ps, Has.Length.EqualTo(3));
+                Assert.That(ps[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps[0].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps[1].QualId, Is.Not.EqualTo("WEI"));
+                Assert.That(ps[2].Weight, Is.EqualTo(1000));
+                Assert.That(ps[2].QualId, Is.Not.EqualTo("WEI"));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.DepreciateDelivery(d.Year, d.DId, [1000, 1100, int.MaxValue]));
+            d = await GetDelivery("20231001X004");
+            Assert.That(d, Is.Not.Null);
+            Assert.Multiple(() => {
+                var ps = GetParts(d);
+                Assert.That(ps, Has.Length.EqualTo(3));
+                Assert.That(ps[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps[0].QualId, Is.EqualTo("WEI"));
+                Assert.That(ps[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps[1].QualId, Is.EqualTo("WEI"));
+                Assert.That(ps[2].Weight, Is.EqualTo(1000));
+                Assert.That(ps[2].QualId, Is.EqualTo("WEI"));
+            });
+        }
+
+        [Test]
+        public async Task TestSplit_05_OtherMember_One() {
+            var d1 = await GetDelivery("20231002X001");
+            var d2 = await GetDelivery("20231002X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                Assert.That(d1.MgNr, Is.EqualTo(101));
+                Assert.That(ps1, Has.Length.EqualTo(3));
+                Assert.That(ps1[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[2].Weight, Is.EqualTo(1000));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToMember(d1.Year, d1.DId, [1000, 0, 0], 102));
+            d1 = await GetDelivery("20231002X001");
+            d2 = await GetDelivery("20231002X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                var ps2 = GetParts(d2);
+                Assert.That(d1.MgNr, Is.EqualTo(101));
+                Assert.That(d2.MgNr, Is.EqualTo(102));
+                Assert.That(ps1, Has.Length.EqualTo(2));
+                Assert.That(ps1[0].DPNr, Is.EqualTo(2));
+                Assert.That(ps1[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[1].DPNr, Is.EqualTo(3));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps2, Has.Length.EqualTo(1));
+                Assert.That(ps2[0].DPNr, Is.EqualTo(1));
+                Assert.That(ps2[0].Weight, Is.EqualTo(1000));
+            });
+        }
+
+        [Test]
+        public async Task TestSplit_06_OtherMember_Partial() {
+            var d1 = await GetDelivery("20231003X001");
+            var d2 = await GetDelivery("20231003X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                Assert.That(d1.MgNr, Is.EqualTo(101));
+                Assert.That(ps1, Has.Length.EqualTo(3));
+                Assert.That(ps1[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[2].Weight, Is.EqualTo(1000));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToMember(d1.Year, d1.DId, [400, -1, -2], 102));
+            d1 = await GetDelivery("20231003X001");
+            d2 = await GetDelivery("20231003X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                var ps2 = GetParts(d2);
+                Assert.That(d1.MgNr, Is.EqualTo(101));
+                Assert.That(d2.MgNr, Is.EqualTo(102));
+                Assert.That(ps1, Has.Length.EqualTo(3));
+                Assert.That(ps1[0].Weight, Is.EqualTo(600));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[2].Weight, Is.EqualTo(1000));
+                Assert.That(ps2, Has.Length.EqualTo(1));
+                Assert.That(ps2[0].Weight, Is.EqualTo(400));
+            });
+        }
+
+        [Test]
+        public async Task TestSplit_07_OtherMember_Mixed() {
+            var d1 = await GetDelivery("20231004X001");
+            var d2 = await GetDelivery("20231004X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                Assert.That(d1.MgNr, Is.EqualTo(101));
+                Assert.That(ps1, Has.Length.EqualTo(3));
+                Assert.That(ps1[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[2].Weight, Is.EqualTo(1000));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToMember(d1.Year, d1.DId, [200, 1000, int.MinValue], 102));
+            d1 = await GetDelivery("20231004X001");
+            d2 = await GetDelivery("20231004X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                var ps2 = GetParts(d2);
+                Assert.That(d1.MgNr, Is.EqualTo(101));
+                Assert.That(d2.MgNr, Is.EqualTo(102));
+                Assert.That(ps1, Has.Length.EqualTo(2));
+                Assert.That(ps1[0].DPNr, Is.EqualTo(1));
+                Assert.That(ps1[0].Weight, Is.EqualTo(800));
+                Assert.That(ps1[1].DPNr, Is.EqualTo(3));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps2, Has.Length.EqualTo(2));
+                Assert.That(ps2[0].DPNr, Is.EqualTo(1));
+                Assert.That(ps2[0].Weight, Is.EqualTo(200));
+                Assert.That(ps2[1].DPNr, Is.EqualTo(2));
+                Assert.That(ps2[1].Weight, Is.EqualTo(1000));
+            });
+        }
+
+        [Test]
+        public async Task TestSplit_08_OtherMember_Complete() {
+            var d1 = await GetDelivery("20231005X001");
+            var d2 = await GetDelivery("20231005X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                Assert.That(d1.MgNr, Is.EqualTo(101));
+                Assert.That(ps1, Has.Length.EqualTo(3));
+                Assert.That(ps1[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[2].Weight, Is.EqualTo(1000));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToMember(d1.Year, d1.DId, [1000, int.MaxValue, 1100], 102));
+            d1 = await GetDelivery("20231005X001");
+            d2 = await GetDelivery("20231005X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps2 = GetParts(d2);
+                Assert.That(d2.MgNr, Is.EqualTo(102));
+                Assert.That(ps2, Has.Length.EqualTo(3));
+                Assert.That(ps2[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps2[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps2[2].Weight, Is.EqualTo(1000));
+            });
+        }
+
+        [Test]
+        public async Task TestSplit_09_OtherDelivery_One() {
+            var d1 = await GetDelivery("20231006X001");
+            var d2 = await GetDelivery("20231006X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                var ps2 = GetParts(d2);
+                Assert.That(ps1, Has.Length.EqualTo(3));
+                Assert.That(ps1[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[2].Weight, Is.EqualTo(1000));
+                Assert.That(ps2, Has.Length.EqualTo(1));
+                Assert.That(ps2[0].Weight, Is.EqualTo(1000));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToLsNr(d1.Year, d1.DId, [0, 1000, -4], d2.LsNr));
+            d1 = await GetDelivery("20231006X001");
+            d2 = await GetDelivery("20231006X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                var ps2 = GetParts(d2);
+                Assert.That(ps1, Has.Length.EqualTo(2));
+                Assert.That(ps1[0].DPNr, Is.EqualTo(1));
+                Assert.That(ps1[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[1].DPNr, Is.EqualTo(3));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps2, Has.Length.EqualTo(2));
+                Assert.That(ps2[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps2[1].Weight, Is.EqualTo(1000));
+            });
+        }
+
+        [Test]
+        public async Task TestSplit_10_OtherDelivery_Partial() {
+            var d1 = await GetDelivery("20231007X001");
+            var d2 = await GetDelivery("20231007X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                var ps2 = GetParts(d2);
+                Assert.That(ps1, Has.Length.EqualTo(3));
+                Assert.That(ps1[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[2].Weight, Is.EqualTo(1000));
+                Assert.That(ps2, Has.Length.EqualTo(1));
+                Assert.That(ps2[0].Weight, Is.EqualTo(1000));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToLsNr(d1.Year, d1.DId, [0, 300, int.MinValue], d2.LsNr));
+            d1 = await GetDelivery("20231007X001");
+            d2 = await GetDelivery("20231007X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                var ps2 = GetParts(d2);
+                Assert.That(ps1, Has.Length.EqualTo(3));
+                Assert.That(ps1[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[1].Weight, Is.EqualTo(700));
+                Assert.That(ps1[2].Weight, Is.EqualTo(1000));
+                Assert.That(ps2, Has.Length.EqualTo(2));
+                Assert.That(ps2[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps2[1].Weight, Is.EqualTo(300));
+            });
+        }
+
+        [Test]
+        public async Task TestSplit_11_OtherDelivery_Mixed() {
+            var d1 = await GetDelivery("20231008X001");
+            var d2 = await GetDelivery("20231008X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                var ps2 = GetParts(d2);
+                Assert.That(ps1, Has.Length.EqualTo(3));
+                Assert.That(ps1[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[2].Weight, Is.EqualTo(1000));
+                Assert.That(ps2, Has.Length.EqualTo(1));
+                Assert.That(ps2[0].Weight, Is.EqualTo(1000));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToLsNr(d1.Year, d1.DId, [850, 1000, -4], d2.LsNr));
+            d1 = await GetDelivery("20231008X001");
+            d2 = await GetDelivery("20231008X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                var ps2 = GetParts(d2);
+                Assert.That(ps1, Has.Length.EqualTo(2));
+                Assert.That(ps1[0].DPNr, Is.EqualTo(1));
+                Assert.That(ps1[0].Weight, Is.EqualTo(150));
+                Assert.That(ps1[1].DPNr, Is.EqualTo(3));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps2, Has.Length.EqualTo(3));
+                Assert.That(ps2[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps2[1].Weight, Is.EqualTo(850));
+                Assert.That(ps2[2].Weight, Is.EqualTo(1000));
+            });
+        }
+
+        [Test]
+        public async Task TestSplit_12_OtherDelivery_Complete() {
+            var d1 = await GetDelivery("20231009X001");
+            var d2 = await GetDelivery("20231009X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Not.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps1 = GetParts(d1);
+                var ps2 = GetParts(d2);
+                Assert.That(ps1, Has.Length.EqualTo(3));
+                Assert.That(ps1[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps1[2].Weight, Is.EqualTo(1000));
+                Assert.That(ps2, Has.Length.EqualTo(1));
+                Assert.That(ps2[0].Weight, Is.EqualTo(1000));
+            });
+
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.SplitDeliveryToLsNr(d1.Year, d1.DId, [1200, int.MaxValue, 1000], d2.LsNr));
+            d1 = await GetDelivery("20231009X001");
+            d2 = await GetDelivery("20231009X002");
+            Assert.Multiple(() => {
+                Assert.That(d1, Is.Null);
+                Assert.That(d2, Is.Not.Null);
+            });
+            Assert.Multiple(() => {
+                var ps2 = GetParts(d2);
+                Assert.That(ps2, Has.Length.EqualTo(4));
+                Assert.That(ps2[0].Weight, Is.EqualTo(1000));
+                Assert.That(ps2[1].Weight, Is.EqualTo(1000));
+                Assert.That(ps2[2].Weight, Is.EqualTo(1000));
+                Assert.That(ps2[3].Weight, Is.EqualTo(1000));
+            });
+        }
+
+        [Test]
+        public async Task TestDelete_01_Normal() {
+            using (var ctx = new AppDbContext()) {
+                Assert.That(await ctx.Deliveries.FindAsync(2022, 2), Is.Not.Null);
+            }
+            Assert.DoesNotThrowAsync(async () => await DeliveryService.DeleteDelivery("20220930X001"));
+            using (var ctx = new AppDbContext()) {
+                Assert.That(await ctx.Deliveries.FindAsync(2022, 2), Is.Null);
+            }
+        }
+    }
+}

Tests/UnitTests/ServiceTests/MemberServiceTest.cs

@@ -0,0 +1,361 @@
+using Elwig.Helpers;
+using Elwig.Models.Entities;
+using Elwig.Services;
+using Elwig.ViewModels;
+using Microsoft.EntityFrameworkCore;
+
+namespace Tests.UnitTests.ServiceTests {
+    [TestFixture]
+    public class MemberServiceTest {
+
+        private static async Task InitViewModel(MemberAdminViewModel vm) {
+            using var ctx = new AppDbContext();
+            vm.BranchSource = await ctx.Branches.ToListAsync();
+            vm.DefaultKgSource = await ctx.Katastralgemeinden.ToListAsync();
+            vm.OrtSource = await ctx.PlzDestinations.Include(p => p.Ort).ToListAsync();
+            vm.BillingOrtSource = await ctx.PlzDestinations.Include(p => p.Ort).ToListAsync();
+        }
+
+        [Test]
+        public async Task TestCreate_01_Minimal() {
+            var vm = new MemberAdminViewModel();
+            await InitViewModel(vm);
+            await vm.InitInputs();
+            vm.Name = "Neuling";
+            vm.GivenName = "Nadine";
+            vm.Address = "Neubaugasse 1";
+            vm.Plz = 2120;
+            vm.Ort = vm.OrtSource.First(d => d.Ort.Name == "Wolkersdorf im Weinviertel");
+            vm.BusinessShares = 1;
+            vm.DefaultKg = vm.DefaultKgSource.First(k => k.Name == "Wolkersdorf");
+
+            Assert.That(vm.MgNr, Is.EqualTo(205));
+            using (var ctx = new AppDbContext()) {
+                Assert.That(await ctx.Members.FindAsync(205), Is.Null);
+            }
+
+            Assert.DoesNotThrowAsync(async () => await vm.UpdateMember(null));
+
+            Member? m;
+            using (var ctx = new AppDbContext()) {
+                m = await ctx.Members
+                    .Where(m => m.MgNr == vm.MgNr)
+                    .Include(m => m.BillingAddress!.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.DefaultWbKg!.AtKg)
+                    .Include(m => m.EmailAddresses)
+                    .Include(m => m.TelephoneNumbers)
+                    .AsSplitQuery()
+                    .FirstOrDefaultAsync();
+            }
+
+            Assert.That(m, Is.Not.Null);
+            Assert.Multiple(() => {
+                Assert.That(m.MgNr, Is.EqualTo(205));
+                Assert.That(m.Name, Is.EqualTo("Neuling"));
+                Assert.That(m.GivenName, Is.EqualTo("Nadine"));
+                Assert.That(m.Address, Is.EqualTo("Neubaugasse 1"));
+                Assert.That(m.PostalDest.AtPlz?.Plz, Is.EqualTo(2120));
+                Assert.That(m.PostalDest.AtPlz?.Ort.Name, Is.EqualTo("Wolkersdorf im Weinviertel"));
+                Assert.That(m.BusinessShares, Is.EqualTo(1));
+                Assert.That(m.DefaultKg?.Name, Is.EqualTo("Wolkersdorf"));
+            });
+
+            vm = new MemberAdminViewModel();
+            await InitViewModel(vm);
+            Assert.DoesNotThrow(() => vm.FillInputs(m));
+            Assert.Multiple(() => {
+                Assert.That(vm.MgNr, Is.EqualTo(205));
+                Assert.That(vm.Name, Is.EqualTo("Neuling"));
+                Assert.That(vm.GivenName, Is.EqualTo("Nadine"));
+                Assert.That(vm.Address, Is.EqualTo("Neubaugasse 1"));
+                Assert.That(vm.Plz, Is.EqualTo(2120));
+                Assert.That(vm.Ort?.Ort.Name, Is.EqualTo("Wolkersdorf im Weinviertel"));
+                Assert.That(vm.BusinessShares, Is.EqualTo(1));
+                Assert.That(vm.DefaultKg?.Name, Is.EqualTo("Wolkersdorf"));
+            });
+        }
+
+        [Test]
+        public async Task TestCreate_02_Full() {
+            var vm = new MemberAdminViewModel();
+            await InitViewModel(vm);
+            await vm.InitInputs();
+
+            vm.MgNr = 999;
+            vm.IsJuridicalPerson = true;
+            vm.Name = "Neue GmbH";
+            vm.ForTheAttentionOf = "Norbert Neuling";
+            vm.Address = "Neuegasse 2";
+            vm.Plz = 2120;
+            vm.Ort = vm.OrtSource.First(d => d.Ort.Name == "Wolkersdorf im Weinviertel");
+
+            vm.EmailAddresses[0] = "neue.gmbh@mail.com";
+            vm.EmailAddresses[1] = "norbert.neuling@mail.com";
+            vm.PhoneNrs[0] = new(0, "+43 2245 9876", "Büro");
+            vm.PhoneNrs[1] = new(1, "+43 664 123456789", "Hr. Neuling");
+            vm.PhoneNrs[2] = new(2, "+43 2245 9876-2", null);
+
+            vm.Iban = "AT97 1234 5678 9012 3460";
+            vm.Bic = "RLNWATWWWDF";
+
+            vm.UstIdNr = "ATU12345693";
+            vm.LfbisNr = "0123498";
+            vm.IsBuchführend = true;
+            vm.IsOrganic = true;
+
+            vm.BillingName = "Neue Holding AG";
+            vm.BillingAddress = "Neuegasse 3";
+            vm.BillingPlz = 2120;
+            vm.BillingOrt = vm.BillingOrtSource.First(d => d.Ort.Name == "Wolkersdorf im Weinviertel");
+
+            vm.BusinessShares = 10;
+            vm.AccountingNr = "330999";
+            vm.DefaultKg = vm.DefaultKgSource.First(k => k.Name == "Wolkersdorf");
+            vm.Comment = "Ich bin eine Anmerkung";
+            vm.ContactViaPost = true;
+            vm.ContactViaEmail = true;
+            vm.IsVollLieferant = true;
+            vm.IsFunktionär = true;
+
+            using (var ctx = new AppDbContext()) {
+                Assert.That(await ctx.Members.FindAsync(999), Is.Null);
+            }
+
+            Assert.DoesNotThrowAsync(async () => await vm.UpdateMember(null));
+
+            Member? m;
+            using (var ctx = new AppDbContext()) {
+                m = await ctx.Members
+                    .Where(m => m.MgNr == vm.MgNr)
+                    .Include(m => m.BillingAddress!.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.DefaultWbKg!.AtKg)
+                    .Include(m => m.EmailAddresses)
+                    .Include(m => m.TelephoneNumbers)
+                    .AsSplitQuery()
+                    .FirstOrDefaultAsync();
+            }
+
+            Assert.That(m, Is.Not.Null);
+            Assert.Multiple(() => {
+                Assert.That(m.MgNr, Is.EqualTo(999));
+                Assert.That(m.IsJuridicalPerson, Is.True);
+                Assert.That(m.Name, Is.EqualTo("Neue GmbH"));
+                Assert.That(m.ForTheAttentionOf, Is.EqualTo("Norbert Neuling"));
+                Assert.That(m.Address, Is.EqualTo("Neuegasse 2"));
+                Assert.That(m.PostalDest.AtPlz?.Plz, Is.EqualTo(2120));
+                Assert.That(m.PostalDest.AtPlz?.Ort.Name, Is.EqualTo("Wolkersdorf im Weinviertel"));
+
+                Assert.That(m.EmailAddresses.Select(a => (a.Nr, a.Address)), Is.EquivalentTo(new (int, string)[] {
+                    (1, "neue.gmbh@mail.com"),
+                    (2, "norbert.neuling@mail.com"),
+                }));
+                Assert.That(m.TelephoneNumbers.Select(n => (n.Nr, n.Type, n.Number, n.Comment)), Is.EquivalentTo(new (int, string, string, string?)[] {
+                    (1, "landline", "+43 2245 9876", "Büro"),
+                    (2, "mobile", "+43 664 123456789", "Hr. Neuling"),
+                    (3, "fax", "+43 2245 9876-2", null),
+                }));
+
+                Assert.That(m.Iban, Is.EqualTo("AT971234567890123460"));
+                Assert.That(m.Bic, Is.EqualTo("RLNWATWWWDF"));
+
+                Assert.That(m.UstIdNr, Is.EqualTo("ATU12345693"));
+                Assert.That(m.LfbisNr, Is.EqualTo("0123498"));
+                Assert.That(m.IsBuchführend, Is.True);
+                Assert.That(m.IsOrganic, Is.True);
+
+                Assert.That(m.BillingAddress, Is.Not.Null);
+                Assert.That(m.BillingAddress?.FullName, Is.EqualTo("Neue Holding AG"));
+                Assert.That(m.BillingAddress?.Address, Is.EqualTo("Neuegasse 3"));
+                Assert.That(m.BillingAddress?.PostalDest.AtPlz?.Plz, Is.EqualTo(2120));
+                Assert.That(m.BillingAddress?.PostalDest.AtPlz?.Ort.Name, Is.EqualTo("Wolkersdorf im Weinviertel"));
+
+                Assert.That(m.BusinessShares, Is.EqualTo(10));
+                Assert.That(m.AccountingNr, Is.EqualTo("330999"));
+                Assert.That(m.DefaultKg?.Name, Is.EqualTo("Wolkersdorf"));
+                Assert.That(m.Comment, Is.EqualTo("Ich bin eine Anmerkung"));
+                Assert.That(m.ContactViaPost, Is.True);
+                Assert.That(m.ContactViaEmail, Is.True);
+                Assert.That(m.IsVollLieferant, Is.True);
+                Assert.That(m.IsFunktionär, Is.True);
+            });
+
+            vm = new MemberAdminViewModel();
+            await InitViewModel(vm);
+            Assert.DoesNotThrow(() => vm.FillInputs(m));
+            Assert.Multiple(() => {
+                Assert.That(vm.MgNr, Is.EqualTo(999));
+                Assert.That(vm.IsJuridicalPerson, Is.True);
+                Assert.That(vm.Name, Is.EqualTo("Neue GmbH"));
+                Assert.That(vm.ForTheAttentionOf, Is.EqualTo("Norbert Neuling"));
+                Assert.That(vm.Address, Is.EqualTo("Neuegasse 2"));
+                Assert.That(vm.Plz, Is.EqualTo(2120));
+                Assert.That(vm.Ort?.Ort.Name, Is.EqualTo("Wolkersdorf im Weinviertel"));
+
+                Assert.That(vm.EmailAddresses, Is.EquivalentTo(new string?[] {
+                    "neue.gmbh@mail.com",
+                    "norbert.neuling@mail.com",
+                    null, null, null, null, null, null, null
+                }));
+                Assert.That(vm.PhoneNrs, Is.EquivalentTo(new MemberAdminViewModel.PhoneNr?[] {
+                    new(0, "+43 2245 9876", "Büro"),
+                    new(1, "+43 664 123456789", "Hr. Neuling"),
+                    new(2, "+43 2245 9876-2", null),
+                    new(), new(), new(), new(), new(), new()
+                }));
+
+                Assert.That(vm.Iban, Is.EqualTo("AT971234567890123460"));
+                Assert.That(vm.Bic, Is.EqualTo("RLNWATWWWDF"));
+
+                Assert.That(vm.UstIdNr, Is.EqualTo("ATU12345693"));
+                Assert.That(vm.LfbisNr, Is.EqualTo("0123498"));
+                Assert.That(vm.IsBuchführend, Is.True);
+                Assert.That(vm.IsOrganic, Is.True);
+
+                Assert.That(vm.BillingName, Is.EqualTo("Neue Holding AG"));
+                Assert.That(vm.BillingAddress, Is.EqualTo("Neuegasse 3"));
+                Assert.That(vm.BillingPlz, Is.EqualTo(2120));
+                Assert.That(vm.BillingOrt?.Ort.Name, Is.EqualTo("Wolkersdorf im Weinviertel"));
+
+                Assert.That(vm.BusinessShares, Is.EqualTo(10));
+                Assert.That(vm.AccountingNr, Is.EqualTo("330999"));
+                Assert.That(vm.DefaultKg?.Name, Is.EqualTo("Wolkersdorf"));
+                Assert.That(vm.Comment, Is.EqualTo("Ich bin eine Anmerkung"));
+                Assert.That(vm.ContactViaPost, Is.True);
+                Assert.That(vm.ContactViaEmail, Is.True);
+                Assert.That(vm.IsVollLieferant, Is.True);
+                Assert.That(vm.IsFunktionär, Is.True);
+            });
+        }
+
+        [Test]
+        public async Task TestUpdate_01_Inactive() {
+            var vm = new MemberAdminViewModel();
+            await InitViewModel(vm);
+            using (var ctx = new AppDbContext()) {
+                vm.FillInputs(await ctx.Members
+                    .Where(m => m.MgNr == 202)
+                    .Include(m => m.BillingAddress!.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.DefaultWbKg!.AtKg)
+                    .Include(m => m.EmailAddresses)
+                    .Include(m => m.TelephoneNumbers)
+                    .AsSplitQuery()
+                    .FirstAsync());
+            }
+
+            Assert.That(vm.IsActive, Is.True);
+
+            var exitDate = DateTime.Now;
+            vm.IsActive = false;
+            vm.ExitDate = $"{exitDate:dd.MM.yyyy}";
+
+            Assert.DoesNotThrowAsync(async () => await vm.UpdateMember(202));
+
+            Member? m;
+            using (var ctx = new AppDbContext()) {
+                m = await ctx.Members
+                    .Where(m => m.MgNr == 202)
+                    .Include(m => m.BillingAddress!.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.DefaultWbKg!.AtKg)
+                    .Include(m => m.EmailAddresses)
+                    .Include(m => m.TelephoneNumbers)
+                    .AsSplitQuery()
+                    .FirstOrDefaultAsync();
+            }
+
+            Assert.That(m, Is.Not.Null);
+            Assert.Multiple(() => {
+                Assert.That(m.IsActive, Is.False);
+                Assert.That(m.ExitDateString, Is.EqualTo($"{exitDate:yyyy-MM-dd}"));
+            });
+
+            vm = new MemberAdminViewModel();
+            await InitViewModel(vm);
+            Assert.DoesNotThrow(() => vm.FillInputs(m));
+            Assert.Multiple(() => {
+                Assert.That(vm.IsActive, Is.False);
+                Assert.That(vm.ExitDate, Is.EqualTo($"{exitDate:dd.MM.yyyy}"));
+            });
+        }
+
+        [Test]
+        public async Task TestUpdate_02_MgNr() {
+            var vm = new MemberAdminViewModel();
+            await InitViewModel(vm);
+            using (var ctx = new AppDbContext()) {
+                vm.FillInputs(await ctx.Members
+                    .Where(m => m.MgNr == 203)
+                    .Include(m => m.BillingAddress!.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.DefaultWbKg!.AtKg)
+                    .Include(m => m.EmailAddresses)
+                    .Include(m => m.TelephoneNumbers)
+                    .AsSplitQuery()
+                    .FirstAsync());
+            }
+
+            Assert.Multiple(() => {
+                Assert.That(vm.MgNr, Is.EqualTo(203));
+                Assert.That(vm.EmailAddresses[0], Is.Not.Null);
+                Assert.That(vm.PhoneNrs[0], Is.Not.Null);
+                Assert.That(vm.BillingName, Is.Not.Null);
+            });
+            vm.MgNr = 210;
+            Assert.DoesNotThrowAsync(async () => await vm.UpdateMember(203));
+
+            Member? m;
+            using (var ctx = new AppDbContext()) {
+                m = await ctx.Members
+                    .Where(m => m.MgNr == 210)
+                    .Include(m => m.BillingAddress!.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.PostalDest.AtPlz!.Ort)
+                    .Include(m => m.DefaultWbKg!.AtKg)
+                    .Include(m => m.EmailAddresses)
+                    .Include(m => m.TelephoneNumbers)
+                    .AsSplitQuery()
+                    .FirstOrDefaultAsync();
+            }
+
+            Assert.That(m, Is.Not.Null);
+            vm = new MemberAdminViewModel();
+            await InitViewModel(vm);
+            Assert.DoesNotThrow(() => vm.FillInputs(m));
+            Assert.Multiple(() => {
+                Assert.That(vm.MgNr, Is.EqualTo(210));
+                Assert.That(vm.EmailAddresses[0], Is.Not.Null);
+                Assert.That(vm.PhoneNrs[0], Is.Not.Null);
+                Assert.That(vm.BillingName, Is.Not.Null);
+            });
+        }
+
+        [Test]
+        public async Task TestDelete_01_NoReferences() {
+            using (var ctx = new AppDbContext()) {
+                Assert.That(await ctx.Members.FindAsync(201), Is.Not.Null);
+            }
+            Assert.DoesNotThrowAsync(async () => await MemberService.DeleteMember(201, false, false, false));
+            using (var ctx = new AppDbContext()) {
+                Assert.That(await ctx.Members.FindAsync(201), Is.Null);
+            }
+        }
+
+        [Test]
+        public async Task TestDelete_02_AllReferences() {
+            using (var ctx = new AppDbContext()) {
+                Assert.That(await ctx.Members.FindAsync(204), Is.Not.Null);
+            }
+            for (int i = 0; i < 7; i++) {
+                Assert.ThrowsAsync<DbUpdateException>(async () => await MemberService.DeleteMember(204, (i & 1) != 0, (i & 2) != 0, (i & 4) != 0));
+                using var ctx = new AppDbContext();
+                Assert.That(await ctx.Members.FindAsync(204), Is.Not.Null);
+            }
+            Assert.DoesNotThrowAsync(async () => await MemberService.DeleteMember(204, true, true, true));
+            using (var ctx = new AppDbContext()) {
+                Assert.That(await ctx.Members.FindAsync(204), Is.Null);
+            }
+        }
+    }
+}

Tests/UnitTests/ServiceTests/Setup.cs

@@ -0,0 +1,25 @@
+using Elwig.Helpers;
+using System.Reflection;
+using Microsoft.Data.Sqlite;
+
+namespace Tests.UnitTests.ServiceTests {
+    [SetUpFixture]
+    public class Setup {
+
+        private SqliteConnection? Connection;
+
+        [OneTimeSetUp]
+        public async Task SetupDatabase() {
+            Connection = await AppDbContext.ConnectAsync();
+            await AppDbContext.ExecuteEmbeddedScript(Connection, Assembly.GetExecutingAssembly(), "Tests.Resources.Sql.ServiceInsert.sql");
+        }
+
+        [OneTimeTearDown]
+        public async Task TeardownDatabase() {
+            if (Connection == null) return;
+            await AppDbContext.ExecuteEmbeddedScript(Connection, Assembly.GetExecutingAssembly(), "Tests.Resources.Sql.ServiceDelete.sql");
+            await Connection.DisposeAsync();
+            Connection = null;
+        }
+    }
+}

Tests/UnitTests/WeighingTests/MockScale.cs

@@ -0,0 +1,110 @@
+using System.Net.Sockets;
+using System.Net;
+using System.Text;
+
+namespace Tests.UnitTests.WeighingTests {
+    public abstract class MockScale : IDisposable {
+
+        protected readonly TcpListener Server;
+
+        public int IdentNr { get; set; } = 0;
+        public int Tare { get; set; } = 0;
+        public int Weight { get; set; } = 0;
+        public string? Error { get; set; } = null;
+
+        protected MockScale(int port) {
+            Server = new TcpListener(IPAddress.Loopback, port);
+            Server.Start(4);
+        }
+
+        public void Dispose() {
+            Server.Dispose();
+            GC.SuppressFinalize(this);
+        }
+    }
+
+    public class CommandMockScale : MockScale {
+
+        private readonly Func<string, int, int, string?, int, (string, bool)> Handler;
+        private readonly Thread ServerThread;
+        private bool IsRunning = true;
+
+        public CommandMockScale(int port, Func<string, int, int, string?, int, (string, bool)> handler) :
+            base(port) {
+            Handler = handler;
+            ServerThread = new Thread(new ParameterizedThreadStart(Serve));
+            ServerThread.Start();
+        }
+
+        private async void Serve(object? parameters) {
+            byte[] buffer = new byte[16];
+            while (IsRunning) {
+                try {
+                    using var client = await Server.AcceptTcpClientAsync();
+                    if (client == null) continue;
+                    using var stream = client.GetStream();
+                    while (true) {
+                        int read = await stream.ReadAsync(buffer);
+                        var (res, inc) = Handler(Encoding.ASCII.GetString(buffer, 0, read), Weight, Tare, Error, IdentNr + 1);
+                        if (inc) IdentNr++;
+                        await stream.WriteAsync(Encoding.ASCII.GetBytes(res));
+                    }
+                } catch (Exception) {
+                    // ignore
+                }
+            }
+        }
+
+        public new void Dispose() {
+            IsRunning = false;
+            ServerThread.Interrupt();
+            ServerThread.Join();
+            base.Dispose();
+        }
+    }
+
+    public class EventMockScale : MockScale {
+
+        private readonly Func<int, int, string?, int, (string, bool)> Handler;
+        private readonly Thread ServerThread;
+        private TcpClient? Client;
+        private bool IsRunning = true;
+
+        public EventMockScale(int port, Func<int, int, string?, int, (string, bool)> handler) :
+            base(port) {
+            Handler = handler;
+            ServerThread = new Thread(new ParameterizedThreadStart(Serve));
+            ServerThread.Start();
+        }
+
+        private async void Serve(object? parameters) {
+            while (IsRunning) {
+                try {
+                    Client = await Server.AcceptTcpClientAsync();
+                } catch (Exception) {
+                    // ignore
+                }
+            }
+        }
+
+        public async Task Weigh(int weight, int tare = 0) {
+            Weight = weight;
+            Tare = tare;
+            await Weigh();
+        }
+
+        public async Task Weigh() {
+            var (res, inc) = Handler(Weight, Tare, Error, IdentNr + 1);
+            if (inc) IdentNr++;
+            await Client!.GetStream().WriteAsync(Encoding.ASCII.GetBytes(res));
+        }
+
+        public new void Dispose() {
+            Client?.Dispose();
+            IsRunning = false;
+            ServerThread.Interrupt();
+            ServerThread.Join();
+            base.Dispose();
+        }
+    }
+}

Tests/UnitTests/WeighingTests/ScaleHandlers.cs

@@ -0,0 +1,181 @@
+namespace Tests.UnitTests.WeighingTests {
+    public static class ScaleHandlers {
+
+        public static (string, bool) Handle_IT3000A(string req, int weight, int tare, string? error, int identNr) {
+            var modes = error?.Split(';') ?? [];
+            var overloaded = modes.Contains("overloaded");
+            var moving = modes.Contains("moving");
+            var invalid = modes.Contains("invalid");
+            var crc = modes.Contains("crc");
+            var unit = modes.Contains("unit");
+
+            Thread.Sleep(100);
+
+            if (invalid) {
+                return ("abcd\r\n", false);
+            } else if (!req.StartsWith('<') || !req.EndsWith('>')) {
+                return ("<31>\r\n", false);
+            }
+            req = req[1..^1];
+
+            bool incr;
+            if (req.Length > 3) {
+                return ("<32>\r\n", false);
+            } else if (req.StartsWith("RN")) {
+                incr = true;
+            } else if (req.StartsWith("RM")) {
+                incr = false;
+            } else {
+                return ("<32>\r\n", false);
+            }
+
+            if (overloaded) {
+                return ("<12>\r\n", false);
+            } else if (weight == 0) {
+                incr = false;
+            }
+
+            if (moving && incr)
+                return ("<13>\r\n", false);
+
+            string data = $"00{(moving ? 1 : 0)}0{new DateTime(2020, 10, 15, 12, 34, 0):dd.MM.yyHH:mm}{(incr ? identNr : 0),4}1" +
+                $"{weight + tare,8}{tare,8}{weight,8}{(unit ? "lb" : "kg")}   {"1",3}";
+            ushort checksum = Elwig.Helpers.Utils.CalcCrc16Modbus(data);
+            if (crc) checksum += 10;
+            return ($"<{data}{checksum,8}>\r\n", incr);
+        }
+
+        public static (string, bool) Handle_IT6000E(string req, int weight, int tare, string? error, int identNr, string terminalNr) {
+            var modes = error?.Split(';') ?? [];
+            var overloaded = modes.Contains("overloaded");
+            var moving = modes.Contains("moving");
+            var invalid = modes.Contains("invalid");
+            var crc = modes.Contains("crc");
+            var unit = modes.Contains("unit");
+
+            if (invalid) {
+                return ("abcd\r\n", false);
+            } else if (!req.StartsWith('<') || !req.EndsWith('>')) {
+                return ("<31>\r\n", false);
+            }
+            req = req[1..^1];
+
+            bool incr;
+            if (req.Length > 3) {
+                return ("<32>\r\n", false);
+            } else if (req.StartsWith("RN")) {
+                incr = true;
+            } else if (req.StartsWith("RM")) {
+                incr = false;
+            } else {
+                return ("<32>\r\n", false);
+            }
+
+            if (overloaded)
+                return ("<12>\r\n", false);
+
+            if (moving && incr)
+                return ("<13>\r\n", false);
+
+            string data = $"00{(moving ? 1 : 0)}0{new DateTime(2020, 10, 8, 8, 47, 0):dd.MM.yyHH:mm}{(incr ? identNr : 0),4}1" +
+                $"{weight + tare,8}{tare,8}{weight,8}{(unit ? "lb" : "kg")}   {terminalNr,3}";
+            ushort checksum = Elwig.Helpers.Utils.CalcCrc16Modbus(data);
+            if (crc) checksum += 10;
+            return ($"<{data}{checksum,8}>\r\n", incr);
+        }
+
+        public static (string, bool) Handle_L246(string req, int weight, int tare, string? error, int identNr) {
+            var modes = error?.Split(';') ?? [];
+            var overloaded = modes.Contains("overloaded");
+            var moving = modes.Contains("moving");
+            var invalid = modes.Contains("invalid");
+            var crc = modes.Contains("crc");
+            var unit = modes.Contains("unit");
+
+            Thread.Sleep(100);
+
+            if (invalid) {
+                return ("abcd\r\n", false);
+            } else if (!req.StartsWith('<') || !req.EndsWith('>')) {
+                return ("<31>\r\n", false);
+            }
+            req = req[1..^1];
+
+            bool incr;
+            if (req.Length > 3) {
+                return ("<32>\r\n", false);
+            } else if (req.StartsWith("RN")) {
+                incr = true;
+            } else if (req.StartsWith("RM")) {
+                incr = false;
+            } else {
+                return ("<32>\r\n", false);
+            }
+
+            if (overloaded)
+                return ("<12>\r\n", false);
+
+            if (moving && incr)
+                return ("<13>\r\n", false);
+
+            string data = $"00{(moving ? 1 : 0)}0{new DateTime(2020, 10, 17, 14, 23, 0):dd.MM.yyHH:mm}{(incr ? identNr : 0),4}1" +
+                $"{weight + tare,8}{tare,8}{weight,8}{(unit ? "lb" : "kg")}   {"001",3}";
+            ushort checksum = Elwig.Helpers.Utils.CalcCrc16Modbus(data);
+            if (crc) checksum += 10;
+            return ($"<{data}{checksum,8}>\r\n", incr);
+        }
+
+        public static (string, bool) HandleDMA02(string req, int weight, int tare, string? error, int identNr) {
+            var modes = error?.Split(';') ?? [];
+            var overloaded = modes.Contains("overloaded");
+            var moving = modes.Contains("moving");
+            var invalid = modes.Contains("invalid");
+
+            Thread.Sleep(100);
+
+            if (invalid) {
+                return ("abcd\x03", false);
+            } else if (req != "\x05" && req != "?") {
+                return ("\x0002ES\x03", false);
+            }
+
+            bool incr;
+            if (req == "?") {
+                incr = false;
+            } else {
+                incr = true;
+            }
+
+            if (overloaded) {
+                return ("\x0002ES\x03", false);
+            } else if (weight == 0) {
+                incr = false;
+            }
+
+            if (moving && incr)
+                return ("\x0002EM\x03", false);
+
+            string data = $" {(moving ? "M" : "S")}{weight + tare,7}{tare,7}{weight,7} 1{(incr ? identNr : 0),6}{new DateTime(2020, 10, 15, 12, 34, 0):yyyyMMddHHmmss}";
+            return ($"\x0002{data}\x03", incr);
+        }
+
+        public static (string, bool) HandleDMA03Baby(string req, int weight, int tare, string? error, int identNr) {
+            return HandleDMA02(req, weight, tare, error, identNr);
+        }
+
+        public static (string, bool) Handle_L320(int weight, int tare, string? error, int identNr) {
+            var modes = error?.Split(';') ?? [];
+            var invalid = modes.Contains("invalid");
+            var unit = modes.Contains("unit");
+
+            Thread.Sleep(100);
+
+            if (invalid) {
+                return ("abcd", false);
+            }
+
+            bool incr = true;
+            return ($" {new DateTime(2020, 9, 28, 9, 8, 0):dd.MM.yy HH:mm} {identNr,4} {weight,9}{(unit ? "lb" : "kg")} ", incr);
+        }
+    }
+}

Tests/UnitTests/WeighingTests/ScaleTestBadenL320.cs

@@ -0,0 +1,56 @@
+using Elwig.Helpers.Weighing;
+
+namespace Tests.UnitTests.WeighingTests {
+    [TestFixture]
+    public class ScaleTestBadenL320 {
+
+        private EventMockScale Mock;
+        private AveryEventScale Scale;
+
+        [OneTimeSetUp]
+        public void SetupScale() {
+            Mock = new EventMockScale(12345, ScaleHandlers.Handle_L320);
+            Scale = new("1", "L320", "tcp://127.0.0.1:12345");
+        }
+
+        [OneTimeTearDown]
+        public void TeardownScale() {
+            Mock.Dispose();
+            Scale.Dispose();
+        }
+
+        [SetUp]
+        public void ResetScale() {
+            Mock.IdentNr = 0;
+            Mock.Weight = 0;
+            Mock.Error = null;
+        }
+
+        [Test]
+        public async Task Test_01_Normal() {
+            WeighingResult? res = null;
+            Scale.WeighingEvent += (sender, evt) => {
+                res = evt.Result;
+            };
+
+            await Mock.Weigh(2345);
+            await Task.Delay(100);
+            Assert.That(res, Is.Not.Null);
+            Assert.That(res, Is.EqualTo(new WeighingResult {
+                NetWeight = 2345,
+                WeighingId = "1", FullWeighingId = $"2020-09-28/1",
+                Date = new DateOnly(2020, 9, 28), Time = new TimeOnly(9, 8),
+            }));
+
+            await Mock.Weigh(4215);
+            await Task.Delay(100);
+            Assert.That(res, Is.Not.Null);
+            Assert.That(res, Is.EqualTo(new WeighingResult {
+                NetWeight = 4215,
+                WeighingId = "2", FullWeighingId = $"2020-09-28/2",
+                Date = new DateOnly(2020, 9, 28),
+                Time = new TimeOnly(9, 8),
+            }));
+        }
+    }
+}

Tests/UnitTests/WeighingTests/ScaleTestGrInzersdorfL246.cs

@@ -0,0 +1,108 @@
+using Elwig.Helpers.Weighing;
+
+namespace Tests.UnitTests.WeighingTests {
+    [TestFixture]
+    class ScaleTestGrInzersdorfL246 {
+
+        private MockScale Mock;
+        private SysTecITScale Scale;
+
+        [OneTimeSetUp]
+        public void SetupScale() {
+            Mock = new CommandMockScale(12345, ScaleHandlers.Handle_L246);
+            Scale = new("1", "L246", "tcp://127.0.0.1:12345");
+        }
+
+        [OneTimeTearDown]
+        public void TeardownScale() {
+            Mock.Dispose();
+            Scale.Dispose();
+        }
+
+        [SetUp]
+        public void ResetScale() {
+            Mock.IdentNr = 0;
+            Mock.Weight = 0;
+            Mock.Error = null;
+        }
+
+        [Test]
+        public async Task Test_01_CurrentWeight() {
+            Mock.Weight = 1235;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1235, TareWeight = 0, NetWeight = 1235,
+                Date = new DateOnly(2020, 10, 17), Time = new TimeOnly(14, 23),
+            }));
+            Mock.Weight = 1240;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1240, TareWeight = 0, NetWeight = 1240,
+                Date = new DateOnly(2020, 10, 17), Time = new TimeOnly(14, 23),
+            }));
+            Mock.Weight = 1245;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1245, TareWeight = 0, NetWeight = 1245,
+                Date = new DateOnly(2020, 10, 17), Time = new TimeOnly(14, 23),
+            }));
+        }
+
+        [Test]
+        public async Task Test_02_Normal() {
+            Mock.Weight = 1235;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1235, TareWeight = 0, NetWeight = 1235,
+                WeighingId = "1", FullWeighingId = $"2020-10-17/1",
+                Date = new DateOnly(2020, 10, 17), Time = new TimeOnly(14, 23),
+            }));
+            Mock.Weight = 3335;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 3335, TareWeight = 0, NetWeight = 3335,
+                WeighingId = "2", FullWeighingId = $"2020-10-17/2",
+                Date = new DateOnly(2020, 10, 17), Time = new TimeOnly(14, 23),
+            }));
+            Mock.Weight = 6420;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 6420, TareWeight = 0, NetWeight = 6420,
+                WeighingId = "3", FullWeighingId = $"2020-10-17/3",
+                Date = new DateOnly(2020, 10, 17), Time = new TimeOnly(14, 23),
+            }));
+        }
+
+        [Test]
+        public void Test_03_Moving() {
+            Mock.Weight = 1_000;
+            Mock.Error = "moving";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+            Assert.That(ex.Message, Contains.Substring("Waage in Bewegung"));
+        }
+
+        [Test]
+        public void Test_04_Overloaded() {
+            Mock.Weight = 10_000;
+            Mock.Error = "overloaded";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+            Assert.That(ex.Message, Contains.Substring("Waage in Überlast"));
+        }
+
+        [Test]
+        public void Test_05_InvalidResponse() {
+            Mock.Weight = 1_000;
+            Mock.Error = "invalid";
+            Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+        }
+
+        [Test]
+        public void Test_06_InvalidCrc() {
+            Mock.Weight = 1_000;
+            Mock.Error = "crc";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+            Assert.That(ex.Message, Contains.Substring("Invalid CRC16 checksum"));
+        }
+
+        [Test]
+        public void Test_07_InvalidUnit() {
+            Mock.Weight = 1_000;
+            Mock.Error = "unit";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+        }
+    }
+}

Tests/UnitTests/WeighingTests/ScaleTestHaugsdorfDMA02.cs

@@ -0,0 +1,115 @@
+using Elwig.Helpers.Weighing;
+
+namespace Tests.UnitTests.WeighingTests {
+    [TestFixture]
+    public class ScaleTestHaugsdorfDMA02 {
+
+        private MockScale Mock;
+        private GassnerScale Scale;
+
+        [OneTimeSetUp]
+        public void SetupScale() {
+            Mock = new CommandMockScale(12345, ScaleHandlers.HandleDMA02);
+            Scale = new("1", "DMA02", "tcp://127.0.0.1:12345");
+        }
+
+        [OneTimeTearDown]
+        public void TeardownScale() {
+            Mock.Dispose();
+            Scale.Dispose();
+        }
+
+        [SetUp]
+        public void ResetScale() {
+            Mock.IdentNr = 0;
+            Mock.Weight = 0;
+            Mock.Tare = 0;
+            Mock.Error = null;
+        }
+
+        [Test]
+        public async Task Test_01_CurrentWeight() {
+            Mock.Weight = 1234;
+            Mock.Tare = 0;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1234,
+                TareWeight = 0,
+                NetWeight = 1234,
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 1235;
+            Mock.Tare = 46;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1281,
+                TareWeight = 46,
+                NetWeight = 1235,
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 1236;
+            Mock.Tare = 92;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1328,
+                TareWeight = 92,
+                NetWeight = 1236,
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+        }
+
+        [Test]
+        public async Task Test_02_Normal() {
+            Mock.Weight = 1234;
+            Mock.Tare = 92;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1326,
+                TareWeight = 92,
+                NetWeight = 1234,
+                WeighingId = "1",
+                FullWeighingId = "1",
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 3333;
+            Mock.Tare = 41;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 3374,
+                TareWeight = 41,
+                NetWeight = 3333,
+                WeighingId = "2",
+                FullWeighingId = "2",
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 4321;
+            Mock.Tare = 0;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 4321,
+                TareWeight = 0,
+                NetWeight = 4321,
+                WeighingId = "3",
+                FullWeighingId = "3",
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+        }
+
+        [Test]
+        public void Test_03_Moving() {
+            Mock.Weight = 1_000;
+            Mock.Tare = 41;
+            Mock.Error = "moving";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+            Assert.That(ex.Message, Contains.Substring("Waage in Bewegung"));
+        }
+
+        [Test]
+        public void Test_04_InvalidResponse() {
+            Mock.Weight = 1_000;
+            Mock.Tare = 41;
+            Mock.Error = "invalid";
+            Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+        }
+    }
+}

Tests/UnitTests/WeighingTests/ScaleTestMatzenIT3000A.cs

@@ -0,0 +1,108 @@
+using Elwig.Helpers.Weighing;
+
+namespace Tests.UnitTests.WeighingTests {
+    [TestFixture]
+    class ScaleTestMatzenIT3000A {
+
+        private MockScale Mock;
+        private SysTecITScale Scale;
+
+        [OneTimeSetUp]
+        public void SetupScale() {
+            Mock = new CommandMockScale(12345, ScaleHandlers.Handle_IT3000A);
+            Scale = new("1", "IT3000A", "tcp://127.0.0.1:12345");
+        }
+
+        [OneTimeTearDown]
+        public void TeardownScale() {
+            Mock.Dispose();
+            Scale.Dispose();
+        }
+
+        [SetUp]
+        public void ResetScale() {
+            Mock.IdentNr = 0;
+            Mock.Weight = 0;
+            Mock.Error = null;
+        }
+
+        [Test]
+        public async Task Test_01_CurrentWeight() {
+            Mock.Weight = 1234;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1234, TareWeight = 0, NetWeight = 1234,
+                Date = new DateOnly(2020, 10, 15), Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 1235;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1235, TareWeight = 0, NetWeight = 1235,
+                Date = new DateOnly(2020, 10, 15), Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 1236;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1236, TareWeight = 0, NetWeight = 1236,
+                Date = new DateOnly(2020, 10, 15), Time = new TimeOnly(12, 34),
+            }));
+        }
+
+        [Test]
+        public async Task Test_02_Normal() {
+            Mock.Weight = 1234;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1234, TareWeight = 0, NetWeight = 1234,
+                WeighingId = "1", FullWeighingId = $"2020-10-15/1",
+                Date = new DateOnly(2020, 10, 15), Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 3333;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 3333, TareWeight = 0, NetWeight = 3333,
+                WeighingId = "2", FullWeighingId = $"2020-10-15/2",
+                Date = new DateOnly(2020, 10, 15), Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 4321;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 4321, TareWeight = 0, NetWeight = 4321,
+                WeighingId = "3", FullWeighingId = $"2020-10-15/3",
+                Date = new DateOnly(2020, 10, 15), Time = new TimeOnly(12, 34),
+            }));
+        }
+
+        [Test]
+        public void Test_03_Moving() {
+            Mock.Weight = 1_000;
+            Mock.Error = "moving";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+            Assert.That(ex.Message, Contains.Substring("Waage in Bewegung"));
+        }
+
+        [Test]
+        public void Test_04_Overloaded() {
+            Mock.Weight = 10_000;
+            Mock.Error = "overloaded";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+            Assert.That(ex.Message, Contains.Substring("Waage in Überlast"));
+        }
+
+        [Test]
+        public void Test_05_InvalidResponse() {
+            Mock.Weight = 1_000;
+            Mock.Error = "invalid";
+            Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+        }
+
+        [Test]
+        public void Test_06_InvalidCrc() {
+            Mock.Weight = 1_000;
+            Mock.Error = "crc";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+            Assert.That(ex.Message, Contains.Substring("Invalid CRC16 checksum"));
+        }
+
+        [Test]
+        public void Test_07_InvalidUnit() {
+            Mock.Weight = 1_000;
+            Mock.Error = "unit";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+        }
+    }
+}

Tests/UnitTests/WeighingTests/ScaleTestSitzendorfDMA03Baby.cs

@@ -0,0 +1,115 @@
+using Elwig.Helpers.Weighing;
+
+namespace Tests.UnitTests.WeighingTests {
+    [TestFixture]
+    public class ScaleTestSitzendorfDMA03Baby {
+
+        private MockScale Mock;
+        private GassnerScale Scale;
+
+        [OneTimeSetUp]
+        public void SetupScale() {
+            Mock = new CommandMockScale(12345, ScaleHandlers.HandleDMA03Baby);
+            Scale = new("1", "DMA03-baby", "tcp://127.0.0.1:12345");
+        }
+
+        [OneTimeTearDown]
+        public void TeardownScale() {
+            Mock.Dispose();
+            Scale.Dispose();
+        }
+
+        [SetUp]
+        public void ResetScale() {
+            Mock.IdentNr = 0;
+            Mock.Weight = 0;
+            Mock.Tare = 0;
+            Mock.Error = null;
+        }
+
+        [Test]
+        public async Task Test_01_CurrentWeight() {
+            Mock.Weight = 1234;
+            Mock.Tare = 0;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1234,
+                TareWeight = 0,
+                NetWeight = 1234,
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 1235;
+            Mock.Tare = 46;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1281,
+                TareWeight = 46,
+                NetWeight = 1235,
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 1236;
+            Mock.Tare = 92;
+            Assert.That(await Scale!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1328,
+                TareWeight = 92,
+                NetWeight = 1236,
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+        }
+
+        [Test]
+        public async Task Test_02_Normal() {
+            Mock.Weight = 1234;
+            Mock.Tare = 92;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1326,
+                TareWeight = 92,
+                NetWeight = 1234,
+                WeighingId = "1",
+                FullWeighingId = "1",
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 3333;
+            Mock.Tare = 41;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 3374,
+                TareWeight = 41,
+                NetWeight = 3333,
+                WeighingId = "2",
+                FullWeighingId = "2",
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+            Mock.Weight = 4321;
+            Mock.Tare = 0;
+            Assert.That(await Scale!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 4321,
+                TareWeight = 0,
+                NetWeight = 4321,
+                WeighingId = "3",
+                FullWeighingId = "3",
+                Date = new DateOnly(2020, 10, 15),
+                Time = new TimeOnly(12, 34),
+            }));
+        }
+
+        [Test]
+        public void Test_03_Moving() {
+            Mock.Weight = 1_000;
+            Mock.Tare = 41;
+            Mock.Error = "moving";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+            Assert.That(ex.Message, Contains.Substring("Waage in Bewegung"));
+        }
+
+        [Test]
+        public void Test_04_InvalidResponse() {
+            Mock.Weight = 1_000;
+            Mock.Tare = 41;
+            Mock.Error = "invalid";
+            Assert.ThrowsAsync<IOException>(async () => await Scale!.Weigh());
+        }
+    }
+}

Tests/UnitTests/WeighingTests/ScaleTestWolkersdorfIT6000E.cs

@@ -0,0 +1,128 @@
+using Elwig.Helpers.Weighing;
+
+namespace Tests.UnitTests.WeighingTests {
+    [TestFixture]
+    class ScaleTestWolkersdorfIT6000E {
+
+        private MockScale MockA;
+        private MockScale MockB;
+        private SysTecITScale ScaleA;
+        private SysTecITScale ScaleB;
+
+        [OneTimeSetUp]
+        public void SetupScale() {
+            MockA = new CommandMockScale(12345, (req, weight, tare, error, identNr) => ScaleHandlers.Handle_IT6000E(req, weight, tare, error, identNr, "A"));
+            MockB = new CommandMockScale(12346, (req, weight, tare, error, identNr) => ScaleHandlers.Handle_IT6000E(req, weight, tare, error, identNr, "B"));
+            ScaleA = new("A", "IT3000E", "tcp://127.0.0.1:12345");
+            ScaleB = new("B", "IT3000E", "tcp://127.0.0.1:12346");
+        }
+
+        [OneTimeTearDown]
+        public void TeardownScale() {
+            MockA.Dispose();
+            MockB.Dispose();
+            ScaleA.Dispose();
+            ScaleB.Dispose();
+        }
+
+        [SetUp]
+        public void ResetScale() {
+            MockA.IdentNr = 0;
+            MockA.Weight = 0;
+            MockA.Error = null;
+            MockB.IdentNr = 0;
+            MockB.Weight = 0;
+            MockB.Error = null;
+        }
+
+        [Test]
+        public async Task Test_01_CurrentWeight() {
+            MockA.Weight = 1234;
+            Assert.That(await ScaleA!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1234, TareWeight = 0, NetWeight = 1234,
+                Date = new DateOnly(2020, 10, 8), Time = new TimeOnly(8, 47),
+            }));
+            MockB.Weight = 3456;
+            Assert.That(await ScaleB!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 3456, TareWeight = 0, NetWeight = 3456,
+                Date = new DateOnly(2020, 10, 8), Time = new TimeOnly(8, 47),
+            }));
+            MockA.Weight = 1236;
+            Assert.That(await ScaleA!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1236, TareWeight = 0, NetWeight = 1236,
+                Date = new DateOnly(2020, 10, 8), Time = new TimeOnly(8, 47),
+            }));
+            MockB.Weight = 3457;
+            Assert.That(await ScaleB!.GetCurrentWeight(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 3457, TareWeight = 0, NetWeight = 3457,
+                Date = new DateOnly(2020, 10, 8), Time = new TimeOnly(8, 47),
+            }));
+        }
+
+        [Test]
+        public async Task Test_02_Normal() {
+            MockA.Weight = 1234;
+            Assert.That(await ScaleA!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 1234, TareWeight = 0, NetWeight = 1234,
+                WeighingId = "1", FullWeighingId = $"2020-10-08/1",
+                Date = new DateOnly(2020, 10, 8), Time = new TimeOnly(8, 47),
+            }));
+            MockB.Weight = 3456;
+            Assert.That(await ScaleB!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 3456, TareWeight = 0, NetWeight = 3456,
+                WeighingId = "1", FullWeighingId = $"2020-10-08/1",
+                Date = new DateOnly(2020, 10, 8), Time = new TimeOnly(8, 47),
+            }));
+            MockA.Weight = 4321;
+            Assert.That(await ScaleA!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 4321, TareWeight = 0, NetWeight = 4321,
+                WeighingId = "2", FullWeighingId = $"2020-10-08/2",
+                Date = new DateOnly(2020, 10, 8), Time = new TimeOnly(8, 47),
+            }));
+            MockB.Weight = 3333;
+            Assert.That(await ScaleB!.Weigh(), Is.EqualTo(new WeighingResult {
+                GrossWeight = 3333, TareWeight = 0, NetWeight = 3333,
+                WeighingId = "2", FullWeighingId = $"2020-10-08/2",
+                Date = new DateOnly(2020, 10, 8), Time = new TimeOnly(8, 47),
+            }));
+        }
+
+        [Test]
+        public void Test_03_Moving() {
+            MockA.Weight = 1_000;
+            MockA.Error = "moving";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await ScaleA!.Weigh());
+            Assert.That(ex.Message, Contains.Substring("Waage in Bewegung"));
+        }
+
+        [Test]
+        public void Test_04_Overloaded() {
+            MockA.Weight = 10_000;
+            MockA.Error = "overloaded";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await ScaleA!.Weigh());
+            Assert.That(ex.Message, Contains.Substring("Waage in Überlast"));
+        }
+
+        [Test]
+        public void Test_05_InvalidResponse() {
+            MockA.Weight = 1_000;
+            MockA.Error = "invalid";
+            Assert.ThrowsAsync<IOException>(async () => await ScaleA!.Weigh());
+        }
+
+        [Test]
+        public void Test_06_InvalidCrc() {
+            MockA.Weight = 1_000;
+            MockA.Error = "crc";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await ScaleA!.Weigh());
+            Assert.That(ex.Message, Contains.Substring("Invalid CRC16 checksum"));
+        }
+
+        [Test]
+        public void Test_07_InvalidUnit() {
+            MockA.Weight = 1_000;
+            MockA.Error = "unit";
+            IOException ex = Assert.ThrowsAsync<IOException>(async () => await ScaleA!.Weigh());
+        }
+    }
+}

Tests/UnitTests/WeighingTests/Utils.cs

@@ -0,0 +1,6 @@
+namespace Tests.UnitTests.WeighingTests {
+    public static class Utils {
+        public static DateOnly Today => DateOnly.FromDateTime(DateTime.Now);
+        public static TimeOnly Time => new(DateTime.Now.Hour, DateTime.Now.Minute);
+    }
+}