Marius Mutu
859e67e874
Verificarile de partener nu mai depind exclusiv de raspunsul ANAF: se citeste intai cache-ul din ISTORIC_CODURI_FISCALE (mutat in CONTAFIN_ORACLE), cu provenienta afisata pe ecrane (sursa / data_sursa) si cu plasa de siguranta cand ANAF tace. Ordinea cache/ANAF e configurabila; cache-ul expira. - programe/validare.prg: verificare single si pe loturi peste cache, contract 404 separat de caderea de serviciu, expirarea cache-ului, corectii la verdictul pe firma si la etichetarea CACHE_INDISP. - programe/ocautare.prg: plasa de siguranta si banda de provenienta la cautarea de partener. - programe/oproceduri_comune.prg: VERIFICA_RTVAI_DATA citeste si cache-ul. - clase/overificari.vc2: propagarea provenientei in interfata. - utile/Teste/: harness-uri de testare headless - echivalenta cache/ANAF pe 200 de coduri reale, marginile pe inactiv si TVA la incasare, mock batch ANAF, baseline D394 si sondele de diagnostic ANAF. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01JCzVWfqscv1xyo5uvJiWiW
438 lines
18 KiB
Plaintext
438 lines
18 KiB
Plaintext
* test_echivalenta_cache_anaf_200.prg - S13, Testul 1, criteriul de acceptare LITERAL din
|
|
* stories-cache-anaf.md ("~200 de coduri... cel putin 3 date de referinta, inclusiv una in
|
|
* trecut"): o rulare cu OrdineCache('MASA')='CACHE,ANAF' si una cu 'ANAF,CACHE', pe acelasi lot
|
|
* de 200 CUI REALE (din NOM_PARTENERI, MARIUSM_AUTO) si aceleasi 3 date de referinta, trebuie sa
|
|
* dea verdicte identice (platitor TVA/scpTVA, TVA la incasare, inactiv).
|
|
*
|
|
* Diferit de test_echivalenta_cache_rtvai.prg (Testul de ADANCIME, 8 CUI cu istoric RTVAI real,
|
|
* deja facut) - acesta e testul de LARGIME/scara cerut explicit ca poarta de productie pentru
|
|
* 'CACHE,ANAF'. Foloseste acelasi mock S11 (mock_batch_anaf.prg), dar il forteaza pe o ordine
|
|
* aleasa (fara sa scrie in OPTIUNI, tabela partajata cu alte benzi) printr-o subclasa care
|
|
* suprascrie OrdineCache - vezi DEFINE CLASS de la finalul fisierului.
|
|
*
|
|
* PROIECTAREA FIXTURE-ULUI (200 coduri REALE, citite din codes_200_reale.txt, extrase din
|
|
* NOM_PARTENERI - vezi diff pentru interogare): fiecare cod primeste, deterministic dupa
|
|
* MOD(index,10), unul din 4 tipare de interval. Majoritatea (140/200) sunt "vanilla" - inregistrate
|
|
* de mult (acum 3 ani) si inca active pe toate 3 campurile - genereaza IDENTIC pe toate 3 date,
|
|
* FARA nicio abtinere (simuleaza firme stabile, cazul obisnuit).
|
|
*
|
|
* MOCK-UL ANAF ESTE SENSIBIL LA DATA CERUTA (corectie 31.07.2026, a doua trecere: reparat DIRECT in
|
|
* mock_batch_anaf.prg::PropBool, nu mai recalculat local in acest test): fiecare item ANAF primeste,
|
|
* O SINGURA DATA la construirea fixture-ului, perechea de date (dataInceputScpTVA/dataSfarsitScpTVA
|
|
* etc., STRING 'YYYY-MM-DD'); PropBool evalueaza boolean-ul FATA DE tdData la fiecare apel - exact ca
|
|
* API-ul ANAF real, care primeste "data" per CUI in cerere (validare.prg:2098). Mock-ul NU e omniscient:
|
|
* cunoaste O SINGURA perioada per camp (aceeasi limitare structurala reala a ANAF - o pereche
|
|
* data_inceput/data_sfarsit, nu o lista). Varianta anterioara (boolean fix, "stare curenta" indiferent
|
|
* de data) era artefact de fixture, nu simulare fidela - vezi docs\diff-S13-teste-echivalenta.md,
|
|
* sectiunea "Ancheta ceruta de team-lead", pentru mecanismul exact si dovada pe cod.
|
|
*
|
|
* Restul (60/200, cate 20 pe grup) exercita marginea cunoscuta, la a treia data de referinta (2 ani
|
|
* in urma):
|
|
* MOD(i,10)=1: scpTVA inchis acum 1 an (deschis 3 ani, inchis 1 an) -> la 2 ani in urma cade IN
|
|
* interiorul perioadei -> acum ca mock-ul e sensibil la data, ambele trasee
|
|
* calculeaza "era activ atunci" -> IDENTIC (nu mai e divergenta)
|
|
* MOD(i,10)=2: TVA la incasare pornita acum 1 an (deschisa) -> la 2 ani in urma cade INAINTE de
|
|
* inceputul singurei perioade cunoscute -> garda S6 se declanseaza -> cache-ul se
|
|
* ABTINE (randul intreg nu se mai intoarce) -> codul e trimis la ANAF (mock), care
|
|
* (marginit la propria perioada, neomniscient) raspunde tot "nu" pentru acea data ->
|
|
* verdict final IDENTIC, dar prin ABTINERE, nu prin cache - se vede in contorul de
|
|
* apeluri ANAF, nu in verdictul final. Asta ramane singura limitare REALA testabila
|
|
* cu acest fixture (ANAF nu are nicio informatie dinainte de perioada pe care o
|
|
* urmareste) - vezi si test_echivalenta_cache_rtvai.prg pentru dovada pe date reale.
|
|
* MOD(i,10)=3: inactiv intre acum 3 ani si acum 1 an (reactivat) -> la 2 ani in urma cade IN
|
|
* fereastra de inactivitate -> ambele trasee calculeaza "era inactiv atunci" ->
|
|
* IDENTIC (nu mai e divergenta)
|
|
* altfel (MOD(i,10) in 0,4,5,6,7,8,9 - 140 coduri): vanilla, IDENTIC pe toate 3 date
|
|
*
|
|
* ASTEPTAT la toate 3 date: 200/200 IDENTICE; la D3, 20 din ele (grupul 2) prin ABTINERE (nu prin
|
|
* cache), 0 DIVERGENTE. O divergenta ramasa dupa aceasta corectie ar fi categoria (c) - bug real -
|
|
* si se raporteaza ca atare, fara sa fie "reparata" sau ascunsa.
|
|
*
|
|
* Capcane (vezi COMUN\docs\depanare_testare_vfp.md si diff-S11-mock-batch.md): SET SAFETY OFF,
|
|
* obiecte de configurare (Collection/Empty) construite INLINE in main (nu in PROCEDURE), mock
|
|
* incarcat DUPA test_init_env_auto, ON ERROR + WriteTestLog, curatenie la inceput si FINALLY.
|
|
|
|
SET SAFETY OFF
|
|
SET TALK OFF
|
|
SET DELETED ON
|
|
SET EXACT ON
|
|
SET CENTURY ON
|
|
SET DATE DMY
|
|
SET NULLDISPLAY TO ''
|
|
CLOSE DATABASES
|
|
|
|
PUBLIC gcTestLog
|
|
gcTestLog = "D:\ROA\ROACONT\COMUN\utile\Teste\cache_anaf\test_echivalenta_cache_anaf_200_log.txt"
|
|
STRTOFILE("START " + TTOC(DATETIME()) + CHR(13)+CHR(10), gcTestLog)
|
|
|
|
ON ERROR DO VpaErr200 WITH ERROR(), MESSAGE(), PROGRAM(), LINENO()
|
|
ON SHUTDOWN QUIT
|
|
|
|
DO D:\ROA\ROACONT\COMUN\utile\Teste\test_init_env_auto.prg WITH 'CENTRAL', 'MARIUSM_AUTO', 'ROMFASTSOFT'
|
|
IF gnHandle <= 0
|
|
DO WriteTestLog200 WITH 'EROARE: conectare Oracle esuata - GATA'
|
|
QUIT
|
|
ENDIF
|
|
DO WriteTestLog200 WITH 'mediu OK, schema=' + gcS
|
|
|
|
*!* 01.08.2026 marius.mutu: watermark pe ID, inainte de orice scriere - garda pt DELETE-urile din CurataIstoric200
|
|
PUBLIC gnIdMaxIstoric200
|
|
gnIdMaxIstoric200 = 0
|
|
IF goExecutor.oExecuta('SELECT NVL(MAX(ID),0) AS IDMAX FROM ISTORIC_CODURI_FISCALE', 'crsWmIstoric200')
|
|
SELECT crsWmIstoric200
|
|
GO TOP
|
|
gnIdMaxIstoric200 = IDMAX
|
|
USE IN (SELECT('crsWmIstoric200'))
|
|
ENDIF
|
|
DO WriteTestLog200 WITH 'watermark ISTORIC_CODURI_FISCALE id_max=' + TRANSFORM(gnIdMaxIstoric200)
|
|
*!* 01.08.2026 marius.mutu: watermark invalid = SELECT esuat - avertisment explicit, stergerile se vor sari
|
|
IF gnIdMaxIstoric200 <= 0
|
|
DO WriteTestLog200 WITH 'ATENTIE: watermark invalid (0) - stergerile din ISTORIC_CODURI_FISCALE vor fi SARITE'
|
|
ENDIF
|
|
|
|
* mock-ul e o SUBCLASA a VerificareANAF - se incarca DUPA test_init_env_auto (vezi mock_batch_anaf.prg)
|
|
SET PROCEDURE TO "D:\ROA\ROACONT\COMUN\utile\Teste\cache_anaf\mock_batch_anaf.prg" ADDITIVE
|
|
|
|
PUBLIC goANAFBatchMock, goANAFBatchScenariuPerGrup, gcANAFBatchScenariu, glANAFBatchIgnoraGate404
|
|
PUBLIC gnANAFBatchApeluri, gcANAFBatchCuiuriTrimise, gcForceOrdine200
|
|
goANAFBatchMock = CREATEOBJECT('Collection')
|
|
goANAFBatchScenariuPerGrup = CREATEOBJECT('Collection')
|
|
gcANAFBatchScenariu = 'NORMAL'
|
|
glANAFBatchIgnoraGate404 = .F.
|
|
gnANAFBatchApeluri = 0
|
|
gcANAFBatchCuiuriTrimise = ''
|
|
gcForceOrdine200 = 'CACHE,ANAF'
|
|
|
|
PUBLIC goMock200
|
|
goMock200 = CREATEOBJECT('VerificareANAFMockBatchOrdine200')
|
|
|
|
DO CurataIstoric200
|
|
|
|
* --- citeste cele 200 de coduri REALE dintr-un fisier text (un CUI pe linie, CRLF) ---
|
|
LOCAL lcCodesFile, lcCodesText
|
|
LOCAL ARRAY laCodes200[1]
|
|
lcCodesFile = "D:\ROA\ROACONT\COMUN\utile\Teste\cache_anaf\codes_200_reale.txt"
|
|
lcCodesText = FILETOSTR(lcCodesFile)
|
|
LOCAL lnCodes200
|
|
lnCodes200 = ALINES(laCodes200, lcCodesText)
|
|
DO WriteTestLog200 WITH 'coduri citite din fisier: ' + TRANSFORM(lnCodes200)
|
|
|
|
* --- date de referinta ---
|
|
LOCAL ldY3, ldY1, ldD1, ldD2, ldD3
|
|
ldD1 = DATE()
|
|
ldY3 = ldD1 - 1095
|
|
ldY1 = ldD1 - 365
|
|
ldD2 = ldD1 - 90
|
|
ldD3 = ldD1 - 730
|
|
DO WriteTestLog200 WITH 'date referinta: D1(azi)=' + DTOC(ldD1) + ' D2(3 luni)=' + DTOC(ldD2) + ' D3(2 ani)=' + DTOC(ldD3)
|
|
|
|
* --- construieste seed-ul de cache (crsANAF-shape) si mock-ul ANAF, per cod, dupa MOD(index,10) ---
|
|
IF USED('crsSeedANAF200')
|
|
USE IN crsSeedANAF200
|
|
ENDIF
|
|
CREATE CURSOR crsSeedANAF200 (cui N(13), data D, denumire V(100), firma V(100), adresa C(244), nrRegCom C(30), ;
|
|
scpTVA L, data_inceput_ScpTVA D, data_sfarsit_ScpTVA D, data_anul_imp_ScpTVA D, mesaj_ScpTVA C(244), ;
|
|
dataInceputTvaInc D, dataSfarsitTvaInc D, dataActualizareTvaInc D, dataPublicareTvaInc D, tipActTvaInc C(100), statusTvaIncasare L, ;
|
|
dataInactivare D, dataReactivare D, dataPublicare D, dataRadiere D, statusInactivi L, ;
|
|
dataInceputSplitTVA D, dataAnulareSplitTVA D, tva L, tvaincasare L, splittva L, inactiv L, ;
|
|
mesaj V(100), judet V(100), strada V(100), nr V(20), localitate V(100), Bloc V(20), scara V(20), etaj V(20), apart V(20), ;
|
|
sursa C(20), data_sursa D)
|
|
|
|
IF USED('crsCoduri200Input')
|
|
USE IN crsCoduri200Input
|
|
ENDIF
|
|
CREATE CURSOR crsCoduri200Input (cod_fiscal C(30) Null, data D Null)
|
|
|
|
IF USED('crsGrupuri200')
|
|
USE IN crsGrupuri200
|
|
ENDIF
|
|
* pastreaza si intervalul seedat per cod - refolosit ca sa recalculez mock-ul la fiecare data,
|
|
* fara sa duplic logica de grup (vezi bucla de mai jos)
|
|
CREATE CURSOR crsGrupuri200 (cui N(13), grup N(2), ;
|
|
dScptvaStart D, dScptvaEnd D, dTvaincStart D, dTvaincEnd D, dInactivareD D, dReactivareD D)
|
|
|
|
LOCAL lnI, lcCuiTxt, lnCuiN, lnGrup
|
|
LOCAL ldScptvaStart, ldScptvaEnd, ldTvaincStart, ldTvaincEnd, ldInactivareD, ldReactivareD
|
|
LOCAL llScpTvaMock, llTvaIncMock, llInactivMock
|
|
|
|
FOR lnI = 1 TO lnCodes200
|
|
lcCuiTxt = ALLTRIM(laCodes200[lnI])
|
|
IF EMPTY(lcCuiTxt)
|
|
LOOP
|
|
ENDIF
|
|
lnCuiN = INT(VAL(lcCuiTxt))
|
|
lnGrup = MOD(lnI, 10)
|
|
|
|
DO CASE
|
|
CASE lnGrup = 1
|
|
* scpTVA inchis acum 1 an - divergenta asteptata la D3
|
|
ldScptvaStart = ldY3
|
|
ldScptvaEnd = ldY1
|
|
llScpTvaMock = .F.
|
|
ldTvaincStart = ldY3
|
|
ldTvaincEnd = {}
|
|
llTvaIncMock = .T.
|
|
ldInactivareD = {}
|
|
ldReactivareD = {}
|
|
llInactivMock = .F.
|
|
CASE lnGrup = 2
|
|
* TVA la incasare pornita acum 1 an - abtinere asteptata la D3
|
|
ldScptvaStart = ldY3
|
|
ldScptvaEnd = {}
|
|
llScpTvaMock = .T.
|
|
ldTvaincStart = ldY1
|
|
ldTvaincEnd = {}
|
|
llTvaIncMock = .T.
|
|
ldInactivareD = {}
|
|
ldReactivareD = {}
|
|
llInactivMock = .F.
|
|
CASE lnGrup = 3
|
|
* inactiv acum 3 ani, reactivat acum 1 an - divergenta asteptata la D3
|
|
ldScptvaStart = ldY3
|
|
ldScptvaEnd = {}
|
|
llScpTvaMock = .T.
|
|
ldTvaincStart = ldY3
|
|
ldTvaincEnd = {}
|
|
llTvaIncMock = .T.
|
|
ldInactivareD = ldY3
|
|
ldReactivareD = ldY1
|
|
llInactivMock = .F.
|
|
OTHERWISE
|
|
* vanilla - identic pe toate 3 date, fara abtinere
|
|
ldScptvaStart = ldY3
|
|
ldScptvaEnd = {}
|
|
llScpTvaMock = .T.
|
|
ldTvaincStart = ldY3
|
|
ldTvaincEnd = {}
|
|
llTvaIncMock = .T.
|
|
ldInactivareD = {}
|
|
ldReactivareD = {}
|
|
llInactivMock = .F.
|
|
ENDCASE
|
|
|
|
INSERT INTO crsSeedANAF200 (cui, data, data_inceput_ScpTVA, data_sfarsit_ScpTVA, ;
|
|
dataInceputTvaInc, dataSfarsitTvaInc, dataInactivare, dataReactivare, ;
|
|
scpTVA, tvaincasare, inactiv) VALUES ;
|
|
(lnCuiN, ldD1, ldScptvaStart, ldScptvaEnd, ldTvaincStart, ldTvaincEnd, ldInactivareD, ldReactivareD, ;
|
|
llScpTvaMock, llTvaIncMock, llInactivMock)
|
|
|
|
INSERT INTO crsCoduri200Input (cod_fiscal) VALUES (lcCuiTxt)
|
|
INSERT INTO crsGrupuri200 (cui, grup, dScptvaStart, dScptvaEnd, dTvaincStart, dTvaincEnd, dInactivareD, dReactivareD) ;
|
|
VALUES (lnCuiN, lnGrup, ldScptvaStart, ldScptvaEnd, ldTvaincStart, ldTvaincEnd, ldInactivareD, ldReactivareD)
|
|
|
|
* -- item mock ANAF, construit O SINGURA DATA (nu per data de referinta) - PropBool
|
|
* (mock_batch_anaf.prg, reparat 31.07.2026) recalculeaza sensibil la tdData la fiecare apel,
|
|
* din exact acest interval unic (STRING 'YYYY-MM-DD', formatul documentat al mock-ului) --
|
|
LOCAL loMockItem200
|
|
loMockItem200 = CREATEOBJECT('Empty')
|
|
ADDPROPERTY(loMockItem200, 'dataInceputScpTVA', Dtoiso200(ldScptvaStart))
|
|
ADDPROPERTY(loMockItem200, 'dataSfarsitScpTVA', Dtoiso200(ldScptvaEnd))
|
|
ADDPROPERTY(loMockItem200, 'dataInceputTvaInc', Dtoiso200(ldTvaincStart))
|
|
ADDPROPERTY(loMockItem200, 'dataSfarsitTvaInc', Dtoiso200(ldTvaincEnd))
|
|
ADDPROPERTY(loMockItem200, 'dataInactivare', Dtoiso200(ldInactivareD))
|
|
ADDPROPERTY(loMockItem200, 'dataReactivare', Dtoiso200(ldReactivareD))
|
|
goANAFBatchMock.Add(loMockItem200, 'C' + NormalizeazaCUI(lcCuiTxt))
|
|
ENDFOR
|
|
|
|
DO WriteTestLog200 WITH 'fixture construit: ' + TRANSFORM(RECCOUNT('crsSeedANAF200')) + ' coduri (grup1=20 scpTVA-inchis, grup2=20 tvainc-recent, grup3=20 inactiv-trecut, restul vanilla)'
|
|
|
|
goMock200.SalveazaIstoricDinCursor('crsSeedANAF200', gnIdUtil)
|
|
DO WriteTestLog200 WITH 'seed salvat in ISTORIC_CODURI_FISCALE'
|
|
|
|
* --- ruleaza ambele ordini, pe toate 3 datele, si compara ---
|
|
TRY
|
|
LOCAL lnDateIdx, ldDataCurenta, lcNumeData
|
|
LOCAL lnIdentice, lnDivergente, lnAbtinute, lnAsteptateDivergente, lnAsteptateAbtinute
|
|
LOCAL lcAliasA, lcAliasB, lcCuiuriCache, lcCuiuriAnaf
|
|
|
|
FOR lnDateIdx = 1 TO 3
|
|
DO CASE
|
|
CASE lnDateIdx = 1
|
|
ldDataCurenta = ldD1
|
|
lcNumeData = 'D1-azi'
|
|
CASE lnDateIdx = 2
|
|
ldDataCurenta = ldD2
|
|
lcNumeData = 'D2-3luni'
|
|
OTHERWISE
|
|
ldDataCurenta = ldD3
|
|
lcNumeData = 'D3-2ani'
|
|
ENDCASE
|
|
|
|
* -- mock-ul ANAF (goANAFBatchMock) NU se mai reconstruieste aici: e populat O SINGURA DATA,
|
|
* mai sus, la construirea fixture-ului - PropBool (mock_batch_anaf.prg) recalculeaza singur,
|
|
* la fiecare apel, boolean-ul sensibil la ldDataCurenta din intervalul unic memorat pe item --
|
|
|
|
* -- rulare CACHE,ANAF --
|
|
gcForceOrdine200 = 'CACHE,ANAF'
|
|
gnANAFBatchApeluri = 0
|
|
gcANAFBatchCuiuriTrimise = ''
|
|
lcAliasA = 'crsRezCacheAnaf'
|
|
IF USED(lcAliasA)
|
|
USE IN (lcAliasA)
|
|
ENDIF
|
|
goMock200.VerificaListaCIF('crsCoduri200Input', ldDataCurenta, lcAliasA)
|
|
lcCuiuriCache = gcANAFBatchCuiuriTrimise
|
|
|
|
* -- rulare ANAF,CACHE --
|
|
gcForceOrdine200 = 'ANAF,CACHE'
|
|
gnANAFBatchApeluri = 0
|
|
gcANAFBatchCuiuriTrimise = ''
|
|
lcAliasB = 'crsRezAnafCache'
|
|
IF USED(lcAliasB)
|
|
USE IN (lcAliasB)
|
|
ENDIF
|
|
goMock200.VerificaListaCIF('crsCoduri200Input', ldDataCurenta, lcAliasB)
|
|
lcCuiuriAnaf = gcANAFBatchCuiuriTrimise
|
|
|
|
DO WriteTestLog200 WITH lcNumeData + ' (' + DTOC(ldDataCurenta) + '): randuri CACHE,ANAF=' + TRANSFORM(IIF(USED(lcAliasA),RECCOUNT(lcAliasA),-1)) + ;
|
|
' randuri ANAF,CACHE=' + TRANSFORM(IIF(USED(lcAliasB),RECCOUNT(lcAliasB),-1)) + ' abtineri(cuiuri trimise sub CACHE,ANAF)=' + TRANSFORM(GETWORDCOUNT(lcCuiuriCache,','))
|
|
|
|
lnIdentice = 0
|
|
lnDivergente = 0
|
|
lnAbtinute = 0
|
|
lnAsteptateDivergente = 0
|
|
lnAsteptateAbtinute = 0
|
|
|
|
SELECT crsGrupuri200
|
|
SCAN
|
|
LOCAL lnCuiCurent2, lnGrupCurent, llGasitA, llGasitB, lnTvaA, lnTvaIA, lnInactA, lnTvaB, lnTvaIB, lnInactB, llAbtinut, llDivergent
|
|
lnCuiCurent2 = cui
|
|
lnGrupCurent = grup
|
|
|
|
llGasitA = .F.
|
|
IF USED(lcAliasA)
|
|
SELECT (lcAliasA)
|
|
LOCATE FOR cui = lnCuiCurent2
|
|
llGasitA = FOUND()
|
|
IF llGasitA
|
|
lnTvaA = IIF(tva,1,0)
|
|
lnTvaIA = IIF(tvaincasare,1,0)
|
|
lnInactA = IIF(inactiv,1,0)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
llGasitB = .F.
|
|
IF USED(lcAliasB)
|
|
SELECT (lcAliasB)
|
|
LOCATE FOR cui = lnCuiCurent2
|
|
llGasitB = FOUND()
|
|
IF llGasitB
|
|
lnTvaB = IIF(tva,1,0)
|
|
lnTvaIB = IIF(tvaincasare,1,0)
|
|
lnInactB = IIF(inactiv,1,0)
|
|
ENDIF
|
|
ENDIF
|
|
|
|
llAbtinut = (',' + TRANSFORM(lnCuiCurent2) + ',') $ (',' + lcCuiuriCache + ',')
|
|
llDivergent = .F.
|
|
IF llGasitA AND llGasitB
|
|
llDivergent = (lnTvaA <> lnTvaB) OR (lnTvaIA <> lnTvaIB) OR (lnInactA <> lnInactB)
|
|
ELSE
|
|
llDivergent = .T. && lipsa unui rand e ea insasi o divergenta de raportat
|
|
ENDIF
|
|
|
|
IF llDivergent
|
|
lnDivergente = lnDivergente + 1
|
|
* dupa corectia mock-ului (sensibil la data), NU mai e asteptata nicio divergenta,
|
|
* in niciun grup, la nicio data - orice divergenta ramasa e categoria (c), bug real
|
|
DO WriteTestLog200 WITH ' DIVERGENT (NEASTEPTAT - posibil bug) ' + lcNumeData + ' cui=' + TRANSFORM(lnCuiCurent2) + ' grup=' + TRANSFORM(lnGrupCurent) + ;
|
|
' CACHE,ANAF(tva=' + TRANSFORM(lnTvaA) + ' tvainc=' + TRANSFORM(lnTvaIA) + ' inactiv=' + TRANSFORM(lnInactA) + ')' + ;
|
|
' ANAF,CACHE(tva=' + TRANSFORM(lnTvaB) + ' tvainc=' + TRANSFORM(lnTvaIB) + ' inactiv=' + TRANSFORM(lnInactB) + ')'
|
|
ELSE
|
|
lnIdentice = lnIdentice + 1
|
|
ENDIF
|
|
|
|
IF llAbtinut
|
|
lnAbtinute = lnAbtinute + 1
|
|
IF lnGrupCurent = 2 AND lnDateIdx = 3
|
|
lnAsteptateAbtinute = lnAsteptateAbtinute + 1
|
|
ENDIF
|
|
ENDIF
|
|
|
|
SELECT crsGrupuri200
|
|
ENDSCAN
|
|
|
|
DO WriteTestLog200 WITH lcNumeData + ' REZULTAT: identice=' + TRANSFORM(lnIdentice) + ;
|
|
' divergente=' + TRANSFORM(lnDivergente) + ' (asteptat: 0, in orice grup, la orice data)' + ;
|
|
' abtinute=' + TRANSFORM(lnAbtinute) + ' (asteptate=' + TRANSFORM(lnAsteptateAbtinute) + ')'
|
|
|
|
IF USED(lcAliasA)
|
|
USE IN (lcAliasA)
|
|
ENDIF
|
|
IF USED(lcAliasB)
|
|
USE IN (lcAliasB)
|
|
ENDIF
|
|
ENDFOR
|
|
|
|
CATCH TO loExc200
|
|
DO WriteTestLog200 WITH 'CATCH ErrorNo=' + TRANSFORM(loExc200.ErrorNo) + ' Message=' + loExc200.Message + ' Proc=' + loExc200.Procedure + ' Line=' + TRANSFORM(loExc200.LineNo)
|
|
|
|
FINALLY
|
|
DO CurataIstoric200
|
|
ENDTRY
|
|
|
|
DO WriteTestLog200 WITH 'GATA'
|
|
QUIT
|
|
|
|
PROCEDURE WriteTestLog200
|
|
LPARAMETERS tcMesaj
|
|
STRTOFILE(TTOC(DATETIME()) + ' ' + tcMesaj + CHR(13)+CHR(10), gcTestLog, 1)
|
|
ENDPROC
|
|
|
|
PROCEDURE VpaErr200
|
|
LPARAMETERS tnErr, tcMsg, tcProg, tnLine
|
|
DO WriteTestLog200 WITH 'ON ERROR nEroare=' + TRANSFORM(tnErr) + ' mesaj=' + tcMsg + ' program=' + tcProg + ' linia=' + TRANSFORM(tnLine)
|
|
ENDPROC
|
|
|
|
*-- sterge cele 200 CUI reale ale acestui test din ISTORIC_CODURI_FISCALE (citite din fisierul
|
|
*-- codes_200_reale.txt) - nu atinge alte coduri din alte suite/benzi
|
|
PROCEDURE CurataIstoric200
|
|
LOCAL lcCodesFileC, lcCodesTextC, lcListaC, lnIC, lnCountC
|
|
LOCAL ARRAY laCodesC[1]
|
|
LOCAL lnSterse
|
|
lcCodesFileC = "D:\ROA\ROACONT\COMUN\utile\Teste\cache_anaf\codes_200_reale.txt"
|
|
IF !FILE(lcCodesFileC)
|
|
DO WriteTestLog200 WITH 'CurataIstoric200: fisier de coduri lipsa, nimic de sters'
|
|
RETURN
|
|
ENDIF
|
|
lcCodesTextC = FILETOSTR(lcCodesFileC)
|
|
lnCountC = ALINES(laCodesC, lcCodesTextC)
|
|
lcListaC = ''
|
|
FOR lnIC = 1 TO lnCountC
|
|
IF !EMPTY(ALLTRIM(laCodesC[lnIC]))
|
|
lcListaC = lcListaC + IIF(EMPTY(lcListaC),'',',') + ALLTRIM(laCodesC[lnIC])
|
|
ENDIF
|
|
ENDFOR
|
|
IF EMPTY(lcListaC)
|
|
RETURN
|
|
ENDIF
|
|
*!* 01.08.2026 marius.mutu: watermark invalid - nu sterg nimic (fara el, DELETE ar lovi tot istoricul comun)
|
|
IF TYPE('gnIdMaxIstoric200') <> 'N' OR gnIdMaxIstoric200 <= 0
|
|
DO WriteTestLog200 WITH 'CurataIstoric200: SARIT - watermark invalid, nu sterg nimic'
|
|
RETURN
|
|
ENDIF
|
|
*!* 01.08.2026 marius.mutu: garda pe ID > watermark (nu SCHEMA_SURSA - stergea randuri de referinta proprii)
|
|
lnSterse = goExecutor.oExecuta([DELETE FROM ISTORIC_CODURI_FISCALE WHERE ID > ] + TRANSFORM(gnIdMaxIstoric200) + [ AND COD_FISCAL_N IN (] + lcListaC + [)])
|
|
=goExecutor.oExecuta('COMMIT')
|
|
DO WriteTestLog200 WITH 'CurataIstoric200: sters=' + TRANSFORM(lnSterse)
|
|
ENDPROC
|
|
|
|
*-- 'YYYY-MM-DD' (formatul mock-ului ANAF, mock_batch_anaf.prg) dintr-o Date VFP; data goala -> '' --
|
|
PROCEDURE Dtoiso200
|
|
LPARAMETERS tdVal
|
|
IF EMPTY(tdVal)
|
|
RETURN ''
|
|
ENDIF
|
|
RETURN LEFT(DTOS(tdVal),4) + '-' + SUBSTR(DTOS(tdVal),5,2) + '-' + SUBSTR(DTOS(tdVal),7,2)
|
|
ENDPROC
|
|
|
|
*-- subclasa care forteaza ordinea printr-o variabila publica (gcForceOrdine200), ca sa nu scriu
|
|
*-- in OPTIUNI (tabela partajata cu alte benzi care ruleaza in paralel pe aceeasi schema) - acelasi
|
|
*-- tipar folosit de S6 in testul lui propriu (docs\diff-S6-citire-cache.md)
|
|
DEFINE CLASS VerificareANAFMockBatchOrdine200 AS VerificareANAFMockBatch
|
|
PROCEDURE OrdineCache
|
|
LPARAMETERS tcTraseu
|
|
RETURN gcForceOrdine200
|
|
ENDPROC
|
|
ENDDEFINE
|