Marcin Wojas
390 lines
22 KiB
C#
390 lines
22 KiB
C#
using System;
|
||
using System.Linq;
|
||
using AwesomeAssertions;
|
||
using NUnit.Framework;
|
||
using Action = System.Action;
|
||
using Soneta.Business;
|
||
using Soneta.CRM;
|
||
using Soneta.Handel;
|
||
using Soneta.Tools;
|
||
using Soneta.Towary;
|
||
using Soneta.Types;
|
||
|
||
namespace Soneta.Skills.Test.Handel.DokumentyHandlowe;
|
||
|
||
/// <summary>
|
||
/// Rozdział 11 skilla „dokument-handlowy” — Operacje pomocnicze (przekrojowe) (W56–W61).
|
||
/// <para>
|
||
/// Testy weryfikują wzorce „okołodokumentowe”: bezpieczne pozyskanie kontrahenta/towaru i obsługę
|
||
/// kontrahenta incydentalnego (W56), przeliczanie jednostek miary towaru (W57), walidację przed
|
||
/// zatwierdzeniem (W58), obsługę błędów/blokady optymistycznej (W59), odczyt metadanych audytowych
|
||
/// <c>ChangeInfos</c> (W60) oraz pracę z definicjami i numeracją dokumentu (W61).
|
||
/// </para>
|
||
/// <para>
|
||
/// W bazie Demo działa <c>StanUjemnyVerifier</c> (blokada stanu ujemnego): rozchód wymaga
|
||
/// wcześniejszego zapisanego przyjęcia. Do prostych scenariuszy używamy przychodu (PW), który
|
||
/// niczego nie blokuje. Magazyn księguje się dopiero po <c>Session.Save()</c>. Wzorzec testów:
|
||
/// utwórz → <c>SaveDispose()</c> → odczyt na świeżej sesji po <c>Guid</c> (po <c>Save()</c> w środku
|
||
/// testu okno edycji się zamyka — kolejna edycja rzuca <c>AccessWriteDenied</c>).
|
||
/// </para>
|
||
/// Cała klasa operuje wyłącznie na publicznym kontrakcie platformy Soneta (jak dodatek zewnętrzny).
|
||
/// </summary>
|
||
[TestFixture]
|
||
public class Rozdzial11_PomocniczeTest : DokumentHandlowyTestBase
|
||
{
|
||
// ===================================================================================
|
||
// Pomocnik lokalny: zatwierdzony przychód (PW) z pozycją, zapisany trwale.
|
||
// PW to przychód — nie podlega blokadzie stanu ujemnego, więc nadaje się do testów
|
||
// numeracji, audytu i odczytu metadanych po zatwierdzeniu.
|
||
// ===================================================================================
|
||
private Guid UtworzZatwierdzonyPwIZapisz(double ilosc = 10, double cena = 5)
|
||
{
|
||
var dok = UtworzDokument(Definicje.PrzyjecieWewnetrzne, magazyn: Magazyn(Magazyn_.Firma));
|
||
InTransaction(() => DodajPozycje(dok, Towar(Towar_.Bikini), ilosc, cena));
|
||
InTransaction(() => dok.Stan = StanDokumentuHandlowego.Zatwierdzony);
|
||
var guid = dok.Guid;
|
||
// Dopiero Save() nadaje numer właściwy i księguje obroty/zasoby; SaveDispose zamyka sesję.
|
||
SaveDispose();
|
||
return guid;
|
||
}
|
||
|
||
// ===================================================================================
|
||
// W56 — Bezpieczne pobranie / utworzenie kontrahenta i towaru pozycji
|
||
// ===================================================================================
|
||
|
||
[Test]
|
||
[Description("W56: WgKodu zwraca istniejący rekord dla znanego kodu, a null dla kodu spoza kartoteki " +
|
||
"(klucz unikalny — pojedynczy rekord lub null).")]
|
||
public void W56_LookupPoKodzie_ZwracaRekordLubNull()
|
||
{
|
||
// Istniejący kontrahent z bazy Demo — lookup po kluczu unikalnym zwraca jeden rekord.
|
||
Kontrahent istniejacy = Kontrahent(Kontrahent_.Abc);
|
||
istniejacy.Should().NotBeNull("kontrahent „Abc” istnieje w bazie Demo");
|
||
|
||
// Kod spoza kartoteki → null (nie wyjątek). To podstawa kontroli istnienia przed użyciem.
|
||
Kontrahent brak = Kontrahent("NIE_ISTNIEJE_XYZ");
|
||
brak.Should().BeNull("WgKodu dla nieistniejącego kodu zwraca null");
|
||
|
||
// Analogicznie towar po kodzie.
|
||
Towar towar = Towar(Towar_.Bikini);
|
||
towar.Should().NotBeNull("towar „BIKINI” istnieje w bazie Demo");
|
||
Towar brakTowaru = Towar("NIE_MA_TAKIEGO");
|
||
brakTowaru.Should().BeNull("WgKodu dla nieistniejącego kodu towaru zwraca null");
|
||
}
|
||
|
||
[Test]
|
||
[Description("W56: kontrahent incydentalny — rekord systemowy pobierany po stałej Kontrahent.INCYDENTALNY " +
|
||
"(indeksator GuidedTable po Guid); rekord ma JestIncydentalny == true.")]
|
||
public void W56_KontrahentIncydentalny_PobranyPoGuidJestOznaczonyJakoIncydentalny()
|
||
{
|
||
// Sprzedaż jednorazowa (klient detaliczny bez kartoteki) — używamy systemowego rekordu
|
||
// „incydentalnego” zamiast tworzyć nowego kontrahenta. Dostęp po stałej Guid.
|
||
Soneta.CRM.Kontrahent incydentalny = Crm.Kontrahenci[Soneta.CRM.Kontrahent.INCYDENTALNY];
|
||
incydentalny.Should().NotBeNull("rekord incydentalny to systemowy rekord obecny w bazie");
|
||
|
||
// JestIncydentalny to pole KALKULOWANE (bool) — potwierdza, że to rekord systemowy.
|
||
incydentalny.JestIncydentalny.Should().BeTrue("to systemowy kontrahent incydentalny");
|
||
|
||
// Zwykły kontrahent z kartoteki NIE jest incydentalny.
|
||
Kontrahent(Kontrahent_.Abc).JestIncydentalny.Should()
|
||
.BeFalse("kontrahent z kartoteki nie jest rekordem incydentalnym");
|
||
}
|
||
|
||
[Test]
|
||
[Description("W56: fallback przy braku rekordu — gdy WgKodu zwraca null, kontrola istnienia pozwala " +
|
||
"sięgnąć po systemowy rekord incydentalny; jednak na fakturze (FV) NIE wolno go ustawiać — " +
|
||
"setter rzuca ArgumentException (kontrahent incydentalny niedozwolony w dokumentach typu FV).")]
|
||
public void W56_FallbackNaIncydentalnego_GdyBrakKontrahentaPoKodzie()
|
||
{
|
||
// Symulacja: kod nabywcy nie istnieje w kartotece — WgKodu zwraca null (kontrola istnienia).
|
||
Kontrahent kontrahent = Kontrahent("DETAL_BEZ_KARTOTEKI");
|
||
if (kontrahent == null)
|
||
kontrahent = Crm.Kontrahenci[Soneta.CRM.Kontrahent.INCYDENTALNY]; // świadomy fallback po stałej Guid
|
||
|
||
// Fallback rzeczywiście znajduje systemowy rekord incydentalny (bez przypisywania go do dokumentu).
|
||
kontrahent.Should().NotBeNull("systemowy rekord incydentalny istnieje w bazie Demo");
|
||
kontrahent.JestIncydentalny.Should().BeTrue("to systemowy kontrahent incydentalny");
|
||
|
||
// Reguła biznesowa: kontrahenta incydentalnego NIE wolno ustawiać na fakturze sprzedaży (FV).
|
||
// Setter Kontrahent na FV zgłasza ArgumentException — dokumentujemy to jako twardą walidację platformy.
|
||
var dok = UtworzDokument(Definicje.FakturaSprzedazy, magazyn: Magazyn(Magazyn_.Firma));
|
||
Action ustawIncydentalnego = () => InTransaction(() => dok.Kontrahent = kontrahent);
|
||
|
||
ustawIncydentalnego.Should().Throw<ArgumentException>(
|
||
"kontrahenta incydentalnego nie można ustawiać w dokumentach typu FV");
|
||
}
|
||
|
||
// ===================================================================================
|
||
// W57 — Przeliczanie jednostek miary towaru (Towar.PrzeliczJednostkę)
|
||
// ===================================================================================
|
||
|
||
[Test]
|
||
[Description("W57: PrzeliczJednostkę w jednostce podstawowej towaru (przeliczenie tożsamościowe) " +
|
||
"zwraca tę samą wartość i symbol — przelicznik 1:1 jest zawsze zdefiniowany.")]
|
||
public void W57_PrzeliczJednostkeNaPodstawowa_ZwracaTeSamaIlosc()
|
||
{
|
||
var towar = Towar(Towar_.Bikini);
|
||
towar.Should().NotBeNull();
|
||
|
||
// Ilość w jednostce PODSTAWOWEJ towaru. throwError: true — brak przelicznika zgłosiłby wyjątek,
|
||
// ale dla jednostki podstawowej → podstawowa konwersja jest tożsamościowa (zawsze poprawna).
|
||
var iloscPodst = new Quantity(7, towar.Jednostka.Kod);
|
||
Quantity wynik = towar.PrzeliczJednostkę(towar.Jednostka, iloscPodst, throwError: true);
|
||
|
||
// Przeliczenie 1:1 — wartość i jednostka bez zmian.
|
||
wynik.Value.Should().Be(7);
|
||
wynik.Symbol.Should().Be(towar.Jednostka.Kod);
|
||
}
|
||
|
||
[Test]
|
||
[Description("W57: na pozycji dokumentu po ustawieniu Towaru symbol jednostki na Ilosc pochodzi z " +
|
||
"jednostki podstawowej towaru — new Quantity(n, poz.Ilosc.Symbol) daje zgodny symbol.")]
|
||
public void W57_SymbolJednostkiNaPozycji_PochodziZTowaru()
|
||
{
|
||
var towar = Towar(Towar_.Bikini);
|
||
var dok = UtworzDokument(Definicje.PrzyjecieWewnetrzne, magazyn: Magazyn(Magazyn_.Firma));
|
||
|
||
PozycjaDokHandlowego poz = null;
|
||
InTransaction(() =>
|
||
{
|
||
// DodajPozycje ustawia Towar PIERWSZY (inicjuje jednostkę), potem Ilosc z symbolem pozycji.
|
||
poz = DodajPozycje(dok, towar, ilosc: 4);
|
||
});
|
||
|
||
// Symbol jednostki pozycji pokrywa się z jednostką podstawową towaru.
|
||
poz.Ilosc.Symbol.Should().Be(towar.Jednostka.Kod,
|
||
"ustawienie Towaru inicjuje symbol jednostki na Ilosc");
|
||
poz.Ilosc.Value.Should().Be(4);
|
||
}
|
||
|
||
// ===================================================================================
|
||
// W58 — Walidacja przed zatwierdzeniem (kompletność, zasób)
|
||
// ===================================================================================
|
||
|
||
[Test]
|
||
[Description("W58: własna walidacja kompletności przed zmianą stanu — dokument bez pozycji ma " +
|
||
"Pozycje.IsEmpty == true (właściwość serwerowa), co pozwala zgłosić czytelny błąd.")]
|
||
public void W58_WalidacjaKompletnosci_PustyDokumentMaPozycjeIsEmpty()
|
||
{
|
||
// FV bez pozycji — nabywca ustawiony, ale brak pozycji.
|
||
var dok = UtworzDokument(Definicje.FakturaSprzedazy,
|
||
kontrahent: Kontrahent(Kontrahent_.Abc),
|
||
magazyn: Magazyn(Magazyn_.Firma));
|
||
|
||
// IsEmpty to WŁAŚCIWOŚĆ (serwerowy exists), nie metoda — używamy jej w walidacji własnej.
|
||
dok.Pozycje.IsEmpty.Should().BeTrue("dokument nie ma jeszcze pozycji");
|
||
dok.Kontrahent.Should().NotBeNull("nabywca jest ustawiony");
|
||
|
||
// Po dodaniu pozycji walidacja kompletności przechodzi.
|
||
InTransaction(() => DodajPozycje(dok, Towar(Towar_.Bikini), ilosc: 2, cena: 5));
|
||
dok.Pozycje.IsEmpty.Should().BeFalse("po dodaniu pozycji kolekcja nie jest pusta");
|
||
}
|
||
|
||
[Test]
|
||
[Description("W58: blokada stanu ujemnego — zatwierdzenie i zapis rozchodu (WZ) towaru bez wcześniej " +
|
||
"zapisanego przyjęcia zgłasza wyjątek dopiero w Save() (StanUjemnyVerifier).")]
|
||
public void W58_RozchodBezStanu_RzucaWyjatekWSave()
|
||
{
|
||
// WZ rozchodowy towaru BIKINI — w tym teście NIE robimy wcześniejszego przyjęcia,
|
||
// więc stan jest niewystarczający. Magazyn księguje się dopiero w Save().
|
||
var wz = UtworzDokument(Definicje.WydanieZewnetrzne,
|
||
kontrahent: Kontrahent(Kontrahent_.Abc),
|
||
magazyn: Magazyn(Magazyn_.Firma));
|
||
InTransaction(() => DodajPozycje(wz, Towar(Towar_.Bikini), ilosc: 5, cena: 9));
|
||
InTransaction(() => wz.Stan = StanDokumentuHandlowego.Zatwierdzony);
|
||
|
||
// Sam Commit NIE księguje zasobów — kontrola stanu ujemnego uruchamia się w Save().
|
||
Action zapis = () => SaveDispose();
|
||
zapis.Should().Throw<Exception>("StanUjemnyVerifier blokuje rozchód bez zapisanego przyjęcia");
|
||
}
|
||
|
||
// ===================================================================================
|
||
// W59 — Obsługa błędów i blokada optymistyczna
|
||
// ===================================================================================
|
||
|
||
[Test]
|
||
[Description("W59: wzorzec łapania wyjątku platformy — edycja na sesji z zamkniętym oknem edycji " +
|
||
"(po SaveDispose) rzuca wyjątek; asercja typu/komunikatu zamiast „połykania”.")]
|
||
public void W59_EdycjaPozaTransakcja_RzucaWyjatek()
|
||
{
|
||
// Tworzymy i zapisujemy dokument; po SaveDispose okno edycji bieżącej sesji jest zamknięte.
|
||
var guid = UtworzZatwierdzonyPwIZapisz();
|
||
var dok = Get<DokumentHandlowy>(guid);
|
||
dok.Should().NotBeNull();
|
||
|
||
// Próba modyfikacji pola POZA transakcją edycyjną (bez Session.Logout(true)) jest niedozwolona.
|
||
// Wzorzec safe-code: łapiemy konkretny wyjątek platformy, nie Exception ogólnie „po cichu”.
|
||
// MemoText przyjmuje string przez konwersję niejawną (string -> MemoText).
|
||
Action edycjaBezTransakcji = () => dok.Opis = "X";
|
||
edycjaBezTransakcji.Should().Throw<Exception>(
|
||
"modyfikacja rekordu wymaga otwartej transakcji edycyjnej (Session.Logout(true))");
|
||
}
|
||
|
||
[Test]
|
||
[Description("W59: walidacja własna rzucana jako RowException PRZED Commit — wyjątek niesie odwołanie " +
|
||
"do wiersza i komunikat; asercja typu wyjątku i jego Row.")]
|
||
public void W59_WalidacjaWlasna_RzucaRowException()
|
||
{
|
||
// Pokazujemy WZORZEC obsługi: walidacja własna zgłasza RowException(dok, komunikat) przed Commit.
|
||
var dok = UtworzDokument(Definicje.FakturaSprzedazy, magazyn: Magazyn(Magazyn_.Firma));
|
||
|
||
// Symulacja walidacji „brak nabywcy” — w realnym kodzie poprzedza zmianę stanu.
|
||
Action walidacja = () =>
|
||
{
|
||
if (dok.Kontrahent == null)
|
||
throw new RowException(dok, "Dokument nie ma nabywcy.".Translate());
|
||
};
|
||
|
||
// Asercja TYPU wyjątku (nie ogólne Exception) — tak rozróżnia się walidację biznesową.
|
||
// RowException udostępnia wiersz przez właściwość IRow (RowException dziedziczy z BusException).
|
||
walidacja.Should().Throw<RowException>()
|
||
.Which.IRow.Should().Be(dok, "RowException niesie odwołanie do wiersza, którego dotyczy");
|
||
}
|
||
|
||
// ===================================================================================
|
||
// W60 — Odczyt metadanych dokumentu (ChangeInfos)
|
||
// ===================================================================================
|
||
|
||
[Test]
|
||
[Description("W60: po utworzeniu i zapisaniu dokumentu FirstChangeInfo (kto/kiedy założył) jest " +
|
||
"wypełnione, gdy audyt jest włączony; gdy null (tryb testowy bez rejestracji) — pomijamy asercję.")]
|
||
public void W60_FirstChangeInfo_PoZapisieNiepusteLubPominiete()
|
||
{
|
||
var guid = UtworzZatwierdzonyPwIZapisz();
|
||
var dok = Get<DokumentHandlowy>(guid);
|
||
dok.Should().NotBeNull();
|
||
|
||
// FirstChangeInfo jest KALKULOWANE (select top 1 ... from ChangeInfos) i może być null,
|
||
// gdy historia rekordu nie była rejestrowana (np. import / audyt wyłączony).
|
||
var zalozyl = dok.FirstChangeInfo;
|
||
if (zalozyl == null)
|
||
{
|
||
// Audyt nie zarejestrował wpisu w tym trybie — SKIP asercji, sam odczyt nie rzuca.
|
||
Assert.Ignore("Brak wpisu ChangeInfo dla rekordu w tym trybie (rejestracja audytu wyłączona) — " +
|
||
"właściwość kalkulowana zwróciła null; odczyt jest dozwolony, asercję pomijamy.");
|
||
}
|
||
|
||
// Gdy audyt działa — wpis ma czas utworzenia i (zwykle) operatora.
|
||
zalozyl.Time.Should().NotBe(default(DateTime), "wpis założenia niesie czas utworzenia");
|
||
}
|
||
|
||
[Test]
|
||
[Description("W60: LastChangeInfo (kto/kiedy ostatnio zmienił) po zapisie jest niepuste lub — w trybie " +
|
||
"bez rejestracji audytu — null; odczyt nie rzuca, asercję czasu wykonujemy warunkowo.")]
|
||
public void W60_LastChangeInfo_PoZapisieNiepusteLubPominiete()
|
||
{
|
||
var guid = UtworzZatwierdzonyPwIZapisz();
|
||
var dok = Get<DokumentHandlowy>(guid);
|
||
|
||
// Sam odczyt właściwości kalkulowanej nie może rzucać — zawsze sprawdzamy != null.
|
||
var ostatnia = dok.LastChangeInfo;
|
||
if (ostatnia == null)
|
||
{
|
||
Assert.Ignore("Brak wpisu LastChangeInfo w tym trybie (rejestracja audytu wyłączona) — " +
|
||
"odczyt dozwolony, asercję pomijamy.");
|
||
}
|
||
|
||
ostatnia.Time.Should().NotBe(default(DateTime), "wpis ostatniej zmiany niesie czas");
|
||
}
|
||
|
||
// ===================================================================================
|
||
// W61 — Praca z definicjami i numeracją (seria, numer pełny, bufor)
|
||
// ===================================================================================
|
||
|
||
[Test]
|
||
[Description("W61: dokument w buforze nie ma jeszcze numeru właściwego — BuforNumer == \"BUFOR\", " +
|
||
"a po zatwierdzeniu i zapisie Numer.NumerPelny zawiera nadany numer (bez znacznika BUFOR).")]
|
||
public void W61_NumerNadawanyPrzyZatwierdzeniu_BuforPotemNumerWlasciwy()
|
||
{
|
||
// Dokument w buforze (jeszcze niezatwierdzony).
|
||
var dok = UtworzDokument(Definicje.PrzyjecieWewnetrzne, magazyn: Magazyn(Magazyn_.Firma));
|
||
InTransaction(() => DodajPozycje(dok, Towar(Towar_.Bikini), ilosc: 10, cena: 5));
|
||
|
||
// W buforze numer właściwy nie jest nadany — kalkulowane BuforNumer zwraca znacznik „BUFOR”.
|
||
dok.Bufor.Should().BeTrue();
|
||
dok.BuforNumer.Should().Be("BUFOR", "w buforze numer właściwy nie jest jeszcze nadany");
|
||
|
||
// Zatwierdzenie + Save nadaje numer właściwy.
|
||
var guid = dok.Guid;
|
||
InTransaction(() => dok.Stan = StanDokumentuHandlowego.Zatwierdzony);
|
||
SaveDispose();
|
||
|
||
// Odczyt na świeżej sesji — numer pełny czytamy przez Numer.NumerPelny (nie składamy ręcznie).
|
||
var zapisany = Get<DokumentHandlowy>(guid);
|
||
zapisany.Zatwierdzony.Should().BeTrue();
|
||
string numer = zapisany.Numer.NumerPelny;
|
||
numer.Should().NotBeNullOrEmpty("zatwierdzony dokument ma nadany numer pełny");
|
||
numer.Should().NotContain("BUFOR", "po zatwierdzeniu numer nie zawiera już znacznika bufora");
|
||
}
|
||
|
||
[Test]
|
||
[Description("W61: pobranie definicji po symbolu (WgSymbolu) oraz odczyt dozwolonych serii dokumentu " +
|
||
"przez GetListSeria(); dodatkowo na zatwierdzonym i zapisanym PW Numer.NumerPelny jest niepusty.")]
|
||
public void W61_DefinicjaISerie_OdczytPublicznegoKontraktu()
|
||
{
|
||
// Definicja dokumentu pobierana po symbolu z bazy Demo (klucz WgSymbolu).
|
||
DefDokHandlowego def = Definicja(Definicje.FakturaSprzedazy);
|
||
def.Should().NotBeNull("definicja FV istnieje w bazie Demo");
|
||
|
||
var dok = UtworzDokument(Definicje.FakturaSprzedazy,
|
||
kontrahent: Kontrahent(Kontrahent_.Abc),
|
||
magazyn: Magazyn(Magazyn_.Firma));
|
||
|
||
// Dokument ma przypisaną definicję (ustawioną jako pierwszą przez helper bazy).
|
||
dok.Definicja.Should().Be(def);
|
||
|
||
// GetListSeria() zwraca dozwolone serie lub null, gdy numeracja nie ma komponentu Seria.
|
||
// Kontrakt testu: sam ODCZYT nie może rzucać; null jest dopuszczalny (brak komponentu Seria).
|
||
string[] serie = null;
|
||
Action odczytSerii = () => serie = dok.GetListSeria();
|
||
odczytSerii.Should().NotThrow("odczyt dozwolonych serii nie może rzucać");
|
||
|
||
// Serię ustawiamy TYLKO gdy numeracja na to pozwala — w przeciwnym razie setter rzuciłby RowException.
|
||
if (serie != null && serie.Length > 0)
|
||
{
|
||
InTransaction(() => dok.Seria = serie[0]);
|
||
dok.Seria.Should().Be(serie[0], "ustawiona seria została zapamiętana");
|
||
}
|
||
|
||
// Numerację potwierdzamy na bezpiecznym dokumencie przychodowym (PW), który można zatwierdzić
|
||
// i zapisać (FV w bazie Demo rzuca NRE w ewidencji VAT przy zatwierdzeniu — §3 faktów).
|
||
var pwGuid = UtworzZatwierdzonyPwIZapisz();
|
||
var pw = Get<DokumentHandlowy>(pwGuid); // świeża sesja po SaveDispose (§8)
|
||
pw.Should().NotBeNull();
|
||
pw.Numer.NumerPelny.Should().NotBeNullOrEmpty("zatwierdzony i zapisany dokument ma nadany numer pełny");
|
||
}
|
||
|
||
// ===================================================================================
|
||
// SCENARIUSZE POMINIĘTE (SKIP) — uzasadnienie zgodne z treścią rozdziału
|
||
// ===================================================================================
|
||
|
||
[Test]
|
||
[Ignore("W56 — utworzenie NOWEGO kontrahenta/towaru „w locie” (new Kontrahent()/new Towar() + AddRow) " +
|
||
"to dane kartotekowe (KONFIGURACYJNE), a nie zachowanie dokumentu handlowego. Rozdział wprost " +
|
||
"odradza tworzenie towaru przy wystawianiu (brak towaru = błąd danych → BusException). Tworzenie " +
|
||
"kartoteki kontrahenta jest pokryte w testach CRM (kontrahent.md, W3). SKIP: poza zakresem rozdziału.")]
|
||
[Description("W56: tworzenie nowego rekordu kartotekowego w locie — pominięte (zakres CRM/konfiguracja).")]
|
||
public void W56_TworzenieNowegoRekordu_Skip() { }
|
||
|
||
[Test]
|
||
[Ignore("W57 — przeliczenie z jednostki POMOCNICZEJ na podstawową (PrzeliczJednostkę z realnym " +
|
||
"przelicznikiem ≠ 1:1) wymaga towaru z ZDEFINIOWANYM przelicznikiem jednostki pomocniczej/" +
|
||
"uzupełniającej. Przeliczniki to dane konfiguracyjne towaru; baza Demo nie gwarantuje towaru " +
|
||
"z jednoznacznym przelicznikiem pomocniczym (TRANSPORT ma jednostkę km, ale konfiguracja " +
|
||
"przeliczników nie jest częścią kontraktu testu). Z throwError: true brak przelicznika rzuciłby " +
|
||
"wyjątek — test byłby kruchy. Pokrywamy konwersję tożsamościową (1:1) i symbol jednostki pozycji. " +
|
||
"SKIP: realny przelicznik pomocniczy = konfiguracja towaru poza zakresem.")]
|
||
[Description("W57: przeliczenie z jednostki pomocniczej (przelicznik ≠ 1:1) — pominięte (konfiguracja towaru).")]
|
||
public void W57_PrzeliczniePomocniczej_Skip() { }
|
||
|
||
[Test]
|
||
[Ignore("W59 — realny konflikt optymistyczny (RowConflictException) i retry wymagają RÓWNOLEGŁEGO zapisu " +
|
||
"tego samego rekordu z DRUGIEJ sesji/wątku. TestBase udostępnia pojedynczą sesję operacyjną i wycofuje " +
|
||
"zmiany w transakcji bazodanowej; symulacja drugiej, zapisującej sesji wykracza poza ten model testowy " +
|
||
"(ryzyko zakleszczeń i niestabilności). Wzorzec łapania wyjątku platformy pokrywamy w " +
|
||
"W59_EdycjaPozaTransakcja i W59_WalidacjaWlasna (asercja typu wyjątku). SKIP: realny wyścig zapisu " +
|
||
"poza modelem TestBase.")]
|
||
[Description("W59: faktyczny konflikt optymistyczny i retry między sesjami — pominięte (model TestBase).")]
|
||
public void W59_KonfliktOptymistyczny_Skip() { }
|
||
}
|