Vh&kdZddlZddlZddlmZddlmZddlmZddl m Z m Z m Z ddl mZddlmZmZdd lmZmZmZmZdd lmZmZmZmZmZmZmZdd l m!Z!dd l"m#Z#dd l$m%Z%m&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,m-Z-m.Z.ddl/m0Z0ddl1m2Z2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddlm?Z?ddl@mAZAddlBmCZCmDZDmEZEddlFmGZGmHZHmIZImJZJmKZKddlLmMZMmNZNmOZOmPZPddlQmRZRmSZSmTZTmUZUddlVmWZWmXZXddlYmZZZmZd d!l[m\Z\m]Z]d"d#l^m_Z_eGd$d%Z`ee(jGd&d'e7ZbGd(d)eZZcGd*d+eZdGd,d-eZeGd.d/eZfGd0d1egZhGd2d3ZieGd4d5ZjGd6d7ZkGd8d9egZlGd:d;ZmeGd<d=ZneGd>d?Zoy)@z- Tests for L{twisted.trial._dist.disttrial}. N)partial)StringIO)sep)CallableListSet)TestCase) implementerverify)Factoryassocdefinefield) assert_thatcontains ends_withequal_to has_lengthnone starts_with)AllOf)given)booleans sampled_from) interfaces) ReactorBase)CancelledErrorDeferredsucceed) ProcessDone)ProcessProtocolProtocol)AlternateReactor)MemoryReactorClock)Failure)FilePath)FilesystemLock)_WORKER_AMP_STDIN) DistReporter)DistTrialRunner WorkerPoolWorkerPoolConfig) countingCalls discardResult fromOptional iterateWhilesequence) LocalWorker RunResultWorker WorkerAction)Reporter TestResult TreeReporterUncleanWarningsReporterWrapper) ErrorHolder TrialSuite)SynchronousTestCaser ) erroneoussample)matches_resultcLeZdZUdZeeeZee e d<dZ dZ y) FakeTransportz* A simple fake process transport. default_closedcy)z% Ignore write calls. N)selffddatas W/home/dcms/DCMS/lib/python3.12/site-packages/twisted/trial/_dist/test/test_disttrial.py writeToChildzFakeTransport.writeToChildIsc:|jj|y)z> Mark one of the child descriptors as closed. N)rFadd)rIrJs rL closeChildFDzFakeTransport.closeChildFDNs rNN) __name__ __module__ __qualname____doc__rr setrFrint__annotations__rMrQrHrNrLrCrCAs*gcl3GSX3 rNrCcDeZdZdZdZdZdZdZdidddddfdZdZ dZ y) CountingReactorz A fake reactor that counts the calls to L{IReactorCore.run}, L{IReactorCore.stop}, and L{IReactorProcess.spawnProcess}. rc<tj|||_yN)r$__init___workers)rIworkerss rLr]zCountingReactor.__init__`s##D) rNrHNc |jj||jt|xjdz c_y)z See L{IReactorProcess.spawnProcess}. @param workerProto: See L{IReactorProcess.spawnProcess}. @param args: See L{IReactorProcess.spawnProcess}. @param kwargs: See L{IReactorProcess.spawnProcess}. r@N)r^appendmakeConnectionrC spawnCount) rI workerProto executableargsenvpathuidgidusePTYchildFDss rL spawnProcesszCountingReactor.spawnProcessds4& [)""=?3 1rNctj|d|jvr|jdddd|xjdz c_y)z+ See L{IReactorCore.stop}. beforeshutdownrr@N)r$stoptriggers stopCountrIs rLrqzCountingReactor.stop{sN % t}} $ 5DMM( #J / 21 5 7 !rNc|xjdz c_d|_d|_|jD]\}}}||i||j |xj dzc_y)z* See L{IReactorCore.run}. r@TN)runCountrunninghasRunwhenRunningHooksrqrs)rIfrfkwargss rLrunzCountingReactor.runsa    #44 OAtV t v    !rN) rRrSrTrUrcrsrvr]rmrqr|rHrNrLrZrZUsC JIH     . rNrZc.eZdZdZdZdZdZdZdZy)CountingReactorTestsz' Tests for L{CountingReactor}. cFg|_t|j|_yr\)r_rZreactorrts rLsetUpzCountingReactorTests.setUps &t||4 rNc`tjtj|jy)zJ L{CountingReactor} instances provide L{IReactorProcess}. N)r verifyObjectrIReactorProcessrrts rLtest_providesIReactorProcessz1CountingReactorTests.test_providesIReactorProcesss J66 ErNc|j|jjt}dD]}|jj |t j t j g|j|j|j|j|g|z|j|jj|y)z The process protocol for a spawned process is connected to a transport and appended onto the provided C{workers} list, and the reactor's C{spawnCount} increased. r@)rfN) assertFalserrcr"rmsysre assertTrue transport assertEqualr_)rIprotocounts rLtest_spawnProcessz&CountingReactorTests.test_spawnProcesss 001  =E LL % %eS^^3>>BR % S OOEOO ,   T\\E7U? ;   T\\44e <  =rNc|j|jjdD]B}|jj|j |jj|Dy)zB Stopping the reactor increments its C{stopCount} rN)rrrsrqr)rIrs rL test_stopzCountingReactorTests.test_stopsU //0 .fakeSpawnProcesss/   Z (   T "   s #rNfoor@rr= PYTHONPATH) rr!r_launchWorkerProcessesrrosrhexistspathsepjoinr)rIirrrrs @@rLtest_launchWorkerProcessesz*WorkerPoolTests.test_launchWorkerProcessess 16a91_&9 9   $ (()99ugN 1y|4 y|45  ! - 2K 4MN5:sC2cD|jjg|jjt g}|j |}|j fd}|j |tt|jjy)zY C{run} dispatches the given action to each of its workers exactly once. c8tj|Sr\)rra)wr_s rLz*WorkerPoolTests.test_run..sq0A(BrNN) rmakedirsrstartrZsuccessResultOfr|rrrr)rIstartingstartedrwr_s @rLrzWorkerPoolTests.test_run sw 99???2#67&&x0++BC W%GZ (>(>?@rNc|jjt|jjdz}|j |j |j|jtg}|j|jj|}|j|j|jjdy)z L{WorkerPool.start} checks if the test directory is already locked, and if it is generates a name based on it. z.lockz _trial_temp-1N)rrr'rrhrlock addCleanupunlockrZrrrrsibling)rIr fakeReactorrs rLtest_runUsedDirectoryz%WorkerPoolTests.test_runUsedDirectorys d33887BC  $  $&b) &&tyy{'CD   $ $  ! ! ) )/ : rNc 6|jjtg}|j|jj |}t j|j}|j||jD]}t|jjtt|jjD]}|j!||j"|j$fD]}|t't)dt|j|t+t|j,j.t1dt|j2j4t1dy)z L{StartedWorkerPool.join} causes all of the workers to exit, closes the log file, and unlocks the test directory. rTFN)rrrZrrrr fromCoroutinerassertNoResultr^rrrFrr(childConnectionLost processExited processEndedr%r rtestLogclosedr testDirLocklocked)rIrrjoiningrrJrzs rL test_joinzWorkerPoolTests.test_join3s- !"%&&tyyw'?@((8 G$!! +A  ++X6G-H Ikk)) *%%b) *ooq~~6 +'+a.)* +  + D((146:GOO**HTN;G''..@rNrsubdirabsoluterreturnNc|r |jjtz|z}t|j|}|r t |}n9t t|jjtt|z}t|}|j|jtg}t|jj |y)z L{WorkerPool.start} creates a L{StartedWorkerPool} configured with a log file based on the L{WorkerPoolConfig.logFile}. )rN)rrhrr rrrrrrr+rrrZrrname)rIrrrmatchesrrs rL test_logFilezWorkerPoolTests.test_logFileHs kk&&,w6Gt{{G4 w'GF33889#-( G&!&&tzz/"2E'FGGOO(('2rN)rRrSrTrUrrrrrrrrrrboolstrrrHrNrLrrsx , *OB A 0A*  W%  3T3C3D33rNrceZdZdZeej dgZdZdZ dZ ddZ dZ d Z dd Zdd Zdd Zdd ZdZdZddZddZddZdZy)DistTrialRunnerTestsz' Tests for L{DistTrialRunner}. test_fooc tt|jtdgt t dt g}|j|tdi|S)z. Create a runner for testing. rT)autostop)reporterFactoryrstream maxWorkersrworkerPoolFactoryrrH) dictr8rrrLocalWorkerPoolrZrr*)rI overridesrfs rL getRunnerzDistTrialRunnerTests.getRunnerrsS(![[]:%oE#B'  I&&&rNct}tt|}|j}|j ||j |j dkDy)ze L{DistTrialRunner.writeResults} writes to the stream specified in the init. rN)rr)r6r writeResultsrtell)rIstringIOresultrunners rLtest_writeResultsz&DistTrialRunnerTests.test_writeResultssK :hx01!F#  !+,rNc8dfd}d}d}|j||}tt|Dcgc] }tc}}|j |j |t jdjt|ycc}w)zq L{DistTrialRunner.runAsync} doesn't try to start more workers than the number of tests. Nc"t|ddi|S)NrTrakwrs rLrecordingFactoryzADistTrialRunnerTests.test_minimalWorker..recordingFactorys"A;;;DKrNr=)rrr) rr;rr rrunAsyncr_startedr_r)rIrrnumTestsrnsuiters @rLtest_minimalWorkerz'DistTrialRunnerTests.test_minimalWorkers    !5E  h@1HJ@A V__U34DMM!$,,j.BCAsBNc|jd}|j|j}|j|}|j |t |j |j ty)z Running with the C{unclean-warnings} option makes L{DistTrialRunner} uses the L{UncleanWarningsReporterWrapper}. T)uncleanWarningsN)rrrrrr)originalr9)rIrdrs rLtest_runUncleanWarningsz,DistTrialRunnerTests.test_runUncleanWarningss[ 5 OODJJ '%%a( fl3 foo/MNrNc t}|j|}|j|jt }|j |t |j}|jd||jd|y)zA L{DistTrialRunner} can run an empty test suite. rRunning 0 testPASSEDN) rrrrr;rr)getvalueassertIn)rIrrroutputs rLtest_runWithoutTestz(DistTrialRunnerTests.test_runWithoutTestsov.%%foojl&CD fl3" &/ h'rNctdttd}t}|j |}|j |j |}|j|t|j}|jd||jd||jd||jd||jd|y)z Even if there is no test, the suite can contain an error (most likely, an import error): this should make the run fail, and the error should be printed. zan errorzfoo barrrzerrors=1FAILEDN) r:r% RuntimeErrorrrrrrr)rr)rIerrrrrrs rL!test_runWithoutTestButWithAnErrorz6DistTrialRunnerTests.test_runWithoutTestButWithAnErrors *gl9.E&FGv.%%fooc&:; fl3" &/ i( j&) j&) h'rNc,|jt}|j|j|j}|j j }t|tdt|ddjtty)z If for some reasons we can't connect to the worker process, the error is recorded in the result object. rr@rN) rBrokenWorkerPoolrrrr errorsrrtyperWorkerPoolBrokenrIrrrs rLtest_runUnexpectedErrorz,DistTrialRunnerTests.test_runUnexpectedErrorsm 2BC%%foodjj&AB''FJqM*F1IaL%%x0@'ABrNc|jt}|jt5|j |j dddy#1swYyxYw)z If the reactor is stopped by C-c (i.e. `run` returns before the test case's Deferred has been fired) we should cancel the pending test run. rN)rr assertRaisesrr|r)rIrs rLtest_runUnexpectedErrorCtrlCz1DistTrialRunnerTests.test_runUnexpectedErrorCtrlCsG /B   ~ . # JJtzz " # # #s AAcL|jtttd}|j |j |j }|jj}t|tdt|ddjtty)z~ If for some reason the worker process cannot run a test, the error is recorded in the result object. T) workerFactoryrrr@rN)rrr_BrokenLocalWorkerrrrr rrrrr WorkerBrokenr s rLtest_runUnexpectedWorkerErrorz2DistTrialRunnerTests.test_runUnexpectedWorkerErrors %/AD   %%foodjj&AB''FJqM*F1IaL%%x '=>rNcdfd}|j|}tj|j|j}|j dJj dj}|j||jd|j|}|j|ty)zG L{DistTrialRunner} waits for the worker pool to stop. Nc"t|ddi|S)NrFrrs rLrzPDistTrialRunnerTests.test_runWaitForProcessesDeferreds..recordingFactorys"A<< ? < II5 6--"++ A%%a( fl3rNc ft}ttjdt j dtjdg}|j |dd}|j|}|j|}t|jtdtdy ) z L{DistTrialRunner} can run in C{exitFirst} mode where it will run until a test fails and then abandon the rest of the suite. r test_failtest_barTr)r exitFirstrr@) successesfailuresN) rr;r?FooTestr>TestRegularFailrrrrr rAr)rIrrrr rs rLtest_exitFirstz#DistTrialRunnerTests.test_exitFirst s z*))+6z*  v!L OOE "%%a( OO #A  rNcjt}tjd}|j|}|j |d}|j |}|j d|j|j|j|j}|j |jd|jdz d|jd |tdd D]}|jd |||j |jd |jd y)z L{DistTrialRunner} can run in C{untilFailure} mode where it will run the given tests until they fail. test_itrT) untilFailurerr@z expected to see PASSED in outputFAILz Test Pass zRan 1 tests inz2expected to see per-iteration test count in outputN)rr>EventuallyFailingTestCaserrrrrr wasSuccessfulrrrr)rIrcaserr rrrs rLtest_runUntilFailurez)DistTrialRunnerTests.test_runUntilFailure"s 229=v. OODtO 4%%a( DFF# --/0"  LL " FFQJ . ff%q! 4A MMJqc*F 3 4  LL) * FF @ rNc|j}|j|j}t|j t dt|j t dy)zw L{DistTrialRunner.run} returns a L{DistReporter} containing the result of the test suite run. Tr@N)rr|rrrArr5)rIrrs rLrzDistTrialRunnerTests.test_runEsM !DJJ'F((*HTN;F$$hqk2rNc0tg}t|5|jd}dddj|j}t |j tgt |jtgt |jtdt |jtdt |jtdt |jtdy#1swYxYw)z L{DistTrialRunner.run} uses the installed reactor L{DistTrialRunner} was constructed without a reactor. NrTr@) rZr#rr|rrrrr6rAr5rvrs)rIrrrs rLtest_installedReactorz*DistTrialRunnerTests.test_installedReactorOs ""% g & 2^^D^1F 2DJJ'FMM8B<0FOOXb\2F((*HTN;F$$hqk2G$$hqk2G%%x{3 2 2s D  DcGddt}ttjGdd}Gdd}t |5|j t 5|jdddddddt |5|j t 5|jdddddddt |5|j t 5|jdddddddy#1swYxYw#1swYxYw#1swYsxYw#1swYwxYw#1swYBxYw#1swYyxYw) z L{DistTrialRunner} raises L{TypeError} if the installed reactor provides neither L{IReactorCore} nor L{IReactorProcess} and no other reactor is given. ceZdZdZy)=DistTrialRunnerTests.test_wrongInstalledReactor..Corecyr\rHrts rL installWakerzJDistTrialRunnerTests.test_wrongInstalledReactor..Core.installWakergsrNN)rRrSrTrLrHrNrLCorerJfs rNrMc eZdZ ddZy)@DistTrialRunnerTests.test_wrongInstalledReactor..ProcessNc yr\rH) rIrrerfrgrhrirjrkrls rLrmzMDistTrialRunnerTests.test_wrongInstalledReactor..Process.spawnProcesslsrN)NNNNFN)rRrSrTrmrHrNrLProcessrOjs rNrQc eZdZy)@DistTrialRunnerTests.test_wrongInstalledReactor..NeitherNrRrSrTrHrNrLNeitherrSz rNrUNrF)rr rrr#r# TypeErrorr)rIrMrQrUs rLtest_wrongInstalledReactorz/DistTrialRunnerTests.test_wrongInstalledReactor_s7 ;  Z// 0   1   gi ( -""9- -t, - - df % -""9- -t, - - gi ( -""9- -t, - - - - - - -  - - - -  - - - -slD(&D9D(E/D4E"E8E  ED% !D((D14D= 9EE  E EE!cGddtfd}|j|}|j5|j|jdddy#1swYyxYw)z If there is an unexpected exception running the test suite then it is re-raised by L{DistTrialRunner.run}. c eZdZy);DistTrialRunnerTests.test_runFailure..BrokenFactoryNrTrHrNrL BrokenFactoryr[rVrNr\cr\rH)rfr{r\s rL brokenFactoryz;DistTrialRunnerTests.test_runFailure..brokenFactorys / !rNrN) Exceptionrr#r|r)rIr^rr\s @rLtest_runFailurez$DistTrialRunnerTests.test_runFailuresY I  "-@   } - # JJtzz " # # #s AA'rN)rRrSrTrUr;r?r7rrrrr rrr!r$r)r0r9rCrrGrXr`rHrNrLrrksv z23 4E' -D, O ((& C# ?42 2! F34 +-Z#rNrc8eZdZdZddZddZddZddZddZy) FunctionalTestsz8 Tests for the functional helpers that need it. Ncttddtdttddtdy)z ``fromOptional`` accepts a default value and an ``Optional`` value of the same type and returns the default value if the optional value is ``None`` or the optional value otherwise. r@Nr)rr/rrts rLtest_fromOptionalz!FunctionalTests.test_fromOptionals. LD)8A;7LA& 4rNct}t|}|j||jdt |j |t y)z ``discardResult`` accepts an awaitable and returns a ``Deferred`` that fires with ``None`` after the awaitable completes. rN)rr.rr.rrr)rIrr s rLtest_discardResultz"FunctionalTests.test_discardResultsF $: !  A 8D((+TV4rNct}t}tjt||}|jd|j ||jdt |j |tdy)z ``sequence`` accepts two awaitables and returns an awaitable that waits for the first one to complete and then completes with the result of the second one. *helloN)rrr1r.rrrr)rIrbcs rL test_sequencezFunctionalTests.test_sequencesf $:#:  " "8Aq> 2 2 A 7D((+Xb\:rNctttg}d}tjt|t|j}|j j d|j ||j j dt|j|tdy)z ``iterateWhile`` executes the actions from its factory until the predicate does not match an action result. c |dk7S)NrirH)values rL predicatez4FunctionalTests.test_iterateWhile..predicates B; rNrriN) rrr0listpopr.rrrr)rIactionsrqr s rLtest_iterateWhilez!FunctionalTests.test_iterateWhiles )1 HJ 'K $11 DM$5$5 6   q! A  r"D((+Xb\:rNctdtdtfd}tddD]}t|t |y)z ``countingCalls`` decorates a function so that it is called with an increasing counter and passes the return value through. rrc |dzS)Nr@rH)rs rLtargetz2FunctionalTests.test_countingCalls..targets q5LrNr@ N)r-rWrrr)rIrxexpecteds rLtest_countingCallsz"FunctionalTests.test_countingCallssL  c c   a  6H (8"4 5 6rNra) rRrSrTrUrergrmrur{rHrNrLrcrcs 5 5 ;;2 6rNrcceZdZdZy)rzx An exception for ``StartedWorkerPoolBroken`` to fail with to allow tests to exercise exception code paths. NrRrSrTrUrHrNrLrrsrNrc.eZdZdZdedddfdZddZy)StartedWorkerPoolBrokenzn A broken, started worker pool. Its workers cannot run actions. They always raise an exception. workerActionNrcKtwr\)r)rIrs rLr|zStartedWorkerPoolBroken.runs   c Kywr\rHrts rLrzStartedWorkerPoolBroken.joins sra)rRrSrTrUr5r|rrHrNrLrrs$ !l4&8!T!rNrc@eZdZUdZeed<dejdefdZ y)rzF A worker pool that has workers with a broken ``run`` method. _configrrcKtSwr\)r)rIrs rLrzBrokenWorkerPool.start s'((rN) rRrSrTrUr,rXrrrrrHrNrLrrs*)!11) )rNrc$eZdZdZdededefdZy) _LocalWorkerz A L{Worker} that runs tests in this process in the usual way. This is a test double for L{LocalWorkerAMP} which allows testing worker pool logic without sending tests over an AMP connection to be run somewhere else.. rBrrcHKt|gj|ddiSw)z8 Directly run C{case} in the usual way. successT)r;r|rIrBrs rLr|z_LocalWorker.runs( D6v&4  s "N)rRrSrTrUPyUnitTestCaser7r3r|rHrNrLrrs!!n!j!Y!rNrceZdZdZy)r(zE A worker tried to run a test case but the worker is broken. Nr}rHrNrLr(r( srNr(c$eZdZdZdededdfdZy)r'z: A L{Worker} that always fails to run test cases. rBrrNcKtw)z@ Raise an exception instead of running C{case}. )r(rs rLr|z_BrokenLocalWorker.run+snr)rRrSrTrUrr7r|rHrNrLr'r'&s!njTrNr'c^eZdZUdZeeed<eeed<e ded<de dddfdZ d Z y) StartedLocalWorkerPoolz' A started L{LocalWorkerPool}. rr_Nr-rrcRK|jD]}||d{y7w)z8 Run the action with each local worker. N)r_)rIrworkers rLr|zStartedLocalWorkerPool.run<s,ll 'Fv& & & ' &s '%'c8K|jd{y7wr\)r-rts rLrzStartedLocalWorkerPool.joinCsmms ) rRrSrTrUr&rrXrr4rr5r|rrHrNrLrr2sDsm# &\tn'l4&8'T'rNrceZdZUdZeed<eeeZ e e ed<dZ e ed<eZegefed<dej&d e fd Zy ) rz_ Implement a worker pool that runs tests in-process instead of in child processes. rrDrF _autostop_workerFactoryrrcBKt|jjDcgc]}|j}}t |jj ||j r tdn t}|jj||Scc}wwr\) rrrrrrrrrrra)rIrrr_rs rLrzLocalWorkerPool.startSs}38 8O8O2PQQ4&&(QQ( LL ) ) "nnWT](*  W%Rs"BBA$BN)rRrSrTrUr,rXrr rrrrrrrrrrr4rrrrHrNrLrrGs` -274=-IHd)*IIt+7NHRZ(7 !11   rNr)prUrr functoolsrioros.pathrtypingrrrunittestr rzope.interfacer r attrsr r rrhamcrestrrrrrrrhamcrest.core.core.allofr hypothesisrhypothesis.strategiesrrtwisted.internetrtwisted.internet.basertwisted.internet.deferrrrtwisted.internet.errorr twisted.internet.protocolr!r"#twisted.internet.test.modulehelpersr#twisted.internet.testingr$twisted.python.failurer%twisted.python.filepathr&twisted.python.lockfiler'twisted.trial._distr( twisted.trial._dist.distreporterr)twisted.trial._dist.disttrialr*r+r,twisted.trial._dist.functionalr-r.r/r0r1twisted.trial._dist.workerr2r3r4r5twisted.trial.reporterr6r7r8r9twisted.trial.runnerr:r;twisted.trial.unittestr<testr>r?matchersrArCrrZr~rrrcr_rrrrr(r'rrrHrNrLrs &&/.//+8'-DD.?@7*,219WWTS 9@%$& Z ' '(?(?)?D5;.5;pX3hX3vq#8q#h K6hK6\y   ) ) )!!"9  (rN