@avեUv% :]0# c p "c~ ] tb(N0X]l]S0"@s#-xvXyrlu#mv. RB$wt "C| `oh~hx*Q- (ϛL.@ĵZY^
*kKjmv57=a ]xi&wN- ~
gFDי^"Ya=vM/Z =>S
gI.\ N{J6cjpL&!2o@Dtٹ%" ft 㾞InYQ;R;TZUv04}L 3z;!2M u"J̈bt3N0VR;{h
g$j84QdVuL m.Z9 z pspDM,DW1ń)j4 }O1i7|cZDg߸ &!,ݤA ?:D<\ t`(F"w[Q ΑZƄ#{ҞVyGazȬvm{A1l$! 4Vw]g \ /v c(n@߃f 3Ft~͌0!%߆pGȣ2=( Cdu"r3" ]GH _<1/id7Q`h] VX_{P0
ͮ,wMe(u. x/ g& J;,L㌆^C՜8HxR1Fid'VqBbYb7K2!@ hw1;
;+,Q ?:ÂQ,3h+-Rr0N
v{v<2ZP:m6!7Dpe~ui?hTPVmdBW /]/ ~ 7YFMDQ K@Sșk)ŝg=M
)Ab,FByf:,@薶?_o]nTa9y% 9 \ `FD3(r#
6"
4Si:h;1,WrYJ?3 C.qMviwQtU<@x43^[\z-ADb(m P=s _083͋D)櫋fnG6 -C$MؾM vޓq)͞n! pu"J fDD 0 f|ryoGys*%$8Q#W
Aw l wM_WE^˨wOT Yex7HY,%,0V8hΘG*on¢13m*!U [[A:kh4EY gxΎ'~!(,%aΗd6} cgh0ֳIJ$Ɨ \)nK/nH x I}7g͇*Xw Nn Ov w{X*à ǡ_a$}`8W.gIWʹˣE \wvv7hްXWEy u
: }HBD73"Ds$v-LlXYwpX<{)_VW6sv͆
}P>ZN1 *!\.b\4'JD ^"<\i{x9(0 y+8NO2̌\繑pd7HQdz֥AFfi
>:%% !(>,%D raڬ=y.ǜD]ډtJDxpFƗյͼ,b2&ۯ_>{CC!9סnHA(QO CP~\ x(!3L[W8PXHE<;
NZD?2 ( AKfuu3ctuHgVi5:$|k}d< o3&u1Dts%"JU #A.!٪" LQ[`|Y]k⥦,^f
`v4@\rIJAN| mC(!\gN?%4(;fii$ize!&*6W^WW6suQ]8(h5+۟YMv={ ) = :q# w]q_eC(!ҎMNN[:v.bԌrTw3yoLyvC],6K{ˍJ? Uf{ ;vwƕ< |'}qfޛ|Dtv%"JZ
Fgrf!c2U͗~bC+5o}y32p3U0MviwIUT]g̲n Ri: x^y k ^"NP5GKwje' D,ͬJEbqni{ko} >-;dc\J?} A,y8όhf(IƈrITIc4[y7KUg2Ll84~cYگv7 )_,#SPl q)j /ɼ L7N< ] c(I%5N~7a?ԜܘeT"M_,T [[^ZweUDwuŭПS|#|3 ^=8s :N/8\Q]κT|_J8Ϭ8h
U)R~歯mLlhh}
Aw l w. ,~qBsM\
U :M/;yMo"Jh4,QKԈHQ ѨhTgL0 hlF%̝{{=eg LޯW2=;3z: !~χO K3{RD fJ)5D ~f|0,ήŵä \8k%]gad~ юQ3EٰyK%6Bɲ7
v盕ݻ.&օ$n|gP x!fɃ;Rj`RCd ̾7Q)hlƘsƐnlæ\P4{ޝd >R\g~eƽ x]] 08sp!R321,;Y10kHD :&u0ܾIssy f" Dx*Pk99@s g8wiL)Fe舍a|]X,4kc3I1 cC*m͒͢Vz9 k]{gjSwt%s5M}~! ;!
8?u|Z| U*`R#P/UFQ/EF;_ŀ1_Eĸf_rfIg,k7l./۬[~!/6'wϭ.oqԊêHs}8 k7w=iL)F;k ꖫ>o0kCcQI6AD8fkAfni7#w[S[i7٠k.O%`HC~gYc|PJݕ̔RjDV j"w-hv `͜ }>d.o C Wmd&UW 5~vG
>
l D)u'-)ԈzV֙`ժTlnf㵫oHfmfKeqGRkm{74&ZXS ?s ;
7M=\Gp \~U*1`R#G_lB
þ;@l={ 6Z0K)[0k6n)W6c+ /O/3\nq^IC&.n$FᎣxr ;R*3O|h0cISϠ`wDqZވd }j읳l#7߬5vq6. &qf9-%_쁾 ?0kf? B)3)# X\,'DldXf^IDrtKf6,NuvU h:}wuH ;! >f}
͚x>^"3-)Rz0+4tyML `dz_1k}8} WԻ+Ml;aV;;Sn1k*^w%x)%Je̔RjNؼscjw+l4k{T |7nE욞 MJ7n-hc$9x+vJW R7^}wk
8yqִoLyL!UJ)O=ob ˳I3V R]-*(PA̒D\N{`r>.e-ZYw*M[0M L@|;
|xTͮRJye`.Ƽl C0l`tYBQq"vͲ?vSl k9.^!=SqCP$ A` x*04:1NyJ̔R#$Xss&eII\%aU:䬩Cxf tzcZu"pQ%uS WfG:]Ol_ Btzvwl@r`k }R:nȔ}F.u֣~&1
s{ng) (k?W1?UJ)ώ^&Us 44y `wXhStn,͞BLNLt9Ad P:Re|*
̅brnp58
/s2_!R01TjhL) }G#Y;NJ[ n$H_j0h7kCW2
#;.'oi||բ}?#Ǫs d!.e|ȐWO B,тRJ% ]%>34[c j6TR5֨x &+sd]*3p$0MQ s88fm07N?'Ñ e d l bZ ;"A
-)TR5n_Z qc6aжH6αZgEt]ne eF_?
a.
kfieO'}NKk 5?Vs|Ȑu%@*g*4Z0SJ%` +lw*3H3!#1W+70cu`0g;d
:ESܰacaϰ6F䒯|Ǣ 9 4! ;;D:!-)TBf "vYY<ϬaʈI|'rA/nc06aT_L"vͰ;lwaӦmvzIwCC,|:\h xJ̔R*Aڑ Kb+v E=e&:lę~?9JFYI5b* 6n;kK"wΐCkg:47pf +_!Kj
iL)&?kv㨮7lMMaYuDg\&-R
zo2 uŘPčt(v}_`~ߕ|ș"qA(".nj1'ψSJ̔R*anZZNuV&B`&|g8qDBf Z0[N2O#_XF˂5vۑ+jy'۷hP@|$QG|Ș7 ;Ri3J ŵZHdS
.͈a$Fjيa;9Ӌ*[e]M[:<ЙZ;w9 xp p s
+!2 \l DɽRJKǸy~TlDboeݬd`]s~7:ZT'rYvQ>_ gQǕds`s'QO!]C <}pwz4s.2tHQтRJ%-0QW|}_*?fiFd F-CߕfZɲ8 z+|qf`Z}~w y(Q $'|Ș' / B4Iʝ- t&X]bɌ| @]^ gtwN8k;ID130
Pd}l]}}Y/poUVC(Z0SJ:f C}Ө"/1LI,vJ3"zdRJ:lћ6Y%W,ʺc4m"w }Hk ]ɡ0hL)8NuՅ5Hc+%3Ǭ,|gf4ЙĽ1\=rP0}Yv~?dqY7 dnڡDW;}ȘP*+`Tp w?v{AMN
5\
}g Xybɠ}÷_A7խ7&" wX|[,9&s}ȉO bӈ;ҽ;DƜv)uHf[tn犺 ބ7u&2T1Шfdu=3zr.#Z8JX*4kw x
!4૾C,:~E3d,)*q j?.b>2cðo7ⵒP43z];0,뽩H\wqAQƍآT*$StY #xt5n!R
|Ș
~ϤTRiLtӂYN=V,ϊDl&TmXW1 `vN2'D۟0X Cǖmu6}GY#|۟~ w,p%Lj "cOi-)nZ0ˉ7. Z,.''
*%vgg돊I2bVwrU & Ȥe[Co_a x X;2t5A2`x o}P*`TZ%ky~qaS0/]kIGdU "g[d7rA?q#W _lႛ>y|Ȱq~,өCdGOA#TJ#EwLJ yajqTs4.LKYelBڏB_MV3;r-ΰLsͤ \
f 6n;sLi;w!%.ɏ3 "~xJ]r@ f997_B7le0Uk7iwJ#+%ٝz7 2}2-Wu [sTqqӧkg\ \
4|!.RJ]rbmέ v _{j 9^_]n53"&WC$N2',Evcmbv}G=, F{x$!V}ȩgAx}|QʗL*3~PSF`~G:b7Vfs,w2 Cfa;5Ӌ*[l.4p;M[{LazT8ory|eC(,iTZ%ĝJN&o}cGĂwD;,:l. 9
Z\,F0\0mպM S/_\p `Qǖ :ˠsȩoK/ B! |Pʇ*cG1zbQ,I@כ !xzČ2l 3Wc+ x^?
,S8χdxu6h!5-)~G:χ6p/_sqv"GX1Cj5x46ݫ#
vwbV7#&ſ8)1l">4oR43 Fj #^ wu;DYVA%-)~Z0S E=wʼdtJTPl \ G8W;S2*" b
`fC%rVU%. dqB6?Z.dW*` 0#ni8%=%3jcYIRwQ
L s\[(U
n?\8\
bsrUNw_ "$< ܰS
|t 7!ԒG!2ŤX%J\> _ @%c f;GT*cE6
쮥N2
ǧN\`A# [ \ǘ {~q0s̑5 +
t!Բ
o!2 PTiL%Y߄%]<7?|-s$IdʃxF??&̈
ݩ^Tقn |gOG S,MCVc`^t 6&6S W#Vt$[ [
JA:-{N^*/|HB)z }0mպվDwt1 !ore\ \m 7}Q&|Ȩ
4nUj`N fK@>Cdzo\^;wƌwVqcuN~XktNolW_ވ\C黒 /<ysܼ|(Hk!|PC/@g%ĝfJeTily ;JG?w@ t3ZU=y ֎~KHku{Qi=] ϾW}U+#|Y7 x. !yRIv9gdNA̭sTeuۅmsVwR" @B0g_3tCwgAx]!2}C(ZZ0SIOzq6!Tr ^x[d fYbfUV e^e٫q|aٜ,>_+=M
b ݅RG G3cxQoT2پCd{>x3seJ,jNX;LifX媮!6lfzQe b
16_ VTൾCKFwk&OC(Z0SI7;@
V_t9p >8g ,{^+-{A@X; (Zw"iɲ8=yO
0O뾃d#!Cw x==!2e_Jjt{}H? B%ߚ~;=d׳~d7"O{*ӭp]$o;3$k^pw 8
w{ 6|t\H}BтJ:-|P}_&6YFR=tѨ4,1:&%pbg^eB)hnιͯw X wO0߾w [K<Ϭ;R˥7*H< !T=1=YFP&G!n7#\U),ֻS u,[؇g y P >x p +^ w {8&!Z.- F!T:<}]t9Fc b9E _g݉8f/{w~ ڹd-"c|X fJtУjIC( Z0SI R1#}P\t\;ǨbNtR9PX+خ^e:~pu4Ycs+|ɀW/ bBH!}!2 D҂J:-Λ!Ljf8 2V}hTg F KdYWN,6߮|gHK=dぷJon B%YO}ȰM>KTM!RwF͆y.M-{lt\^,feq+r9WZhu'ň]7DIZ`K8 $N .'ovoFbkoMA2쏀}Pj)`[a|,Yx_ذEs;˰~P[Ê]qU'佘3T"Gt9 HA=|ȸ BCтJ̿q )Z+/'o
5рxw5YJl_w
niHi$Vw/ႰџE-sC<]qu#UOp B|0 \J\W*r|R'd$ջG:|_p ߺX{2Bwa*Wl,8Lg42}WlԻ}t¨ |bXn2QLt-a\DFU6'J B癭pM~^;PM`^dfRk="l&;D=8wD f*
~;@N nx-Oח:, ^}G>s1 bd rwԒ[f
[FI)ZƑٌ1'|+;H>p7JDxQDf \AFflтJ[W<(Aj-[7Wgf£ |";ǠTo M7%zay՝(:gF I)rv f^{CY2~
i߰Db a!23G%~B 64l8Qa#2 e|g[y,ƄBg$g8(BXF!rHb,Ɖu&0. $pRX\8Ap"'`@pQXgcED0Vp)L`ZpL?Wvw6,7C %ςZ`ӏsSW|L V^ ;Hƽ xJAdUZxu-YAQ}XpNpYC߁ Qh#N!"Ep q)E$szhD^;2bbs}n3m٥eI2\G6fq8 h2 '}ȸ.<3}A f*-^ |w xY Xą'0
, ;N
[OYAkLЙ+$ǂQ$FsF5D!G!Xqb"'Ƃ pR3VZq* r-CZtUpgVe㾃 ȫ )5LVCfAT~iLɛS?# \$n<x X@P?~8 Aiǎ.0qLv|k|k>]VuR~`"qGM\4d|( n.%54u'_v %#_;Ȁ|xQwyP=C+5rZ0SiXSC(>KOf4 W}Qq-5\
wOZ0Si2 oڿ7
V;~
S $.=t oK}G>sfJFc|20 _E0O"rME 3xygfC#K;KGGQ 9 2zM f*mBmP 6`o
DG7xP@Px^*71hL/"S%&BrA hDJiL8Lsk(v嬟N!o%ފĝH|z` $>U#AThLkq g1* AsFdq9IcPc^nLW þ u.sH}İg~""[͏mp[$ yCz:p9p3՞`QjɲFFCo2]J|3Ss_,wc5]ު6{aa,Iw7ڕslkJv,<} TQ˝2;K!i K7ϹUʧ;DOG҂J S*
s ć?uʉb&GpNuoW;KRN7<`E
QPMαB#\ ^ \ &CF|,+sMm+L̍L0wKѵ(D_N&2g=YcND,d,vblqx;;KR" ?x
-JiSe:>vmXX(W Ҍ--HZٮ KI #͈u=gZ/b@'R 1 Z,SIx9` 9ʉl>VUY|P~B~ Ipg^W{ Z7*+یFe4R>a䢻uqBZUrDv .BEF LӮxY1{Jw!qwYwI CW=PZW J G@V=bk? r,E&'X+rAFN°"Q83ZhVwz fFą-E,&:N1My;̃ g#*y|xw-囓TN DAU;#_ķp}$kDԙv+E'v! 3X0C5TALJ\R*Vy%Gvޙ_eޜ88w! JG;Ho+7uJÀo,˾;H}?lmjCeϵTa*o -^/"
ÊI;g&k
}"E`@8̮;QdOO R<{
qa)kEEx9: (7I f*n ;R iqPq9HƶsDѳ 5Ƴ6T|UbZpDfE=]^ИP41 n
ά0,\uK v|z
C(uz4st~NL1; -4{!pJ ~!A&^P,pbDFۙ Αt-ᄈ̨ #g ]AHam`&@ cq ^Oׁ|[˴ȪE.1
eCJ -4~ Dks}H ;N
k;H}-.ͷzA:k}'@F,q-r~)h
Z.dq>Y]G16cpS"f /,r 1o{1,vr0? $'
}Qّ7&*^;ʵ_']ڝtS;˨4cs(X;GV+"nI\4 k &g:JE⯹/̧qϽ-gZ9eIY 6YQC(LG &}ɉw)5Z0Siwc`O+ Yq
c1'2Hݨ0nw"s)qwv{ #ZU
_ed*m߾]_ہW1$!\
x9fl!T6hLeG Bǣ_vdbbm '2HQToT7KJXkVsQYD$c*T)#C%xގμW\w B ;Hx*2}Ӯr8-4Y[f YOq/ Ώ.ֹA
wO .OΑGq{fFA_xo=6Y2@Vg ,* M|
O\hfbZ`PYt AeCǼߍw%Y%0n5f`2,7a9 N/n5Ŗ X&1ʋOb=Ave/bJ.9lTCRr4};ʴO|ɓ۷ۣ >,o&#_jx3 yQ3wm0;>s^{$9p0A "*,E{I5:O꾃тݘ1-9rן[؋9wӫ^?N:Z, !sbn=6z}v Mo dUAO|Q3%눏˭ DeNx"iAnǎWT;k%8zƚQ`,F]FU7eQkQgPGwB ?2GwLw!xJ
i?C L]ЂʚoRRjP T㾃;]t)jŜ^ =rf:\db"cdj6$̢Ԋ5;HN<
T}?s|QjK}ɩ{}Qɧ35/|Qr*a.ckTtoKr6(5] {yَAr /
GtGeqc>g {0|B f* D<$6Wl B ܥ7>>eaa֬n |O>< :{#b}MY^2"?~MX ;D76ͯ)7J ? BoX"AR}FvV _ k4za2WI\;J,ƾc?|g}<)!R q G` |=Vj/w<~
{7HYV#S,+v5rԓŎvMqvo6s Ν;Ofɍ~w4!7'c{ 9J -,7lUE7* Aʈ`.7b;J|sFM(*L/4IJ qFfkQyi͑ i>Bo6awhٽ{mW]:35)-ZD*ZQA%Dy,DHBSB"-} {r g>3$;9sΝ~3{ ߽ou{rMy6Λ"`]vi榹i(|4e]B'ސꮋ`/_oq%Iu=?IMedC˵fWut9x9|? Wk-wNNN6C {m;<*\ׅ$u lD N؍fyOƶ܇w{W%$#=C|lnj|$D/ 32~nutii7` |-MPvfiI>u0Jzׅ0%0cHo>\tͯ8 R%^\emva]WrO+;o=&S3͡ٻrnj ⰷ% o>7ݢf$u <0# F JzmNr a+wZʚ:4s.-8Bn;<3;1R5
ZSV:_x5iJG{]% `M'yDC] $yGEf#J`?$8[7.=u!lnpSJY vdu`vnMݷ:i~L =Z'j3>xsJ^aF`6X d]ʮ`C F Jr]'u]iwv][˻?yi)yZMDW{-` k_l4²L[7OnXۙlp>B(<5f'mI~B0%0{%yqڝnL_Lr{ׅu]{+/[]yN6t kk#3 6jf~Zja[Z¡õ߬f#~M$o;k\h c9w]lR$|&0Q3.O$Nb'' ax-/{tkI躞ڔcGg''Ng-.>t|ya#ԱlLc|W;wWZZ>\:HNM3zf#J`$ynM2 D?.[:x%)N)e~zvxaVc&.j OdԔzSm[b[7f^|C5I`f#J`'$MG^EKMwz{ׅ@묖禩OOyQƖ\]k;YQk-bؑCZA&ML-ip̠)&;u]l|:ɣ.(:핝nK$upO^1Z3jdSSf_Y?k&)5Gg_J:Z/(MoPᾚW~{@d0f EE3itomF`6fpj.K$OOI "'g-y;Ϛ]SǗv}KMBau-Z:~5{^5 ;<2|ׅkI>
وyh&2ɾnK֚$䯻.N[? ;R)yFIyJR79~Mr|iǡKڄK+,I ٹ g՚S)ׯRz (e{˿;(S$ ^2lD `0N7yI q-7qOt\ u7!FzyJ?;7bj ʐz/ ?¡ 6@[HR?Uki,M_c
&0;5'yNE6`A`6f0xOL=;I'
Iޘ-IV:6u7boԚ[I} Ͽ:vxZ7|iyȱjť2sP#M&N[֒ޔZ?k-7=ɛNri]$ H F 6Dg&?s,u\ յ7:+)"%W$9[krlnn
,LݵoƎ1$Ǧsz~i~|ʚ IlJͮO89_"0;yW&ygE62䖴ٜf#J`ñ;ɯ
ΞvMN7.>;Fƻ> XHO5IcSIتM];/֔$nPV /hKmO-ƿdf'ciY u^OEkJ`6fЍKgON/rj( Og-6w3yB)qI,'< ml=jl,3k37kn>GL5gHkZ}㫾f#0;qI.O{ '5h6وh$<"96$_J}<2˚` n3GS.\Zk SzZv5k v,.>t|qPw<MYZ ;&_(i2+ y/w]a=:89%0Ѵ3ա^<Ò\r0Ǘ `rrxG<<<5R/JE/[Z x }RT-$wZXtƫ&6Dݞd"<8mOK.$\]wcnۋi{Ϯ7sv${Ҷٟdv-
6=iC OsrjlD `9+mOs֏ |HDki3c O;뫦}[Jqn_Ol1&:9缜f^&禗sJ-5u?IjR?:Rz%;j͞Rld^fҤIjMJ5elNך4e4ccS90?=99t QtFڝI^~&u_385{0s9vk( N[ IENDB` tox-4.13.0/docs/_static/img/tox.svg 0000664 0000000 0000000 00000063025 14564001166 0017107 0 ustar 00root root 0000000 0000000
image/svg+xml
t x
tox-4.13.0/docs/_static/img/toxfavi.ico 0000664 0000000 0000000 00000035356 14564001166 0017736 0 ustar 00root root 0000000 0000000 00 % 6 % h 6 ( 0 ` $ m{
yy
y oooLo~w|ĉyʼnyxi~yXLwV zY oo7ooou{|yyyvh{ZӈxWyX7yX o%ooopv|||yyyyyo^yXyXyX% ooQooopw|||}}yyyyxwp}]yXyXψyXPyX lomoooqx|||{}yvusrp~o}oayYyYyYyYmyY _bϻpeʵfɳgȲgůmponnmnxv}p}o}o}o}o}o}ocyYyYyYyYyYpyY aѽXaѽaѽaѽaҾ_̹ahhhhhim}tw|p}o}o}o}o}oeyYyYyYyYyYyYX ^-aѽaѽaѽaѽaѽ_Ǵ]fhhhhim}m}ryzq}o}o}o}ogyYyYyYyYvW^AփH.- JSП_aѽaѽaѽaѽ]°[ahhhhjm}m}m}o{xs}o}o}oizZyYyYvV\?I/I/I/ OGOZaѽaѽaѽaм\[]fhhhjm}m}m}m}n|uv|p}okz[yYuVZ>I/I/I/I/G OO֣OT`Ҿaѽaѽ`ͺ\[[bhhhjm}m}m}m}m}m}rx{ql|\tUY=I/I/I/I/I/I/ O+OOP]aѽaѽ_ʶ[[[]ghhjm}m}m}m}m}m}m}pzzrwXW;I/I/I/I/I/I/I/+ OdOOOWaѽaѽ^Ų[[[[chhjm}m}m}m}m}m}m}m}mvxeNL4I0I/I/I/I/I/I/d PO֙OOOQ_aѼ][[[[^ghjm}m}m}m}m}m}m|jsgzhmgTt[GwWA}P8K2I/I/I/I/I/ O OֽOOOOZaϻ\[[[[[chjm}m}m}m}m}kxhmfwffwfljXr]Jr]Jr]JuZEzS=M5J0I/H. OOOOOOT_[[[[[[_gkm}m}m}m|jrgzhfwffwffwfklZr]Jr]Jr]Jr]Jr]Js\HwWB|Q:~O7 N NNNNNOYͻ[[[[[[[dkm}m}kxhlfwffwffwffwffwfjo]r]Jr]Jr]Jr]Jr]Jr]Jr]Jr]Jr\I = ======D˿QTWYZ[[_km{jrgzhfwffwffwffwffwffwfiq`q^Kr]Jr]Jr]Jr]Jr]Jr]Jr\Ir[H 88888889GKKMOQTWdhmfwffwffwffwffwffwffwffwfhsbq_Mr]Jr]Jr]Jr[IsXEtRAtM}A~EHHHJ}vQc^Qb]Qb]Qb]Qb]Qb]Qb]Qb]Rb\Wb[xiaS 33w3333335=>~?~B~FHMunQa\Qb]Qb]Qb]Pc^Pc^Od_Ne`Oc_vPa] 33Z3333338>~>~>~?~C~LnhNd`MfbLgcKhdJieIifHjfHjgZGkh 3,333334;>}>~>~@}yHlhHjgHjgHjgHjgHjgHjgHjg, 33@33335=>~>~DuqHjgHjgHjgHjgHjgHjg@Hjg 33"3W339>~?|FnkHjgHjgHjgWHjg#Hjg 26>@~zHkhHjg ? ? ( @ nnw4DzDx4ciH ooVosz遤yy鉑pԈ_xWWyX poEoot{|yyyrayXyXEyX iĭnmoot{{{vutrkzZyYyYmyY _bлpd̷e˵fmmmls}|q}o}o}ol{[yYyYzZpf `ӿLaѽaѽaҾ^ðchhhlpzyr}o}o~m|]yYzYqRW;L LV`Ҿaѽaм\_hhhlm}o|wu}o~n~_yYqRT8I/I/ OdP]aѽ`κ\\dhhlm}m}m}tw|paoPR7H.I/I/d O OֳOXaѽ_˷[[`hhlm}m}m}m}qzy]Q6H.I/I/I/I/ O&OOR_^Ƴ[[\eilm}m}m}m|jtnmZxU@~O8K1I/I/߃I/& ODOOO[^[[[`hlm}m}lxhmfxgjn\r]Kr]IuYE{S~@~EKxrPc^Pc^Od_NeaMfaNd`tOa] 33K3334<>~?~GrmJheIifHjgHjgHjgKEmk 33^337=@~yGliHjgHjgHjg^Hjg 33 4; <ؙ;BOR^f}lexhgtcq^KsVDsRA 8r89FJL[xbqcsenTFuH8uH8r 8,88?IIN]uiacXe]QqM>vG7, ?7n55?FI|QgaVa[ZbYd\Qn 33l35>F{uLgcLfcMfblSa\ 33)3m:CuqHjgmGkh)Bom tox-4.13.0/docs/changelog.rst 0000664 0000000 0000000 00000166712 14564001166 0016042 0 ustar 00root root 0000000 0000000 Release History
===============
.. include:: _draft.rst
.. towncrier release notes start
v4.13.0 (2024-02-16)
--------------------
Features - 4.13.0
~~~~~~~~~~~~~~~~~
- Extract virtual environment packaging code to its own base class not tied to ``virtualenv`` - by :user:`gaborbernat`. (:issue:`3200`)
Improved Documentation - 4.13.0
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Documented usage of ``pytest`` with ``tox run-parallel`` - by :user:`faph`. (:issue:`3187`)
- Configuration: state in config directive sections their ini file sections - by :user:`0cjs`. (:issue:`3194`)
- Development: summarize important points experienced developers need to know - by :user:`0cjs`. (:issue:`3197`)
v4.12.1 (2024-01-16)
--------------------
Bugfixes - 4.12.1
~~~~~~~~~~~~~~~~~
- Fixed bug where running with --installpkg and multiple envs could not clean up between tests (:issue:`3165`)
v4.12.0 (2024-01-11)
--------------------
Features - 4.12.0
~~~~~~~~~~~~~~~~~
- Always pass ``FORCE_COLOR`` and ``NO_COLOR`` to the environment (:issue:`3171`)
Bugfixes - 4.12.0
~~~~~~~~~~~~~~~~~
- ``--parallel-no-spinner`` flag now implies ``--parallel`` (:issue:`3158`)
Improved Documentation - 4.12.0
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- -Fix ``open an issue`` link in development.rst (:issue:`3179`)
v4.11.4 (2023-11-27)
--------------------
Bugfixes - 4.11.4
~~~~~~~~~~~~~~~~~
- Fix terminal size of tox subcommands (fixes ipython, ipdb, prompt_toolkit, ...). (:issue:`2999`)
- Fix ``quickstart`` command from requiring ``root`` positional argument (:issue:`3084`)
- Added 'AppData' to the default passed environment variables on Windows. (:issue:`3151`)
Improved Documentation - 4.11.4
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Fix default value for ``install_command`` - by :user:`hashar`. (:issue:`3126`)
- Fix default value for ``base_python`` - by :user:`rpatterson`. (:issue:`3156`)
v4.11.3 (2023-09-08)
--------------------
Bugfixes - 4.11.3
~~~~~~~~~~~~~~~~~
- Handle ``FileNotFoundError`` when the ``base_python`` interpreter doesn't exist (:issue:`3105`)
Improved Documentation - 4.11.3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Explain how plugins are registered and discovered - by :user:`hashar`. (:issue:`3116`)
v4.11.2 (2023-09-07)
--------------------
Bugfixes - 4.11.2
~~~~~~~~~~~~~~~~~
- Fix bug in ``config.rst`` by removing stray colons left over from (:issue:`3111`) - by :user:`posita`. (:issue:`3118`)
- Provide example to make CLI help more helpful for ``-x`/``--override`` - by :user:`posita`. (:issue:`3119`)
Improved Documentation - 4.11.2
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Fix typos discovered by codespell - by :user:`cclauss`. (:issue:`3113`)
v4.11.1 (2023-09-01)
--------------------
Bugfixes - 4.11.1
~~~~~~~~~~~~~~~~~
- Allow passing in multiple overrides using the ``;`` character and fix ``,`` being used as splitting values -
by :user:`gaborbernat`. (:issue:`3112`)
v4.11.0 (2023-08-29)
--------------------
Features - 4.11.0
~~~~~~~~~~~~~~~~~
- Add support for setting build backend ``config_settings`` in the configuration file - by :user:`gaborbernat`. (:issue:`3090`)
v4.10.0 (2023-08-21)
--------------------
Features - 4.10.0
~~~~~~~~~~~~~~~~~
- Change accepted environment name rule: must be made up of factors defined in configuration or match regex
``(pypy|py|cython|)((\d(\.\d+(\.\d+)?)?)|\d+)?``. If an environment name does not match this fail, and if a close match
found suggest that to the user. (:issue:`3099`)
Bugfixes - 4.10.0
~~~~~~~~~~~~~~~~~
- ``--override foo+=bar`` appending syntax will now work correctly when ``foo`` wasn't defined in ``tox.ini``. (:issue:`3100`)
v4.9.0 (2023-08-16)
-------------------
Features - 4.9.0
~~~~~~~~~~~~~~~~
- Disallow command line environments which are not explicitly specified in the config file - by :user:`tjsmart`. (:issue:`2858`)
v4.8.0 (2023-08-12)
-------------------
Features - 4.8.0
~~~~~~~~~~~~~~~~
- ``--override`` can now take options in the form of ``foo+=bar`` which
will append ``bar`` to the end of an existing list/dict, rather than
replacing it. (:issue:`3087`)
v4.7.0 (2023-08-08)
-------------------
Features - 4.7.0
~~~~~~~~~~~~~~~~
- Make --hashseed default to PYTHONHASHSEED, if defined - by :user:`paravoid`.
The main motivation for this is to able to set the hash seed when building the
documentation with "tox -e docs", and thus avoid embedding a random value in
the tox documentation for --help. This caused documentation builds to fail to
build reproducibly. (:issue:`2942`)
Bugfixes - 4.7.0
~~~~~~~~~~~~~~~~
- Update a regular expression in tests to match the exception message in both Python 3.12 and older. (:issue:`3065`)
Improved Documentation - 4.7.0
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Fix broken links - by :user:`gaborbernat`. (:issue:`3072`)
v4.6.4 (2023-07-06)
-------------------
Bugfixes - 4.6.4
~~~~~~~~~~~~~~~~
- Fix hang and zombie process on interrupt (CTRL-C). (:issue:`3056`)
v4.6.3 (2023-06-19)
-------------------
Bugfixes - 4.6.3
~~~~~~~~~~~~~~~~
- Ensure that ``get_requires_for_build_wheel`` is called before ``prepare_metadata_for_build_wheel``, and
``get_requires_for_build_editable`` is called before ``prepare_metadata_for_build_editable`` - by :user:`abravalheri`. (:issue:`3043`)
Improved Documentation - 4.6.3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Linked environment variable substitutions docs in
``set_env`` and ``pass_env`` config docs. (:issue:`3039`)
v4.6.2 (2023-06-16)
-------------------
Bugfixes - 4.6.2
~~~~~~~~~~~~~~~~
- Avoid cache collision between editable wheel build and normal wheel build -- by :user:`f3flight`. (:issue:`3035`)
v4.6.1 (2023-06-15)
-------------------
No significant changes.
v4.6.0 (2023-06-05)
-------------------
Features - 4.6.0
~~~~~~~~~~~~~~~~
- Added ``--list-dependencies`` and ``--no-list-dependencies`` CLI parameters.
If unspecified, defaults to listing when in CI, but not otherwise. (:issue:`3024`)
Misc - 4.6.0
~~~~~~~~~~~~
- :issue:`3020`
v4.5.1 (2023-05-25)
-------------------
Bugfixes - 4.5.1
~~~~~~~~~~~~~~~~
- Fix ``tox --devenv venv`` invocation without ``-e`` - by :user:`asottile`. (:issue:`2925`)
v4.5.0 (2023-04-24)
-------------------
Features - 4.5.0
~~~~~~~~~~~~~~~~
- When run with verbosity=1, the per-step timing summaries are suppressed at the
end of the run. Thanks to :user:`nedbat` at the PyCon 2023 sprints. (:issue:`2891`)
Improved Documentation - 4.5.0
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Add FAQ entry on how to test EOL Python versions by :user:`jugmac00`. (:issue:`2989`)
v4.4.12 (2023-04-13)
--------------------
Bugfixes - 4.4.12
~~~~~~~~~~~~~~~~~
- Avoid race conditions in tests using the ``demo_pkg_inline`` fixture. (:issue:`2985`)
v4.4.11 (2023-04-05)
--------------------
Bugfixes - 4.4.11
~~~~~~~~~~~~~~~~~
- Fixed an issue where a tox plugin couldn't change the value of ``tox_root``. (:issue:`2966`)
v4.4.10 (2023-04-05)
--------------------
Bugfixes - 4.4.10
~~~~~~~~~~~~~~~~~
- Fix issue where ``work_dir`` was not correctly including ``tox_root`` for test runs. (:issue:`2933`)
v4.4.9 (2023-04-05)
-------------------
Bugfixes - 4.4.9
~~~~~~~~~~~~~~~~
- Instead of raising ``UnicodeDecodeError`` when command output includes non-utf-8 bytes,
``tox`` will now use ``surrogateescape`` error handling to convert the unrecognized bytes
to escape sequences according to :pep:`383` - by :user:`masenf`. (:issue:`2969`)
Improved Documentation - 4.4.9
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Document running tox within a Docker container. (:issue:`1035`)
- Added python version 3.11 to ``installation.rst``. (:issue:`2964`)
v4.4.8 (2023-03-26)
-------------------
Bugfixes - 4.4.8
~~~~~~~~~~~~~~~~
- ``tox.ini`` is now included in source distributions in order to make all tests pass. (:issue:`2939`)
- Fix ``--index-url`` and ``--find-links`` being used together in ``requirements.txt`` files. (:issue:`2959`)
v4.4.6 (2023-02-21)
-------------------
Bugfixes - 4.4.6
~~~~~~~~~~~~~~~~
- Plugins are now able to access tox.ini config sections using a custom prefix with the same suffix / name as a tox
``testenv`` - by :user:`masenf` (:issue:`2926`)
v4.4.5 (2023-02-07)
-------------------
Bugfixes - 4.4.5
~~~~~~~~~~~~~~~~
- Ignore labels when tox will provision a runtime environment (``.tox``) so that environment configurations which depend
on provisioned plugins or specific tox versions are not accessed in the outer tox process where the configuration would
be invalid - by :user:`masenf`. (:issue:`2916`)
v4.4.4 (2023-01-31)
-------------------
Bugfixes - 4.4.4
~~~~~~~~~~~~~~~~
- Forward ``HOME`` by default - by :user:`gschaffner`. (:issue:`2702`)
v4.4.3 (2023-01-30)
-------------------
Bugfixes - 4.4.3
~~~~~~~~~~~~~~~~
- Tox will now expand self-referential extras discovered in package deps to respect local modifications to package
metadata. This allows a package extra to explicitly depend on another package extra, which previously only worked with
non-static metadata - by :user:`masenf`. (:issue:`2904`)
v4.4.2 (2023-01-25)
-------------------
Bugfixes - 4.4.2
~~~~~~~~~~~~~~~~
- Allow the user configuration file (default ``/tox/config.ini``) to be overridden via the
``TOX_USER_CONFIG_FILE`` environment variable. Previously tox was looking at the ``TOX_CONFIG_FILE`` to override the
user configuration, however that environment variable is already used to override the main configuration - by
:user:`masenf`. (:issue:`2890`)
v4.4.1 (2023-01-25)
-------------------
Bugfixes - 4.4.1
~~~~~~~~~~~~~~~~
- In tox 4.4.0 ``constrain_package_deps`` was introduced with a default value of ``True``. This has been changed back to
``False``, which restores the original behavior of tox 4.3.5 - by :user:`masenf`. (:issue:`2897`)
v4.4.0 (2023-01-25)
-------------------
Features - 4.4.0
~~~~~~~~~~~~~~~~
- Test environments now recognize boolean config keys ``constrain_package_deps`` (default=true) and ``use_frozen_constraints`` (default=false),
which control how tox generates and applies constraints files when performing ``install_package_deps``.
If ``constrain_package_deps`` is true (default), then tox will write out ``{env_dir}{/}constraints.txt`` and pass it to
``pip`` during ``install_package_deps``. If ``use_frozen_constraints`` is false (default), the constraints will be taken
from the specifications listed under ``deps`` (and inside any requirements or constraints file referenced in ``deps``).
Otherwise, ``list_dependencies_command`` (``pip freeze``) is used to enumerate exact package specifications which will
be written to the constraints file.
In previous releases, conflicting package dependencies would silently override the ``deps`` named in the configuration,
resulting in test runs against unexpected dependency versions, particularly when using tox factors to explicitly test
with different versions of dependencies - by :user:`masenf`. (:issue:`2386`)
Bugfixes - 4.4.0
~~~~~~~~~~~~~~~~
- When parsing command lines, use ``shlex(..., posix=True)``, even on windows platforms, since non-POSIX mode does not
handle escape characters and quoting like a shell would. This improves cross-platform configurations without hacks or
esoteric quoting.
To make this transition easier, on Windows, the backslash path separator will not treated as an escape character unless
it precedes a quote, whitespace, or another backslash character. This allows paths to mostly be written in single or
double backslash style.
Note that **double-backslash will no longer be escaped to a single backslash in substitutions**, instead the double
backslash will be consumed as part of command splitting, on either posix or windows platforms.
In some instances superfluous double or single quote characters may be stripped from arg arrays in ways that do not
occur in the default windows ``cmd.exe`` shell - by :user:`masenf`. (:issue:`2635`)
Improved Documentation - 4.4.0
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Add information when command from ``list_dependencies_command`` configuration option is used. (:issue:`2883`)
v4.3.5 (2023-01-18)
-------------------
Bugfixes - 4.3.5
~~~~~~~~~~~~~~~~
- When building a ``wheel`` or ``editable`` package with a PEP 517 backend, no
longer pass an empty ``metadata_directory`` to the backend ``build_wheel`` or
``build_editable`` endpoint.
Some backends, such as PDM and poetry, will not generate package metadata in
the presence of a ``metadata_directory``, even if it is empty.
Prior to this change, attempting to install a wheel created by tox using PDM or
poetry would return an error like "There is no item named
'my-package.0.1.dist-info/WHEEL' in the archive" - by :user:`masenf`. (:issue:`2880`)
v4.3.4 (2023-01-17)
-------------------
Bugfixes - 4.3.4
~~~~~~~~~~~~~~~~
- When executing via the provisioning environment (``.tox`` by default), run
``tox`` in working directory of the parent process.
Prior to this change (from tox 4.0.0), the provisioned ``tox`` would execute with
``{tox_root}`` as the working directory, which breaks when a relative path is
passed to ``-c`` or ``--conf`` and ``tox`` is executed in a working directory
other than ``{tox_root}`` - by :user:`masenf`. (:issue:`2876`)
Misc - 4.3.4
~~~~~~~~~~~~
- :issue:`2878`
v4.3.3 (2023-01-16)
-------------------
Bugfixes - 4.3.3
~~~~~~~~~~~~~~~~
- The provision environment (``.tox``) will never inherit from ``testenv``.
During provisioning, other test environments are not processed, allowing the
use of keys and values that may be registered by later tox version or
provisioned plugins - by :user:`masenf`. (:issue:`2862`)
v4.3.2 (2023-01-16)
-------------------
Bugfixes - 4.3.2
~~~~~~~~~~~~~~~~
- Fix regression introduced in 4.3.0 which occurred when a substitution expression
for an environment variable that had previously been substituted appears in the
ini file after a substitution expression for a different environment variable.
This situation erroneously resulted in an exception about "circular chain
between set" of those variables - by :user:`masenf`. (:issue:`2869`)
v4.3.1 (2023-01-15)
-------------------
Bugfixes - 4.3.1
~~~~~~~~~~~~~~~~
- Fix regression introduced in 4.3.0 by expanding substitution expressions
(``{...}``) that result from a previous subsitution's replacement value (up to
100 times). Note that recursive expansion is strictly depth-first; no
replacement value will ever affect adjacent characters nor will expansion ever
occur over the result of more than one replacement - by :user:`masenf`. (:issue:`2863`)
v4.3.0 (2023-01-15)
-------------------
Features - 4.3.0
~~~~~~~~~~~~~~~~
- Rewrite substitution replacement parser - by :user:`masenf`
* ``\`` acts as a proper escape for ``\`` in ini-style substitutions
* The resulting value of a substitution is no longer reprocessed in the context
of the broader string. (Prior to this change, ini-values were repeatedly re-substituted until
the expression no longer had modifications)
* Migrate and update "Substitutions" section of Configuration page from v3 docs.
* ``find_replace_part`` is removed from ``tox.config.loader.ini.replace``
* New names exported from ``tox.config.loader.ini.replace``:
* ``find_replace_expr``
* ``MatchArg``
* ``MatchError``
* ``MatchExpression``
* Note: the API for ``replace`` itself is unchanged. (:issue:`2732`)
- Improved documentation for factors and test env names - by :user:`stephenfin`. (:issue:`2852`)
v4.2.8 (2023-01-11)
-------------------
Bugfixes - 4.2.8
~~~~~~~~~~~~~~~~
- Allow using package names with env markers for pip's ``--no-binary`` and ``--only-binary`` options - by :user:`q0w`. (:issue:`2814`)
v4.2.7 (2023-01-11)
-------------------
Bugfixes - 4.2.7
~~~~~~~~~~~~~~~~
- A testenv with multiple factors, one of which conflicts with a ``base_python`` setting in ``tox.ini``, will now use the
correct Python interpreter version - by :user:`stephenfin`. (:issue:`2838`)
- Explicitly list ``wheel`` as requirement for the tests, as some of the tests error without it. (:issue:`2843`)
- tox has reverted support for Python factors that include PATCH release info (e.g. ``py3.10.1``), build architecture
(e.g. ``pypy3-64``) or do not define a ``py`` prefix or other supported prefix (e.g. ``3.10``). These complex factors
were initially supported with the release of tox 4.0 but has proven complicated to support. Instead, the simple factors
supported by tox 3 e.g. (``py310``, ``pypy3``) or period-separated equivalent (``py3.10``) introduced in tox 4 should be
used. Users who wish to specify more specific Python version information should configure the :ref:`base_python` setting
- by :user:`stephenfin`. (:issue:`2848`)
v4.2.6 (2023-01-06)
-------------------
Bugfixes - 4.2.6
~~~~~~~~~~~~~~~~
- Handle properly pip ``--no-binary`` / ``--only-binary`` options in requirements.txt format files. (:issue:`2814`)
v4.2.5 (2023-01-06)
-------------------
Bugfixes - 4.2.5
~~~~~~~~~~~~~~~~
- The combination of ``usedevelop = true`` and ``--skip-missing-interpreters=false`` will no longer fail for environments
that were *not* invoked - by :user:`stephenfin`. (:issue:`2811`)
- Fix an attribute error when ``use_develop = true`` is set and an unsupported interpreter version is requested - by
:user:`stephenfin`. (:issue:`2826`)
- tox returns a non-zero error code if all envs are skipped. It will now correctly do this if only a single env was
requested and this was skipped - by :user:`stephenfin`. (:issue:`2827`)
v4.2.4 (2023-01-05)
-------------------
Bugfixes - 4.2.4
~~~~~~~~~~~~~~~~
- Setting ``[testenv] basepython = python3`` will no longer override the Python interpreter version requested by a factor,
such as ``py311`` - by :user:`stephenfin`. (:issue:`2754`)
- Also accept tab after colon before factor filter expansion - by :user:`pdecat`. (:issue:`2823`)
v4.2.3 (2023-01-04)
-------------------
Bugfixes - 4.2.3
~~~~~~~~~~~~~~~~
- ``devenv`` does not respect the specified path when the package is a wheel file - by :user:`gaborbernat`. (:issue:`2815`)
- Require space after colon before factor filter expansion, unless it is the last character of the line - by :user:`pdecat`. (:issue:`2822`)
v4.2.2 (2023-01-04)
-------------------
Bugfixes - 4.2.2
~~~~~~~~~~~~~~~~
- Add ``CC``, ``CFLAGS``, ``CCSHARED``, ``CXX``, ``CPPFLAGS``, ``LDFLAGS``, ``PKG_CONFIG`` and ``PKG_CONFIG_SYSROOT_DIR``
to the default passed through environment variables list as these are needed for building various C-extensions
- by :user:`gaborbernat`. (:issue:`2818`)
v4.2.1 (2023-01-03)
-------------------
Bugfixes - 4.2.1
~~~~~~~~~~~~~~~~
- Fix extracting extras from markers with more than 2 extras in an or chain - by :user:`dconathan`. (:issue:`2791`)
v4.2.0 (2023-01-03)
-------------------
Features - 4.2.0
~~~~~~~~~~~~~~~~
- Packaging environments now inherit from the ``pkgenv`` section, allowing to set all your packaging options in one place,
and support the ``deps`` key to set additional dependencies that will be installed after ``pyproject.toml`` static
``requires`` but before backends dynamic requires - by :user:`gaborbernat`. (:issue:`2543`)
Improved Documentation - 4.2.0
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Document breaking changes with tox 4 and packaging environments - by :user:`gaborbernat`. (:issue:`2543`)
- Document how to handle environments whose names match ``tox`` subcommands - by :user:`sirosen`. (:issue:`2728`)
v4.1.3 (2023-01-02)
-------------------
Bugfixes - 4.1.3
~~~~~~~~~~~~~~~~
- Reuse package_env with ``--installpkg`` - by :user:`q0w`. (:issue:`2442`)
- Fail more gracefully when pip :ref:`install_command` is empty - by :user:`jayaddison`. (:issue:`2695`)
Improved Documentation - 4.1.3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Add breaking-change documentation for empty ``install_command`` values - by :user:`jayaddison`. (:issue:`2695`)
Misc - 4.1.3
~~~~~~~~~~~~
- :issue:`2796`, :issue:`2797`
v4.1.2 (2022-12-30)
-------------------
Bugfixes - 4.1.2
~~~~~~~~~~~~~~~~
- Fix ``--skip-missing-interpreters`` behavior - by :user:`q0w`. (:issue:`2649`)
- Restore tox 3 behavior of showing the output of pip freeze, however now only active when running inside a CI
environment - by :user:`gaborbernat`. (:issue:`2685`)
- Fix extracting extras from markers with many extras - by :user:`q0w`. (:issue:`2791`)
v4.1.1 (2022-12-29)
-------------------
Bugfixes - 4.1.1
~~~~~~~~~~~~~~~~
- Fix logging error with emoji in git branch name. (:issue:`2768`)
Improved Documentation - 4.1.1
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Add faq entry about reuse of environments - by :user:`jugmac00`. (:issue:`2788`)
v4.1.0 (2022-12-29)
-------------------
Features - 4.1.0
~~~~~~~~~~~~~~~~
- ``-f`` can be used multiple times and on hyphenated factors (e.g. ``-f py311-django -f py39``) - by :user:`sirosen`. (:issue:`2766`)
Improved Documentation - 4.1.0
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Fix a grammatical typo in docs/user_guide.rst. (:issue:`2787`)
v4.0.19 (2022-12-28)
--------------------
Bugfixes - 4.0.19
~~~~~~~~~~~~~~~~~
- Create temp_dir if not exists - by :user:`q0w`. (:issue:`2770`)
v4.0.18 (2022-12-26)
--------------------
Bugfixes - 4.0.18
~~~~~~~~~~~~~~~~~
- Strip leading and trailing whitespace when parsing elements in requirement files - by :user:`gaborbernat`. (:issue:`2773`)
v4.0.17 (2022-12-25)
--------------------
Features - 4.0.17
~~~~~~~~~~~~~~~~~
- Suppress a report output when verbosity = 0. (:issue:`2697`)
Bugfixes - 4.0.17
~~~~~~~~~~~~~~~~~
- Fix ``--sdistonly`` behavior. (:issue:`2653`)
- Override toxworkdir with --workdir. (:issue:`2654`)
v4.0.16 (2022-12-20)
--------------------
Bugfixes - 4.0.16
~~~~~~~~~~~~~~~~~
- Fix :ref:`change_dir` is relative to current working directory rather than to the :ref:`tox_root` when using the ``-c``
argument to locate the ``tox.ini`` file - by :user:`gaborbernat`. (:issue:`2619`)
v4.0.15 (2022-12-19)
--------------------
Bugfixes - 4.0.15
~~~~~~~~~~~~~~~~~
- Fix tox auto-provisioning not working and relax :ref:`min_version` default from ``4.0`` to no version constraint
- by :user:`gaborbernat`. (:issue:`2634`)
- Fix assertion in ``test_result_json_sequential`` when interpreter ``_base_executable`` is a hardlink (macOS homebrew)
- by :user:`masenf`. (:issue:`2720`)
- Complex negative factor filters not working - by :user:`gaborbernat`. (:issue:`2747`)
v4.0.14 (2022-12-18)
--------------------
Bugfixes - 4.0.14
~~~~~~~~~~~~~~~~~
- Do not include non test environment sections or factor filters in INI configuration to factor discovery - by
:user:`gaborbernat`. (:issue:`2746`)
v4.0.13 (2022-12-17)
--------------------
Bugfixes - 4.0.13
~~~~~~~~~~~~~~~~~
- A plain section in INI configuration matching a tox environment name shadowed the laters configuration - by
:user:`gaborbernat`. (:issue:`2636`)
- Fix space not accepted in factor filter expression - by :user:`gaborbernat`. (:issue:`2718`)
v4.0.12 (2022-12-16)
--------------------
Bugfixes - 4.0.12
~~~~~~~~~~~~~~~~~
- If tox is running in a tty, allocate a pty (pseudo terminal) for commands
and copy termios attributes to show colors and improve interactive use - by :user:`masenf`. (:issue:`1773`)
- Fix python hash seed not being set - by :user:`gaborbernat`. (:issue:`2645`)
- Fix legacy CLI flags ``--pre``, ``--force-deps``, ``--sitepackages`` and ``--alwayscopy`` not working, and mark them
as deprecated - by :user:`gaborbernat`. (:issue:`2690`)
Improved Documentation - 4.0.12
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Document user level config. (:issue:`2633`)
v4.0.11 (2022-12-14)
--------------------
Features - 4.0.11
~~~~~~~~~~~~~~~~~
- Modified handling of ``NO_COLOR`` environment variable, consistent with
`de facto conventions `_: any non-empty string will enable ``NO_COLOR`` (disable colorized
output); no ``NO_COLOR`` variable or ``NO_COLOR`` with an empty string will disable ``NO_COLOR`` (enable colorized
output) - by :user:`ptmcg`. (:issue:`2719`)
Bugfixes - 4.0.11
~~~~~~~~~~~~~~~~~
- ``TOX_SKIP_ENV`` environment variable now works again, and can also be set via the CLI argument ``--skip-env``
for any command where ``-e`` can be set - by :user:`mgedmin`. (:issue:`2698`)
- ``tox config`` should only show :ref:`env_list` arguments by default instead of ``ALL`` - by :user:`gaborbernat`. (:issue:`2726`)
v4.0.10 (2022-12-14)
--------------------
Features - 4.0.10
~~~~~~~~~~~~~~~~~
- Add ``py_dot_ver`` and ``py_impl`` constants to environments to show the current Python implementation and dot version
(e.g. ``3.11``) for the current environment. These can be also used as substitutions in ``tox.ini`` - by
:user:`gaborbernat`. (:issue:`2640`)
Bugfixes - 4.0.10
~~~~~~~~~~~~~~~~~
- ``--help`` now reports the default verbosity level (which is WARNING) correctly. (:issue:`2707`)
v4.0.9 (2022-12-13)
-------------------
Features - 4.0.9
~~~~~~~~~~~~~~~~
- Add :meth:`tox_on_install ` and
:meth:`tox_env_teardown ` plugin hooks - by :user:`gaborbernat`. (:issue:`2687`)
- Add ``PKG_CONFIG_PATH`` to the default pass through environment list for python tox environments -
by :user:`gaborbernat`. (:issue:`2700`)
v4.0.8 (2022-12-11)
-------------------
Bugfixes - 4.0.8
~~~~~~~~~~~~~~~~
- Fix multiple substitution on factor filtering in ``tox.ini`` when multiple factor filters match
- by :user:`gaborbernat`. (:issue:`2650`)
- Fix regression in ``requirements.txt`` parsing - by :user:`gaborbernat`. (:issue:`2682`)
v4.0.7 (2022-12-11)
-------------------
Bugfixes - 4.0.7
~~~~~~~~~~~~~~~~
- Support for ``--no-deps`` flag within the :ref:`deps` - by :user:`gaborbernat`. (:issue:`2674`)
v4.0.6 (2022-12-10)
-------------------
Features - 4.0.6
~~~~~~~~~~~~~~~~
- Fail on :ref:`pass_env`/:ref:`passenv` entries containing whitespace - by :user:`ericzolf`. (:issue:`2658`)
v4.0.5 (2022-12-09)
-------------------
Bugfixes - 4.0.5
~~~~~~~~~~~~~~~~
- Normalize extra names passed in (fixes extra groups not being picked up during installation) - by :user:`gaborbernat`. (:issue:`2655`)
v4.0.4 (2022-12-09)
-------------------
Bugfixes - 4.0.4
~~~~~~~~~~~~~~~~
- Disable logging from ``distlib.util`` and ``filelock`` as these log messages are too verbose - by :user:`gaborbernat`. (:issue:`2655`)
- Use ``!r`` and ``repr()`` to better display erroneous values in exception from ``StrConverter.to_bool()`` - by :user:`ptmcg`. (:issue:`2665`)
Improved Documentation - 4.0.4
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Document that running ``--showconfig`` or ``--help-ini`` with the ``-v`` flag will add interleaved debugging
information, whereas tox v3 added extra lines at the start - by :user:`jugmac00`. (:issue:`2622`)
- Document that tox v4 errors when using ``-U`` when defining dependencies via ``deps`` - by :user:`jugmac00`. (:issue:`2631`)
v4.0.3 (2022-12-08)
-------------------
Bugfixes - 4.0.3
~~~~~~~~~~~~~~~~
- Always set environment variable ``PYTHONIOENCODING`` to ``utf-8`` to ensure tox works under Windows custom encodings
- by :user:`gaborbernat`. (:issue:`2422`)
- Ensure :ref:`change_dir` is created if does not exist before executing :ref:`commands` - by :user:`gaborbernat`. (:issue:`2620`)
- Pass through ``NUMBER_OF_PROCESSORS`` on Windows as is needed for ``multiprocessing.cpu_count`` -
by :user:`gaborbernat`. (:issue:`2629`)
- The core tox configuration now contains ``host_python`` key showing the host python executable path -
by :user:`gaborbernat`. (:issue:`2630`)
Improved Documentation - 4.0.3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Document that space separator is no longer valid for the :ref:`passenv` and instead one should use comma -
by :user:`gaborbernat`. (:issue:`2615`)
- Document necessity to escape ``#`` within INI configuration - by :user:`jugmac00`. (:issue:`2617`)
v4.0.2 (2022-12-07)
-------------------
Bugfixes - 4.0.2
~~~~~~~~~~~~~~~~
- Unescaped comma in substitution should not be replaced during INI expansion - by :user:`gaborbernat`. (:issue:`2616`)
- ``tox --showconfig -e py311`` reports tox section, though it should not - by :user:`gaborbernat`. (:issue:`2624`)
v4.0.1 (2022-12-07)
-------------------
Bugfixes - 4.0.1
~~~~~~~~~~~~~~~~
- Create session views of the build wheel/sdist into the :ref:`temp_dir` folder - by :user:`gaborbernat`. (:issue:`2612`)
- Default tox min_version to 4.0 instead of current tox version - by :user:`gaborbernat`. (:issue:`2613`)
v4.0.0 (2022-12-07)
-------------------
Bugfixes - 4.0.0
~~~~~~~~~~~~~~~~
- The temporary folder within the tox environment was named ``.temp`` instead of ``.tmp`` - by :user:`gaborbernat`. (:issue:`2608`)
Improved Documentation - 4.0.0
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Enumerate breaking changes of tox 4 in the FAQ, and also list major new improvements - by :user:`gaborbernat`. (:issue:`2587`)
- Document in the FAQ that tox 4 will raise a warning when finding conflicting environment names - by :user:`gaborbernat`. (:issue:`2602`)
v4.0.0rc4 (2022-12-06)
----------------------
Bugfixes - 4.0.0rc4
~~~~~~~~~~~~~~~~~~~
- Fix extras not being kept for install dependencies - by :user:`gaborbernat`. (:issue:`2603`)
Deprecations and Removals - 4.0.0rc4
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Remove deprecated configuration option ``whitelist_externals`` which was replaced by ``allowlist_externals`` - by :user:`jugmac00`. (:issue:`2599`)
v4.0.0rc3 (2022-12-05)
----------------------
Features - 4.0.0rc3
~~~~~~~~~~~~~~~~~~~
- Add ``--exit-and-dump-after`` flag that allows automatically killing tox if does not finish within the passed seconds,
and dump the thread stacks (useful to debug tox when it seemingly hangs) - by :user:`gaborbernat`. (:issue:`2595`)
Bugfixes - 4.0.0rc3
~~~~~~~~~~~~~~~~~~~
- Ensure that two parallel tox instance invocations on different tox environment targets will work by holding a file lock
onto the packaging operations (e.g., in bash ``tox4 r -e py311 &; tox4 r -e py310``) - by :user:`gaborbernat`. (:issue:`2594`)
- Fix leaking backend processes when the build backend does not support editable wheels and fix failure when multiple
environments exist that have a build backend that does not support editable wheels - by :user:`gaborbernat`. (:issue:`2595`)
v4.0.0rc2 (2022-12-04)
----------------------
Features - 4.0.0rc2
~~~~~~~~~~~~~~~~~~~
- Support for recursive extras in Python package dependencies - by :user:`gaborbernat`. (:issue:`2567`)
Bugfixes - 4.0.0rc2
~~~~~~~~~~~~~~~~~~~
- Support in INI files for ignore exit code marker the ``-`` without a subsequent space too - by :user:`gaborbernat`. (:issue:`2561`)
- Ensure paths constructed by tox are stable by resolving relative paths to fully qualified one, this insures that running
tox from a different folder than project root still generates meaningful paths - by :user:`gaborbernat`. (:issue:`2562`)
- Ensure only on run environment operates at a time on a packaging environment (fixes unexpected failures when running in
parallel mode) - by :user:`gaborbernat`. (:issue:`2564`)
- Fallback to ``editable-legacy`` if package target is ``editable`` but the build backend does not have ``build_editable``
hook - by :user:`gaborbernat`. (:issue:`2567`)
- Allow reference replacement in INI configuration via keys that contain the ``-`` character - by :user:`gaborbernat`. (:issue:`2569`)
- Resolve symlinks when saving Python executable path - by :user:`ssbarnea`. (:issue:`2574`)
- Do not set ``COLUMNS`` or ``LINES`` environment to the current TTY size if already set by the user -
by :user:`gaborbernat`. (:issue:`2575`)
- Add missing :pypi:`build[virtualenv]` test dependency - by :user:`ssbarnea`. (:issue:`2576`)
v4.0.0rc1 (2022-11-29)
----------------------
Features - 4.0.0rc1
~~~~~~~~~~~~~~~~~~~
- Add support for generative section headers - by :user:`gaborbernat`. (:issue:`2362`)
Bugfixes - 4.0.0rc1
~~~~~~~~~~~~~~~~~~~
- Allow installing relative paths that go outside tox root folder. - by :user:`ssbarnea`. (:issue:`2366`)
v4.0.0b3 (2022-11-27)
---------------------
Features - 4.0.0b3
~~~~~~~~~~~~~~~~~~
- Improve coloring of logged commands - by :user:`ssbarnea`. (:issue:`2356`)
- Pass ``PROGRAMDATA``, ``PROGRAMFILES(x86)``, ``PROGRAMFILES`` environments on Windows by default as it is needed for discovering the VS C++ compiler and start testing against 3.11 - by :user:`gaborbernat`. (:issue:`2492`)
- Support PEP-621 static metadata for getting package dependencies - by :user:`gaborbernat`. (:issue:`2499`)
- Add support for editable wheels, make it the default development mode and rename ``dev-legacy`` mode to
``editable-legacy`` - by :user:`gaborbernat`. (:issue:`2502`)
Bugfixes - 4.0.0b3
~~~~~~~~~~~~~~~~~~
- Recognize ``TERM=dumb`` or ``NO_COLOR`` environment variables. - by :user:`ssbarnea`. (:issue:`1290`)
- Allow passing config directory without filename. - by :user:`ssbarnea`. (:issue:`2340`)
- Avoid ignored explicit argument 're' console message. - by :user:`ssbarnea`. (:issue:`2342`)
- Display registered plugins with ``tox --version`` - by :user:`mxd4`. (:issue:`2358`)
- Allow ``--hash`` to be specified in requirements.txt files. - by :user:`masenf`. (:issue:`2373`)
- Avoid impossible minversion version requirements. - by :user:`ssbarnea`. (:issue:`2414`)
Improved Documentation - 4.0.0b3
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Add new documentation for tox 4 - by :user:`gaborbernat`. (:issue:`2408`)
v4.0.0b2 (2022-04-11)
---------------------
Features - 4.0.0b2
~~~~~~~~~~~~~~~~~~
- Use ``tox`` console entry point name instead of ``tox4`` - by :user:`gaborbernat`. (:issue:`2344`)
- Use ``.tox`` as working directory instead of ``.tox/4`` - by :user:`gaborbernat`. (:issue:`2346`)
- Switch to ``hatchling`` as build backend instead of ``setuptools`` - by :user:`gaborbernat`. (:issue:`2368`)
Bugfixes - 4.0.0b2
~~~~~~~~~~~~~~~~~~
- Fix CLI raises an error for ``-va`` with ``ignored explicit argument 'a'`` - by :user:`gaborbernat`. (:issue:`2343`)
- Do not interpolate values when parsing ``tox.ini`` configuration files - by :user:`gaborbernat`. (:issue:`2350`)
Improved Documentation - 4.0.0b2
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Deleted the tox mailing list -- by :user:`jugmac00` (:issue:`2364`)
v4.0.0b1 (2022-02-05)
---------------------
Features - 4.0.0b1
~~~~~~~~~~~~~~~~~~
- Display a hint for unrecognized argument CLI parse failures to use ``--`` separator to pass arguments to commands
- by :user:`gaborbernat`. (:issue:`2183`)
- Do not allow extending the config set beyond setup to ensures that all configuration values are visible via the config
sub-command. - by :user:`gaborbernat`. (:issue:`2243`)
- Print a message when ignoring outcome of commands - by :user:`gaborbernat`. (:issue:`2315`)
Bugfixes - 4.0.0b1
~~~~~~~~~~~~~~~~~~
- Fix type annotation is broken for :meth:`tox.config.sets.ConfigSet.add_config` when adding a container type
- by :user:`gaborbernat`. (:issue:`2233`)
- Insert ``TOX_WORK_DIR``, ``TOX_ENV_NAME``, ``TOX_ENV_DIR`` and ``VIRTUAL_ENV`` into the environment variables for all
tox environments to keep contract with tox version 3 - by :user:`gaborbernat`. (:issue:`2259`)
- Fix plugin initialization order - core plugins first, then 3rd party and finally inline - by :user:`gaborbernat`. (:issue:`2264`)
- Legacy parallel mode should accept ``-p`` flag without arguments - by :user:`gaborbernat`. (:issue:`2299`)
- Sequential run fails because the packaging environment is deleted twice for sequential runs with recreate flag on
- by :user:`gaborbernat`. (:issue:`2300`)
- Require Python 3.10 to generate docs - by :user:`jugmac00`. (:issue:`2321`)
- Environment assignment for output breaks when using ``-rv`` (when we cannot guess upfront the verbosity level from the
CLI arguments) - by :user:`gaborbernat`. (:issue:`2324`)
- ``devenv`` command does not respect specified path - by :user:`gaborbernat`. (:issue:`2325`)
Improved Documentation - 4.0.0b1
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Enable link check during documentation build - by :user:`gaborbernat`. (:issue:`806`)
- Document ownership of the ``tox.wiki`` root domain - by :user:`gaborbernat`. (:issue:`2242`)
- Document :meth:`tox.config.sets.ConfigSet.loaders` - by :user:`gaborbernat`. (:issue:`2287`)
- Fix CLI documentation is missing and broken documentation references - by :user:`gaborbernat`. (:issue:`2310`)
v4.0.0a10 (2022-01-04)
----------------------
Features - 4.0.0a10
~~~~~~~~~~~~~~~~~~~
- Support for grouping environment values together by applying labels to them either at :ref:`core ` and
:ref:`environment ` level, and allow selecting them via the :ref:`-m ` flag from the CLI - by
:user:`gaborbernat`. (:issue:`238`)
- Support for environment files within the :ref:`set_env` configuration via the ``file|`` prefix - by :user:`gaborbernat`. (:issue:`1938`)
- Support for ``--no-provision`` flag - by :user:`gaborbernat`. (:issue:`1951`)
- Missing ``pyproject.toml`` or ``setup.py`` file at the tox root folder without the ``--install-pkg`` flag assumes no
packaging - by :user:`gaborbernat`. (:issue:`1964`)
- Add ``external`` package type for :ref:`package` (see :ref:`external-package-builder`), and extract package dependencies
for packages passed in via :ref:`--installpkg ` - by :user:`gaborbernat`. (:issue:`2204`)
- Add support for rewriting script invocations that have valid shebang lines when the ``TOX_LIMITED_SHEBANG`` environment
variable is set and not empty - by :user:`gaborbernat`. (:issue:`2208`)
- Support for the ``--discover`` CLI flag - by :user:`gaborbernat`. (:pull:`2245`)
- Moved the python packaging logic into a dedicate package :pypi:`pyproject-api` and
use it as a dependency - by :user:`gaborbernat`. (:pull:`2274`)
- Drop python 3.6 support - by :user:`gaborbernat`. (:pull:`2275`)
- Support for selecting target environments with a given factor via the :ref:`-f ` CLI environment flag - by
:user:`gaborbernat`. (:pull:`2290`)
Bugfixes - 4.0.0a10
~~~~~~~~~~~~~~~~~~~
- Fix ``CTRL+C`` is not stopping the process on Windows - by :user:`gaborbernat`. (:issue:`2159`)
- Fix list/depends commands can create tox package environment as runtime environment and display an error message
- by :user:`gaborbernat`. (:pull:`2234`)
Deprecations and Removals - 4.0.0a10
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- ``tox_add_core_config`` and ``tox_add_env_config`` now take a ``state: State`` argument instead of a configuration one,
and ``Config`` not longer provides the ``envs`` property (instead users should migrate to ``State.envs``) - by
:user:`gaborbernat`. (:pull:`2275`)
v4.0.0a9 (2021-09-16)
---------------------
Features - 4.0.0a9
~~~~~~~~~~~~~~~~~~
- Expose the parsed CLI arguments on the main configuration object for plugins and allow plugins to define their own
configuration section -- by :user:`gaborbernat`. (:pull:`2191`)
- Let tox run fail when all envs are skipped -- by :user:`jugmac00`. (:issue:`2195`)
- Expose the configuration loading mechanism to plugins to define and load their own sections. Add
:meth:`tox_add_env_config ` plugin hook called after the configuration environment
is created for a tox environment and removed ``tox_configure``. Add the main configuration object as argument to
:meth:`tox_add_core_config `. Move the environment list method from the state to
the main configuration object to allow its use within plugins -- by :user:`gaborbernat`. (:issue:`2200`)
- Allow running code in plugins before and after commands via
:meth:`tox_before_run_commands ` and
:meth:`tox_after_run_commands ` plugin points -- by :user:`gaborbernat`. (:issue:`2201`)
- Allow plugins to update the :ref:`set_env` and change the :ref:`pass_env` configurations -- by :user:`gaborbernat`. (:issue:`2215`)
Bugfixes - 4.0.0a9
~~~~~~~~~~~~~~~~~~
- Fix env variable substitutions with defaults containing colon (e.g. URL) -- by :user:`comabrewer`. (:issue:`2182`)
- Do not allow constructing ``ConfigSet`` directly and implement ``__contains__`` for ``Loader`` -- by
:user:`gaborbernat`. (:pull:`2209`)
- Fix old-new value on recreate cache miss-match are swapped -- by :user:`gaborbernat`. (:issue:`2211`)
- Report fails when report does not support Unicode characters -- by :user:`gaborbernat`. (:issue:`2213`)
Improved Documentation - 4.0.0a9
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Adopt furo theme, update our state diagram and description in user docs (SVG + light/dark variant), split
the Python API into its own page from under the plugin page, and document plugin adoption under the ``tox-dev``
organization - by :user:`gaborbernat`. (:issue:`1881`)
v4.0.0a8 (2021-08-21)
---------------------
Features - 4.0.0a8
~~~~~~~~~~~~~~~~~~
- Add support for :ref:`allowlist_externals`, commands not matching error - by :user:`gaborbernat`. (:issue:`1127`)
- Add outcome of environments into the result json (:ref:`--result-json `) under the ``result`` key
containing ``success`` boolean, ``exit_code`` integer and ``duration`` float value - by :user:`gaborbernat`. (:issue:`1405`)
- Add ``exec`` subcommand that allows users to run an arbitrary command within the tox environment (without needing to
modify their configuration) - by :user:`gaborbernat`. (:issue:`1790`)
- Add check to validate the base Python names and the environments name do not conflict Python spec wise, when they do
raise error if :ref:`ignore_base_python_conflict` is not set or ``False`` - by :user:`gaborbernat`. (:issue:`1840`)
- Allow any Unix shell-style wildcards expression for :ref:`pass_env` - by :user:`gaborbernat`. (:issue:`2121`)
- Add support for :ref:`args_are_paths` flag - by :user:`gaborbernat`. (:issue:`2122`)
- Add support for :ref:`env_log_dir` (compared to tox 3 extend content and keep only last run entries) -
by :user:`gaborbernat`. (:issue:`2123`)
- Add support for ``{:}`` substitution in ini files as placeholder for the OS path separator - by :user:`gaborbernat`. (:issue:`2125`)
- When cleaning directories (for tox environment, ``env_log_dir``, ``env_tmp_dir`` and packaging metadata folders) do not
delete the directory itself and recreate, but instead just delete its content (this allows the user to cd into it and
still be in a valid folder after a new run) - by :user:`gaborbernat`. (:pull:`2139`)
- Changes to help plugin development: simpler tox env creation argument list, expose python creation directly,
allow skipping list dependencies install command for pip and executable is only part of the python cache for virtualenv
- by :user:`gaborbernat`. (:pull:`2172`)
Bugfixes - 4.0.0a8
~~~~~~~~~~~~~~~~~~
- Support ``#`` character in path for the tox project - by :user:`gaborbernat`. (:issue:`763`)
- If the command expression fails to parse with shlex fallback to literal pass through of the remaining elements
- by :user:`gaborbernat`. (:issue:`1944`)
- tox config fails on :ref:`--recreate ` flag, and once specified the output does not reflect the
impact of the CLI flags - by :user:`gaborbernat`. (:issue:`2037`)
- Virtual environment creation for Python is always triggered at every run - by :user:`gaborbernat`. (:issue:`2041`)
- Add support for setting :ref:`suicide_timeout`, :ref:`interrupt_timeout` and :ref:`terminate_timeout` - by
:user:`gaborbernat`. (:issue:`2124`)
- Parallel show output not working when there's a packaging phase in the run - by :user:`gaborbernat`. (:pull:`2161`)
Improved Documentation - 4.0.0a8
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Note constraint files are a subset of requirement files - by :user:`gaborbernat`. (:issue:`1939`)
- Add a note about having a package with different Python requirements than tox and not specifying :ref:`base_python` -
by :user:`gaborbernat`. (:issue:`1975`)
- Fix :ref:`--runner ` is missing default value and documentation unclear - by :user:`gaborbernat`. (:issue:`2004`)
v4.0.0a7 (2021-07-28)
---------------------
Features - 4.0.0a7
~~~~~~~~~~~~~~~~~~
- Add support for configuration taken from the ``setup.cfg`` file -by :user:`gaborbernat`. (:issue:`1836`)
- Add support for configuration taken from the ``pyproject.toml`` file, ``tox`` section ``legacy_tox_ini`` key - by
:user:`gaborbernat`. (:issue:`1837`)
- Add configuration documentation - by :user:`gaborbernat`. (:issue:`1914`)
- Implemented ``[]`` substitution (alias for ``{posargs}``) - by
:user:`hexagonrecursion`. (:issue:`1928`)
- Implement ``[testenv] ignore_outcome`` - "a failing result of this testenv will not make tox fail" - by :user:`hexagonrecursion`. (:issue:`1947`)
- Inline plugin support via ``tox_.py``. This is loaded where the tox config source is discovered. It's a Python file
that can contain arbitrary Python code, such as definition of a plugin. Eventually we'll add a plugin that allows
succinct declaration/generation of new tox environments - by :user:`gaborbernat`. (:pull:`1963`)
- Introduce the installer concept, and collect pip installation into a ``pip`` package, also attach to this
the requirements file parsing which got a major rework - by :user:`gaborbernat`. (:pull:`1991`)
- Support CPython ``3.10`` -by :user:`gaborbernat`. (:pull:`2014`)
Bugfixes - 4.0.0a7
~~~~~~~~~~~~~~~~~~
- Environments with a platform mismatch are no longer silently skipped, but properly reported - by :user:`jugmac00`. (:issue:`1926`)
- Port pip requirements file parser to ``tox`` to achieve full equivalency (such as support for the per requirement
``--install-option`` and ``--global-option`` flags) - by :user:`gaborbernat`. (:issue:`1929`)
- Support for extras with paths for Python deps and requirement files - by :user:`gaborbernat`. (:issue:`1933`)
- Due to a bug ``\{posargs} {posargs}`` used to expand to literal ``{posargs} {posargs}``.
Now the second ``{posargs}`` is expanded.
``\{posargs} {posargs}`` expands to ``{posargs} positional arguments here`` - by :user:`hexagonrecursion`. (:issue:`1956`)
- Enable setting a different ``upstream`` repository for the coverage diff report.
This has been hardcoded to ``upstream/rewrite`` until now.
by :user:`jugmac00`. (:issue:`1972`)
- Enable replacements (a.k.a section substitutions) for section names containing a dash in sections
without the ``testenv:`` prefix - by :user:`jugmac00`, :user:`obestwalter`, :user:`eumiro`. (:issue:`1985`)
- Fix legacy list env command for empty/missing envlist - by :user:`jugmac00`. (:issue:`1987`)
- Requirements and constraints files handling got reimplemented, which should fix all open issues related to this area
- by :user:`gaborbernat`. (:pull:`1991`)
- Use importlib instead of ``__import__`` - by :user:`dmendek`. (:issue:`1995`)
- Evaluate factor conditions for ``command`` keys - by :user:`jugmac00`. (:issue:`2002`)
- Prefer f-strings instead of the str.format method - by :user:`eumiro`. (:issue:`2012`)
- Fix regex validation for SHA 512 hashes - by :user:`jugmac00`. (:issue:`2018`)
- Actually run all environments when ``ALL`` is provided to the legacy env command - by :user:`jugmac00`. (:issue:`2112`)
- Move from ``appdirs`` to ``platformdirs`` - by :user:`gaborbernat`. (:pull:`2117`)
- Move from ``toml`` to ``tomli`` - by :user:`gaborbernat`. (:pull:`2118`)
Improved Documentation - 4.0.0a7
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Start documenting the plugin interface. Added :meth:`tox_register_tox_env `,
:meth:`tox_add_option `,
:meth:`tox_add_core_config `,
``tox_configure`` - by :user:`gaborbernat`. (:pull:`1991`)
- Explain how ``-v`` and ``-q`` flags play together to determine CLI verbosity level - by :user:`jugmac00`. (:issue:`2005`)
- Start polishing the documentation for the upcoming final release - by :user:`jugmac00`. (:pull:`2006`)
- Update documentation about changelog entries for trivial changes - by :user:`jugmac00`. (:issue:`2007`)
v4.0.0a6 (2021-02-15)
---------------------
Features - 4.0.0a6
~~~~~~~~~~~~~~~~~~
- Add basic quickstart implementation (just use pytest with the current Python version) - by :user:`gaborbernat`. (:issue:`1829`)
- Support comments via the ``#`` character within the ini configuration (to force a literal ``#`` use ``\#``) -
by :user:`gaborbernat`. (:issue:`1831`)
- Add support for the ``install_command`` settings in the virtual env test environments - by :user:`gaborbernat`. (:issue:`1832`)
- Add support for the ``package_root`` \ ``setupdir`` ( Python scoped) configuration that sets the root directory used for
packaging (the location of the historical ``setup.py`` and modern ``pyproject.toml``). This can be set at root level, or
at tox environment level (the later takes precedence over the former) - by :user:`gaborbernat`. (:issue:`1838`)
- Implement support for the ``--installpkg`` CLI flag - by :user:`gaborbernat`. (:issue:`1839`)
- Add support for the ``list_dependencies_command`` settings in the virtual env test environments - by
:user:`gaborbernat`. (:issue:`1842`)
- Add support for the ``ignore_errors`` settings in tox test environments - by :user:`gaborbernat`. (:issue:`1843`)
- Add support for the ``pip_pre`` settings for virtual environment based tox environments - by :user:`gaborbernat`. (:issue:`1844`)
- Add support for the ``platform`` settings in tox test environments - by :user:`gaborbernat`. (:issue:`1845`)
- Add support for the ``recreate`` settings in tox test environments - by :user:`gaborbernat`. (:issue:`1846`)
- Allow Python test and packaging environments with version 2.7 - by :user:`gaborbernat`. (:pull:`1900`)
- Do not construct a requirements file for deps in virtualenv, instead pass content as CLI argument to pip - by
:user:`gaborbernat`. (:pull:`1906`)
- Do not display status update environment reports when interrupted or for the final environment ran (because at the
final report will be soon printed and makes the status update redundant) - by :user:`gaborbernat`. (:issue:`1909`)
- The ``_TOX_SHOW_THREAD`` environment variable can be used to print alive threads when tox exists (useful to debug
when tox hangs because of some non-finished thread) and also now prints the pid of the local subprocess when reporting
the outcome of an execution - by :user:`gaborbernat`. (:pull:`1915`)
Bugfixes - 4.0.0a6
~~~~~~~~~~~~~~~~~~
- Normalize description text to collapse newlines and one or more than whitespace to a single space - by
:user:`gaborbernat`. (:issue:`1829`)
- Support aliases in show config key specification (will print with the primary key) - by :user:`gaborbernat`. (:issue:`1831`)
- Show config no longer marks as unused keys that are inherited (e.g. if the key is coming from ``testenv`` section and our
target is ``testenv:fix``) - by :user:`gaborbernat`. (:issue:`1833`)
- ``--alwayscopy`` and ``--sitepackages`` legacy only flags do not work - by :user:`gaborbernat`. (:issue:`1839`)
- Fix handling of ``commands_pre``/``commands``/``commands_post`` to be in line with tox 3 (returned incorrect exit codes
and post was not always executed) - by :user:`gaborbernat`. (:issue:`1843`)
- Support requirement files containing ``--hash`` constraints - by :user:`gaborbernat`. (:issue:`1903`)
- Fix a bug that caused tox to never finish when pulling configuration from a tox run environment that was never executed
- by :user:`gaborbernat`. (:pull:`1915`)
Deprecations and Removals - 4.0.0a6
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- - Drop support for ``sdistsrc`` flag because introduces a significant complexity and is barely used (5 hits on a github
search).
- ``--skip-missing-interpreters``, ``--notest``, ``--sdistonly``, ``--installpkg``, ``--develop`` and
``--skip-pkg-install`` CLI flags are no longer available for ``devenv`` (enforce the only sane value for these).
By :user:`gaborbernat` (:issue:`1839`)
- Remove Jenkins override support: this feature goes against the spirit of tox - blurring the line between the CI and
local runs. It also singles out a single CI provider, which opens the door for other CIs wanting similar functionality.
Finally, only 54 code file examples came back on a Github search, showing this is a not widely used feature. People who
still want Jenkins override support may create a tox plugin to achieve this functionality - by :user:`gaborbernat`. (:issue:`1841`)
v4.0.0a5 (2021-01-23)
---------------------
Features - 4.0.0a5
~~~~~~~~~~~~~~~~~~
- Support the ``system_site_packages``/``sitepackages`` flag for virtual environment based tox environments -
by :user:`gaborbernat`. (:issue:`1847`)
- Support the ``always_copy``/``alwayscopy`` flag for virtual environment based tox environments -
by :user:`gaborbernat`. (:issue:`1848`)
- Support the ``download`` flag for virtual environment based tox environments - by :user:`gaborbernat`. (:issue:`1849`)
- Recreate virtual environment based tox environments when the ``virtualenv`` version changes - by :user:`gaborbernat`. (:issue:`1865`)
Bugfixes - 4.0.0a5
~~~~~~~~~~~~~~~~~~
- Not all package dependencies are installed when different tox environments in the same run use different set of
extras - by :user:`gaborbernat`. (:issue:`1868`)
- Support ``=`` separator in requirement file flags, directories as requirements and correctly set the root of the
requirements file when using the ``--root`` CLI flag to change the root - by :user:`gaborbernat`. (:issue:`1853`)
- Cleanup local subprocess file handlers when exiting runs (fixes ``ResourceWarning: unclosed file`` errors when running
with ``env PYTHONTRACEMALLOC=5 PYTHONDEVMODE=y`` under a Python built with ``--with-pydebug``)
- by :user:`gaborbernat`. (:issue:`1857`)
- Various small bugfixes:
- honor updating default environment variables set by internal tox via set env (``PIP_DISABLE_PIP_VERSION_CHECK``)
- do not multi-wrap ``HandledError`` in the ini file loader,
- skipped environments are logged now with their fail message at default verbosity level,
- fix an error that made the show configuration command crash when making the string of a config value failed,
- support empty-new lines within the set env configurations replacements,
by :user:`gaborbernat`. (:pull:`1864`)
Improved Documentation - 4.0.0a5
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Add CLI documentation - by :user:`gaborbernat`. (:pull:`1852`)
v4.0.0a4 (2021-01-16)
---------------------
Features - 4.0.0a4
~~~~~~~~~~~~~~~~~~
- Use ``.tox/4`` instead of ``.tox4`` folder (so ignores for tox 3 works for tox 4 too), reminder we'll rename this to
just ``.tox`` before public release, however to encourage testing tox 4 in parallel with tox 3 this is helpful
- by :user:`gaborbernat`. (:discussion:`1812`)
- Colorize the ``config`` command: section headers are yellow, keys are green, values remained white, exceptions are light
red and comments are cyan - by :user:`gaborbernat`. (:pull:`1821`)
Bugfixes - 4.0.0a4
~~~~~~~~~~~~~~~~~~
- Support legacy format (``-cconstraint.txt``) of constraint files in ``deps``, and expand constraint files too when
viewing inside the ``deps`` or calculating weather our environment is up to date or not - by :user:`gaborbernat`. (:issue:`1788`)
- When specifying requirements/editable/constraint paths within ``deps`` escape space, unless already escaped to support
running specifying transitive requirements files within deps - by :user:`gaborbernat`. (:issue:`1792`)
- When using a provisioned tox environment requesting ``--recreate`` failed with ``AttributeError`` -
by :user:`gaborbernat`. (:issue:`1793`)
- Fix ``RequirementsFile`` from tox is rendered incorrectly in ``config`` command - by :user:`gaborbernat`. (:issue:`1820`)
- Fix a bug in the configuration system where referring to the same named key in another env/section causes circular
dependency error - by :user:`gaborbernat`. (:pull:`1821`)
- Raise ``ValueError`` with descriptive message when a requirements file specified does not exist
- by :user:`gaborbernat`. (:pull:`1828`)
- Support all valid requirement file specification without delimiting space in the ``deps`` of the ``tox.ini`` -
by :user:`gaborbernat`. (:issue:`1834`)
Improved Documentation - 4.0.0a4
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Add code style guide for contributors - by :user:`gaborbernat`. (:issue:`1734`)
v4.0.0a3 (2021-01-13)
---------------------
Features - 4.0.0a3
~~~~~~~~~~~~~~~~~~
- Raise exception when set env enters into a circular reference - by :user:`gaborbernat`. (:issue:`1779`)
- - Raise exception when variable substitution enters into a circle.
- Add ``{/}`` as substitution for os specific path separator.
- Add ``{env_bin_dir}`` constant substitution.
- Implement support for ``--discover`` flag - by :user:`gaborbernat`. (:pull:`1784`)
Bugfixes - 4.0.0a3
~~~~~~~~~~~~~~~~~~
- Entries in the ``set_env`` does not reference environments from ``set_env`` - by :user:`gaborbernat`. (:issue:`1776`)
- ``env`` substitution does not uses values from ``set_env`` - by :user:`gaborbernat`. (:issue:`1779`)
- Adopt tox 3 base pass env list, by adding:
- on all platforms: ``LANG``, ``LANGUAGE``, ``CURL_CA_BUNDLE``, ``SSL_CERT_FILE`` , ``LD_LIBRARY_PATH`` and ``REQUESTS_CA_BUNLDE``,
- on Windows: ``SYSTEMDRIVE`` - by :user:`gaborbernat`. (:issue:`1780`)
- Fixed a bug that crashed tox where calling tox with the recreate flag and when multiple environments were reusing the
same package - by :user:`gaborbernat`. (:issue:`1782`)
- - Python version markers are stripped in package dependencies (after wrongfully being detected as an extra marker).
- In packaging APIs do not set ``PYTHONPATH`` (to empty string) if ``backend-path`` is empty.
- Fix commands parsing on Windows (do not auto-escape ``\`` - instead users should use the new ``{\}``, and on parsed
arguments strip both ``'`` and ``"`` quoted outcomes).
- Allow windows paths in substitution set/default (the ``:`` character used to separate substitution arguments may
also be present in paths on Windows - do not support single capital letter values as substitution arguments) -
by :user:`gaborbernat`. (:pull:`1784`)
- Rework how we handle Python packaging environments:
- the base packaging environment changed from ``.package`` to ``.pkg``,
- merged the ``sdist``, ``wheel`` and ``dev`` separate packaging implementations into one, and internally dynamically
pick the one that's needed,
- the base packaging environment always uses the same Python environment as tox is installed into,
- the base packaging environment is used to get the metadata of the project (via PEP-517) and to build ``sdist`` and
``dev`` packages,
- for building wheels introduced a new per env configurable option ``wheel_build_env``, if the target Python major/minor
and implementation for the run tox environment and the base package tox environment matches set this to ``.pkg``,
otherwise this is ``.pkg-{implementation}{major}{minor}``,
- internally now packaging environments can create further packaging environments they are responsible of managing,
- updated ``depends`` to use the packaging logic,
- add support skip missing interpreters for depends and show config,
by :user:`gaborbernat`. (:issue:`1804`)
v4.0.0a2 (2021-01-09)
---------------------
Features - 4.0.0a2
~~~~~~~~~~~~~~~~~~
- Add option to disable colored output, and support ``NO_COLOR`` and ``FORCE_COLOR`` environment variables - by
:user:`gaborbernat`. (:pull:`1630`)
Bugfixes - 4.0.0a2
~~~~~~~~~~~~~~~~~~
- Fix coverage generation in CI - by :user:`gaborbernat`. (:pull:`1551`)
- Fix the CI failures:
- drop Python 3.5 support as it's not expected to get to a release before EOL,
- fix test using ``\n`` instead of ``os.linesep``,
- Windows Python 3.6 does not contain ``_overlapped.ReadFileInto``
- by :user:`gaborbernat`. (:pull:`1556`)
Improved Documentation - 4.0.0a2
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Add base documentation by merging virtualenv structure with tox 3 - by :user:`gaborbernat`. (:pull:`1551`)
v4.0.0a1
--------
* First version all is brand new.
.. warning::
The current tox is the second iteration of implementation. From version ``0.5`` all the way to ``3.X``
we numbered the first iteration. Version ``4.0.0a1`` is a complete rewrite of the package, and as such this release
history starts from there. The old changelog is still available in the
`legacy branch documentation `_.
tox-4.13.0/docs/changelog/ 0000775 0000000 0000000 00000000000 14564001166 0015273 5 ustar 00root root 0000000 0000000 tox-4.13.0/docs/changelog/template.jinja2 0000664 0000000 0000000 00000002073 14564001166 0020207 0 ustar 00root root 0000000 0000000 {% set top_underline = underlines[0] %}
{% if versiondata.name %}
v{{ versiondata.version }} ({{ versiondata.date }})
{{ top_underline * ((versiondata.version + versiondata.date)|length + 4)}}
{% else %}
{{ versiondata.version }} ({{ versiondata.date }})
{{ top_underline * ((versiondata.version + versiondata.date)|length + 3)}}
{% endif %}
{% for section, _ in sections.items() %}
{% set underline = underlines[1] %}
{% if sections[section] %}
{% for category, val in definitions.items() if category in sections[section]%}
{{ definitions[category]['name'] }} - {{ versiondata.version }}
{{ underline * ((definitions[category]['name'] + versiondata.version)|length + 3)}}
{% if definitions[category]['showcontent'] %}
{% for text, values in sections[section][category].items() %}
- {{ text }} ({{ values|join(', ') }})
{% endfor %}
{% else %}
- {{ sections[section][category]['']|join(', ') }}
{% endif %}
{% if sections[section][category]|length == 0 %}
No significant changes.
{% else %}
{% endif %}
{% endfor %}
{% else %}
No significant changes.
{% endif %}
{% endfor %}
tox-4.13.0/docs/cli_interface.rst 0000664 0000000 0000000 00000000134 14564001166 0016663 0 ustar 00root root 0000000 0000000 .. _cli:
.. sphinx_argparse_cli::
:module: tox.config.cli.parse
:func: _get_parser_doc
tox-4.13.0/docs/conf.py 0000664 0000000 0000000 00000012075 14564001166 0014650 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import re
import subprocess
import sys
from importlib.machinery import SourceFileLoader
from pathlib import Path
from subprocess import check_output
from typing import TYPE_CHECKING, Any
from sphinx.domains.python import PythonDomain
from sphinx.ext.extlinks import ExternalLinksChecker
from tox import __version__
if TYPE_CHECKING:
from docutils.nodes import Element, reference
from sphinx.addnodes import pending_xref
from sphinx.application import Sphinx
from sphinx.builders import Builder
from sphinx.environment import BuildEnvironment
from sphinx.ext.autodoc import Options
company, name = "tox-dev", "tox"
release, version = __version__, ".".join(__version__.split(".")[:2])
copyright = f"{company}" # noqa: A001
master_doc, source_suffix = "index", ".rst"
html_theme = "furo"
html_title, html_last_updated_fmt = "tox", "%Y-%m-%dT%H:%M:%S"
pygments_style, pygments_dark_style = "sphinx", "monokai"
html_static_path, html_css_files = ["_static"], ["custom.css"]
html_logo, html_favicon = "_static/img/tox.svg", "_static/img/toxfavi.ico"
extensions = [
"sphinx.ext.autodoc",
"sphinx.ext.autosectionlabel",
"sphinx.ext.extlinks",
"sphinx.ext.intersphinx",
"sphinx_argparse_cli",
"sphinx_autodoc_typehints",
"sphinx_inline_tabs",
"sphinx_copybutton",
]
exclude_patterns = ["_build", "changelog/*", "_draft.rst"]
autoclass_content, autodoc_member_order, autodoc_typehints = "class", "bysource", "none"
autodoc_default_options = {
"member-order": "bysource",
"undoc-members": True,
"show-inheritance": True,
}
autosectionlabel_prefix_document = True
extlinks = {
"issue": ("https://github.com/tox-dev/tox/issues/%s", "#%s"),
"pull": ("https://github.com/tox-dev/tox/pull/%s", "PR #%s"),
"discussion": ("https://github.com/tox-dev/tox/discussions/%s", "#%s"),
"user": ("https://github.com/%s", "@%s"),
"gh_repo": ("https://github.com/%s", "%s"),
"gh": ("https://github.com/%s", "%s"),
"pypi": ("https://pypi.org/project/%s", "%s"),
}
intersphinx_mapping = {
"python": ("https://docs.python.org/3", None),
"packaging": ("https://packaging.pypa.io/en/latest", None),
}
nitpicky = True
nitpick_ignore = []
linkcheck_workers = 10
linkcheck_ignore = [
re.escape(i)
for i in (
r"https://github.com/tox-dev/tox/issues/new?title=Trouble+with+development+environment",
r"https://www.unix.org/version2/sample/abort.html",
)
]
extlinks_detect_hardcoded_links = True
def process_signature( # noqa: PLR0913
app: Sphinx, # noqa: ARG001
objtype: str,
name: str, # noqa: ARG001
obj: Any, # noqa: ARG001
options: Options,
args: str, # noqa: ARG001
retann: str | None, # noqa: ARG001
) -> None | tuple[None, None]:
# skip-member is not checked for class level docs, so disable via signature processing
return (None, None) if objtype == "class" and "__init__" in options.get("exclude-members", set()) else None
def setup(app: Sphinx) -> None:
here = Path(__file__).parent
# 1. run towncrier
root, exe = here.parent, Path(sys.executable)
towncrier = exe.with_name(f"towncrier{exe.suffix}")
cmd = [str(towncrier), "build", "--draft", "--version", "NEXT"]
new = check_output(cmd, cwd=root, text=True, stderr=subprocess.DEVNULL) # noqa: S603
(root / "docs" / "_draft.rst").write_text("" if "No significant changes" in new else new)
class PatchedPythonDomain(PythonDomain):
def resolve_xref( # noqa: PLR0913
self,
env: BuildEnvironment,
fromdocname: str,
builder: Builder,
type: str, # noqa: A002
target: str,
node: pending_xref,
contnode: Element,
) -> Element:
# fixup some wrongly resolved mappings
mapping = {
"_io.TextIOWrapper": "io.TextIOWrapper",
"tox.config.of_type.T": "typing.TypeVar", # used by Sphinx bases
"tox.config.loader.api.T": "typing.TypeVar", # used by Sphinx bases
"tox.config.loader.convert.T": "typing.TypeVar", # used by Sphinx bases
"tox.tox_env.installer.T": "typing.TypeVar", # used by Sphinx bases
"concurrent.futures._base.Future": "concurrent.futures.Future",
}
if target in mapping:
target = node["reftarget"] = mapping[target]
return super().resolve_xref(env, fromdocname, builder, type, target, node, contnode)
app.connect("autodoc-process-signature", process_signature, priority=400)
app.add_domain(PatchedPythonDomain, override=True)
tox_cfg = SourceFileLoader("tox_conf", str(here / "tox_conf.py")).load_module().ToxConfig
app.add_directive(tox_cfg.name, tox_cfg)
def check_uri(self: ExternalLinksChecker, refnode: reference) -> None:
if refnode.document.attributes["source"].endswith("index.rst"):
return None # do not use for the index file
return prev_check(self, refnode)
prev_check, ExternalLinksChecker.check_uri = ExternalLinksChecker.check_uri, check_uri
tox-4.13.0/docs/config.rst 0000664 0000000 0000000 00000112345 14564001166 0015351 0 ustar 00root root 0000000 0000000 .. _configuration:
Configuration
+++++++++++++
tox configuration can be split into two categories: core and environment specific. Core settings are options that can
be set once and used for all tox environments, while environment options are applied to the given tox environment only.
Discovery and file types
------------------------
Out of box tox supports three configuration locations prioritized in the following order:
1. ``tox.ini``,
2. ``pyproject.toml``,
3. ``setup.cfg``.
With regards to the configuration format, at the moment we only support *ini-style*. ``tox.ini`` and ``setup.cfg`` are
by nature such files, while in ``pyproject.toml`` currently you can only inline the *ini-style* config.
Note that ``setup.cfg`` requires the content to be under the ``tox:tox`` and ``testenv`` sections and is otherwise
ignored. ``pyproject.toml`` on the other hand is in TOML format. However, one can inline the *ini-style* format under
the ``tool.tox.legacy_tox_ini`` key as a multi-line string.
``tox.ini``
~~~~~~~~~~~
The core settings are under the ``tox`` section while the environment sections are under the ``testenv:{env_name}``
section. All tox environments by default inherit setting from the ``testenv`` section. This means if tox needs an option
and is not available under ``testenv:{env_name}`` will first try to use the value from ``testenv``, before falling back
to the default value for that setting. For example:
.. code-block:: ini
[tox]
min_version = 4.0
env_list =
py310
py39
type
[testenv]
deps = pytest
commands = pytest tests
[testenv:type]
deps = mypy
commands = mypy src
``setup.cfg``
~~~~~~~~~~~~~
The core settings are under the ``tox:tox`` section while the environment sections are under the ``testenv:{env_name}``
section. All tox environments by default inherit setting from the ``testenv`` section. This means if tox needs an option
and is not available under ``testenv:{env_name}`` will first try to use the value from ``testenv``, before falling back
to the default value for that setting. For example:
.. code-block:: ini
[tox:tox]
min_version = 4.0
env_list =
py310
py39
type
[testenv]
deps = pytest
commands = pytest tests
[testenv:type]
deps = mypy
commands = mypy src
``pyproject.toml``
~~~~~~~~~~~~~~~~~~
You can inline a ``tox.ini`` style configuration under the ``tool.tox`` section and ``legacy_tox_ini`` key.
Below you find the specification for the *ini-style* format, but you might want to skim some
examples first and use this page as a reference.
.. code-block:: toml
[tool.tox]
legacy_tox_ini = """
[tox]
min_version = 4.0
env_list =
py310
py39
type
[testenv]
deps = pytest
commands = pytest tests
[testenv:type]
deps = mypy
commands = mypy src
"""
.. _conf-core:
Core
----
The following options are set in the ``[tox]`` section of ``tox.ini`` or the ``[tox:tox]`` section of ``setup.cfg``.
.. conf::
:keys: requires
:default:
:version_added: 3.2.0
Specify a list of :pep:`508` compliant dependencies that must be satisfied in the Python environment hosting tox when
running the tox command. If any of these dependencies are not satisfied will automatically create a provisioned tox
environment that does not have this issue, and run the tox command within that environment. See
:ref:`provision_tox_env` for more details.
.. code-block:: ini
[tox]
requires =
tox>=4
virtualenv>20.2
.. conf::
:keys: min_version, minversion
:default:
A string to define the minimal tox version required to run. If the host's tox version is less than this, it will
automatically create a provisioned tox environment that satisfies this requirement. See :ref:`provision_tox_env`
for more details.
.. conf::
:keys: provision_tox_env
:default: .tox
:version_added: 3.8.0
Name of the tox environment used to provision a valid tox run environment.
.. versionchanged:: 3.23.0
When tox is invoked with the ``--no-provision`` flag, the provision won't be attempted, tox will fail instead.
.. conf::
:keys: env_list, envlist
:default:
A list of environments to run by default (when the user does not specify anything during the invocation).
.. versionchanged:: 3.4.0
Which tox environments are run during the tox invocation can be further filtered via the operating system
environment variable ``TOX_SKIP_ENV`` regular expression (e.g. ``py27.*`` means **don't** evaluate environments
that start with the key ``py27``). Skipped environments will be logged at level two verbosity level.
.. conf::
:keys: skip_missing_interpreters
:default: config
:version_added: 1.7.2
Setting this to ``true`` will force ``tox`` to return success even if some of the specified environments were
missing. This is useful for some CI systems or when running on a developer box, where you might only have a subset
of all your supported interpreters installed but don't want to mark the build as failed because of it. As expected,
the command line switch always overrides this setting if passed on the invocation. Setting it to ``config`` means
that the value is read from the config file.
.. conf::
:keys: tox_root, toxinidir
The root directory for the tox project (where the configuration file is found).
.. conf::
:keys: work_dir, toxworkdir
:default: {tox_root}/.tox
Directory for tox to generate its environments into, will be created if it does not exist.
.. conf::
:keys: temp_dir
:default: {work_dir}/.tmp
Directory where to put tox temporary files. For example: we create a hard link (if possible, otherwise new copy) in
this directory for the project package. This ensures tox works correctly when having parallel runs (as each session
will have its own copy of the project package - e.g. the source distribution).
.. conf::
:keys: no_package, skipsdist
:default: false
Flag indicating to perform the packaging operation or not. Set it to ``true`` when using tox for an application,
instead of a library.
.. conf::
:keys: package_env, isolated_build_env
:default: .pkg
:version_added: 3.3.0
Default name of the virtual environment used to create a source distribution from the source tree.
.. conf::
:keys: package_root, setupdir
:default: {tox_root}
Indicates where the packaging root file exists (historically setup.py file or pyproject.toml now).
.. conf::
:keys: labels
:default:
A mapping of label names to environments it applies too. For example:
.. code-block:: ini
[tox]
labels =
test = py310, py39
static = flake8, mypy
Python language core options
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.. conf::
:keys: ignore_base_python_conflict, ignore_basepython_conflict
:default: True
.. versionadded:: 3.1.0
tox allows setting the Python version for an environment via the :ref:`basepython` setting. If that's not set tox
can set a default value from the environment name (e.g. ``py310`` implies Python 3.10). Matching up the Python
version with the environment name has became expected at this point, leading to surprises when some configs don't
do so. To help with sanity of users, an error will be raised whenever the environment name version does not match
up with this expectation.
Furthermore, we allow hard enforcing this rule by setting this flag to ``true``. In such cases we ignore the
:ref:`base_python` and instead always use the base Python implied from the Python name. This allows you to configure
:ref:`base_python` in the :ref:`base` section without affecting environments that have implied base Python versions.
.. _conf-testenv:
tox environment
---------------
The following options are set in the ``[testenv]`` or ``[testenv:*]`` sections of ``tox.ini`` or ``setup.cfg``.
Base options
~~~~~~~~~~~~
.. conf::
:keys: envname, env_name
:constant:
The name of the tox environment.
.. conf::
:keys: env_dir, envdir
:default: {work_dir}/{env_name}
:version_added: 1.5
Directory assigned to the tox environment. If not absolute it would be treated as relative to :ref:`tox_root`.
.. conf::
:keys: env_tmp_dir, envtmpdir
:default: {work_dir}/{env_name}/tmp
A folder that is always reset at the start of the run.
.. conf::
:keys: env_log_dir, envlogdir
:default: {work_dir}/{env_name}/log
A folder containing log files about tox runs. It's always reset at the start of the run. Currently contains every
process invocation in the format of ``-.log``, and details the execution request (command,
environment variables, current working directory, etc.) and its outcome (exit code and standard output/error
content).
.. conf::
:keys: platform
Run on platforms that match this regular expression (empty means any platform). If a non-empty expression is defined
and does not match against the ``sys.platform`` string the entire test environment will be skipped and none of the
commands will be executed. Running ``tox -e `` will run commands for a particular platform and skip
the rest.
.. conf::
:keys: pass_env, passenv
:default:
Environment variables to pass on to the tox environment. The values are evaluated as UNIX shell-style wildcards, see
`fnmatch `_ If a specified environment variable doesn't exist in the
tox invocation environment it is ignored. The list of environment variable names is not case sensitive, for example:
passing ``A`` or ``a`` will pass through both ``A`` and ``a``.
More environment variable-related information
can be found in :ref:`environment variable substitutions`.
.. conf::
:keys: set_env, setenv
A dictionary of environment variables to set when running commands in the tox environment. Lines starting with a
``file|`` prefix define the location of environment file.
.. note::
Environment files are processed using the following rules:
- blank lines are ignored,
- lines starting with the ``#`` character are ignored,
- each line is in KEY=VALUE format; both the key and the value are stripped,
- there is no special handling of quotation marks, they are part of the key or value.
More environment variable-related information
can be found in :ref:`environment variable substitutions`.
.. conf::
:keys: parallel_show_output
:default: False
:version_added: 3.7
If set to ``True`` the content of the output will always be shown when running in parallel mode.
.. conf::
:keys: recreate
:default: False
Always recreate virtual environment if this option is true, otherwise leave it up to tox.
.. conf::
:keys: allowlist_externals
:default:
Each line specifies a command name (in glob-style pattern format) which can be used in the commands section even if
it's located outside of the tox environment. For example: if you use the unix *rm* command for running tests you can
list ``allowlist_externals=rm`` or ``allowlist_externals=/usr/bin/rm``. If you want to allow all external
commands you can use ``allowlist_externals=*`` which will match all commands (not recommended).
.. conf::
:keys: labels
:default:
:ref_suffix: env
A list of labels to apply for this environment. For example:
.. code-block:: ini
[testenv]
labels = test, core
[testenv:flake8]
labels = mypy
Execute
~~~~~~~
.. conf::
:keys: suicide_timeout
:default: 0.0
:version_added: 3.15.2
When an interrupt is sent via Ctrl+C or the tox process is killed with a SIGTERM, a SIGINT is sent to all foreground
processes. The :ref:`suicide_timeout` gives the running process time to cleanup and exit before receiving (in some
cases, a duplicate) SIGINT from tox.
.. conf::
:keys: interrupt_timeout
:default: 0.3
:version_added: 3.15
When tox is interrupted, it propagates the signal to the child process after :ref:`suicide_timeout` seconds. If the
process still hasn't exited after :ref:`interrupt_timeout` seconds, its sends a SIGTERM.
.. conf::
:keys: terminate_timeout
:default: 0.2
:version_added: 3.15
When tox is interrupted, after waiting :ref:`interrupt_timeout` seconds, it propagates the signal to the child
process, waits :ref:`interrupt_timeout` seconds, sends it a SIGTERM, waits :ref:`terminate_timeout` seconds, and
sends it a SIGKILL if it hasn't exited.
Run
~~~
.. conf::
:keys: base
:default: testenv
:version_added: 4.0.0
Inherit missing keys from these sections.
.. conf::
:keys: runner
:default:
:version_added: 4.0.0
The tox execute used to evaluate this environment. Defaults to Python virtual environments, however may be
overwritten by plugins.
.. conf::
:keys: description
:default:
A short description of the environment, this will be used to explain the environment to the user upon listing
environments.
.. conf::
:keys: depends
:default:
tox environments that this environment depends on (must be run after those).
.. warning::
``depends`` does not pull in dependencies into the run target, for example if you select ``py310,py39,coverage``
via the ``-e`` tox will only run those three (even if ``coverage`` may specify as ``depends`` other targets too -
such as ``py310, py39, py38``). This is solely meant to specify dependencies and order in between a target run
set.
.. conf::
:keys: commands_pre
:default:
:version_added: 3.4
Commands to run before running the :ref:`commands`. All evaluation and configuration logic applies from
:ref:`commands`.
.. conf::
:keys: commands
:default:
The commands to be called for testing. Only execute if :ref:`commands_pre` succeed. Each line is interpreted as one
command; however a command can be split over multiple lines by ending the line with the ``\`` character.
Commands will execute one by one in sequential fashion until one of them fails (their exit code is non-zero) or all
of them succeed. The exit code of a command may be ignored (meaning they are always considered successful) by
prefixing the command with a dash (``-``) - this is similar to how ``make`` recipe lines work. The outcome of the
environment is considered successful only if all commands (these + setup + teardown) succeeded (exit code ignored
via the ``-`` or success exit code value of zero).
.. note::
The virtual environment binary path (see :ref:`env_bin_dir`) is prepended to the ``PATH`` environment variable,
meaning commands will first try to resolve to an executable from within the virtual environment, and only after
that outside of it. Therefore ``python`` translates as the virtual environments ``python`` (having the same
runtime version as the :ref:`base_python`), and ``pip`` translates as the virtual environments ``pip``.
.. note::
``shlex`` POSIX-mode quoting rules are used to split the command line into arguments on all
supported platforms as of tox 4.4.0.
The backslash ``\`` character can be used to escape quotes, whitespace, itself, and
other characters (except on Windows, where a backslash in a path will not be interpreted as an escape).
Unescaped single quote will disable the backslash escape until closed by another unescaped single quote.
For more details, please see :doc:`shlex parsing rules `.
.. note::
Inline scripts can be used, however note these are discovered from the project root directory, and is not
influenced by :ref:`change_dir` (this only affects the runtime current working directory). To make this behavior
explicit we recommend that you make inline scripts absolute paths by prepending ``{tox_root}``, instead of
``path/to/my_script`` prefer ``{tox_root}{/}path{/}to{/}my_script``. If your inline script is platform dependent
refer to :ref:`platform-specification` on how to select different script per platform.
.. conf::
:keys: commands_post
:default:
Commands to run after running the :ref:`commands`. Execute regardless of the outcome of both :ref:`commands` and
:ref:`commands_pre`. All evaluation and configuration logic applies from :ref:`commands`.
.. conf::
:keys: change_dir, changedir
:default: {tox_root}
Change to this working directory when executing the test command. If the directory does not exist yet, it will be
created (required for Windows to be able to execute any command).
.. conf::
:keys: args_are_paths
:default: False
Treat positional arguments passed to tox as file system paths and - if they exist on the filesystem and are in
relative format - rewrite them according to the current and :ref:`change_dir` working directory. This handles
automatically transforming relative paths specified on the CLI to relative paths respective of the commands executing
directory.
.. conf::
:keys: ignore_errors
:default: False
When executing the commands keep going even if a sub-command exits with non-zero exit code. The overall status will
be "commands failed", i.e. tox will exit non-zero in case any command failed. It may be helpful to note that this
setting is analogous to the ``-k`` or ``--keep-going`` option of GNU Make.
.. conf::
:keys: ignore_outcome
:default: False
If set to true a failing result of this test environment will not make tox fail (instead just warn).
.. conf::
:keys: skip_install
:default: False
:version_added: 1.9
Skip installation of the package. This can be used when you need the virtualenv management but do not want to
install the current package into that environment.
.. conf::
:keys: package_env
:default: {package_env}
:version_added: 4.0.0
:ref_suffix: env
Name of the virtual environment used to create a source distribution from the source tree for this environment.
.. conf::
:keys: package_tox_env_type
:version_added: 4.0.0
:default: virtualenv-pep-517
tox package type used to package.
Packaging
~~~~~~~~~
.. conf::
:keys: package_root, setupdir
:default: {package_root}
:ref_suffix: env
Indicates where the packaging root file exists (historically setup.py file or pyproject.toml now).
.. _python-options:
Python options
~~~~~~~~~~~~~~
.. conf::
:keys: base_python, basepython
:default: <{env_name} python factor> or
Name or path to a Python interpreter which will be used for creating the virtual environment, first one found wins.
This determines in practice the Python for what we'll create a virtual isolated environment. Use this to specify the
Python version for a tox environment. If not specified, the virtual environments factors (e.g. name part) will be
used to automatically set one. For example, ``py310`` means ``python3.10``, ``py3`` means ``python3`` and ``py``
means ``python``. If the name does not match this pattern the same Python version tox is installed into will be used.
.. versionchanged:: 3.1
After resolving this value if the interpreter reports back a different version number than implied from the name
a warning will be printed by default. However, if :ref:`ignore_basepython_conflict` is set, the value is
ignored and we force the :ref:`base_python` implied from the factor name.
.. note::
Leaving this unset will cause an error if the package under test has a different Python requires than tox itself
and tox is installed into a Python that's not supported by the package. For example, if your package requires
Python 3.10 or later, and you install tox in Python 3.9, when you run a tox environment that has left this
unspecified tox will use Python 3.9 to build and install your package which will fail given it requires 3.10.
.. conf::
:keys: env_site_packages_dir, envsitepackagesdir
:constant:
The Python environments site package - where packages are installed (the purelib folder path).
.. conf::
:keys: env_bin_dir, envbindir
:constant:
The binary folder where console/gui scripts are generated during installation.
.. conf::
:keys: env_python, envpython
:constant:
The Python executable from within the tox environment.
Python run
~~~~~~~~~~
.. conf::
:keys: deps
:default:
Name of the Python dependencies. Installed into the environment prior to project after environment creation, but
before package installation. All installer commands are executed using the :ref:`tox_root` as the current working
directory. Each value must be one of:
- a Python dependency as specified by :pep:`440`,
- a `requirement file `_ when the value starts with
``-r`` (followed by a file path),
- a `constraint file `_ when the value starts with
``-c`` (followed by a file path).
For example:
.. code-block:: ini
[testenv]
deps =
pytest>=7,<8
-r requirements.txt
-c constraints.txt
.. conf::
:keys: use_develop, usedevelop
:default: false
:version_added: 1.6
Install the current package in development mode using :pep:`660`. This means that the package will
be installed in-place and editable.
.. note::
``package = editable`` is the preferred way to enable development/editable mode. See the details in :ref:`package`.
.. note::
PEP-660 introduced a standardized way of installing a package in development mode, providing the same effect as if
``pip install -e`` was used.
.. conf::
:keys: package
:version_added: 4.0
When option can be one of ``wheel``, ``sdist``, ``editable``, ``editable-legacy``, ``skip``, or ``external``. If
:ref:`use_develop` is set this becomes a constant of ``editable``. If :ref:`skip_install` is set this becomes a
constant of ``skip``.
.. conf::
:keys: wheel_build_env
:version_added: 4.0
:default: -
If :ref:`package` is set to ``wheel`` this will be the tox Python environment in which the wheel will be
built. The value is generated to be unique per Python flavor and version, and prefixed with :ref:`package_env` value.
This is to ensure the target interpreter and the generated wheel will be compatible. If you have a wheel that can be
reused across multiple Python versions set this value to the same across them (to avoid building a new wheel for
each one of them).
.. conf::
:keys: extras
:version_added: 2.4
:default:
A list of "extras" from the package to be installed. For example, ``extras = testing`` is equivalent to ``[testing]``
in a ``pip install`` command.
.. _external-package-builder:
External package builder
~~~~~~~~~~~~~~~~~~~~~~~~
tox supports operating with externally built packages. External packages might be provided in two ways:
- explicitly via the :ref:`--installpkg ` CLI argument,
- setting the :ref:`package` to ``external`` and using a tox packaging environment named ``_external``
(see :ref:`package_env`) to build the package. The tox packaging environment takes all configuration flags of a
:ref:`python environment `, plus the following:
.. conf::
:keys: deps
:default:
:ref_suffix: external
Name of the Python dependencies as specified by :pep:`440`. Installed into the environment prior running the build
commands. All installer commands are executed using the :ref:`tox_root` as the current working directory.
.. conf::
:keys: commands
:default:
:ref_suffix: external
Commands to run that will build the package. If any command fails the packaging operation is considered failed and
will fail all environments using that package.
.. conf::
:keys: ignore_errors
:default: False
:ref_suffix: external
When executing the commands keep going even if a sub-command exits with non-zero exit code. The overall status will
be "commands failed", i.e. tox will exit non-zero in case any command failed. It may be helpful to note that this
setting is analogous to the ``-k`` or ``--keep-going`` option of GNU Make.
.. conf::
:keys: change_dir, changedir
:default: {tox_root}
:ref_suffix: external
Change to this working directory when executing the package build command. If the directory does not exist yet, it
will be created (required for Windows to be able to execute any command).
.. conf::
:keys: package_glob
:default: {envtmpdir}{/}dist{/}*
A glob that should match the wheel/sdist file to install. If no file or multiple files is matched the packaging
operation is considered failed and will raise an error.
Python virtual environment
~~~~~~~~~~~~~~~~~~~~~~~~~~
.. conf::
:keys: system_site_packages, sitepackages
:default: False
Create virtual environments that also have access to globally installed packages. Note the default value may be
overwritten by the ``VIRTUALENV_SYSTEM_SITE_PACKAGES`` environment variable.
.. warning::
In cases where a command line tool is also installed globally you have to make sure that you use the tool installed
in the virtualenv by using ``python -m `` (if supported by the tool) or
``{env_bin_dir}/``. If you forget to do that you will get an error.
.. conf::
:keys: always_copy, alwayscopy
:default: False
Force virtualenv to always copy rather than symlink. Note the default value may be overwritten by the
``VIRTUALENV_COPIES`` or ``VIRTUALENV_ALWAYS_COPY`` (in that order) environment variables. This is useful for
situations where hardlinks don't work (e.g. running in VMS with Windows guests).
.. conf::
:keys: download
:version_added: 3.10
:default: False
True if you want virtualenv to upgrade pip/wheel/setuptools to the latest version. Note the default value may be
overwritten by the ``VIRTUALENV_DOWNLOAD`` environment variable. If (and only if) you want to choose a specific
version (not necessarily the latest) then you can add ``VIRTUALENV_PIP=20.3.3`` (and similar) to your :ref:`set_env`.
Python virtual environment packaging
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.. conf::
:keys: meta_dir
:version_added: 4.0.0
:default: {env_dir}/.meta
Directory where to put the project metadata files.
.. conf::
:keys: pkg_dir
:version_added: 4.0.0
:default: {env_dir}/.dist
Directory where to put project packages.
.. conf::
:keys: config_settings_get_requires_for_build_sdist
:version_added: 4.11
Config settings (``dict[str, str]``) passed to the ``get_requires_for_build_sdist`` backend API endpoint.
.. conf::
:keys: config_settings_build_sdist
:version_added: 4.11
Config settings (``dict[str, str]``) passed to the ``build_sdist`` backend API endpoint.
.. conf::
:keys: config_settings_get_requires_for_build_wheel
:version_added: 4.11
Config settings (``dict[str, str]``) passed to the ``get_requires_for_build_wheel`` backend API endpoint.
.. conf::
:keys: config_settings_prepare_metadata_for_build_wheel
:version_added: 4.11
Config settings (``dict[str, str]``) passed to the ``prepare_metadata_for_build_wheel`` backend API endpoint.
.. conf::
:keys: config_settings_build_wheel
:version_added: 4.11
Config settings (``dict[str, str]``) passed to the ``build_wheel`` backend API endpoint.
.. conf::
:keys: config_settings_get_requires_for_build_editable
:version_added: 4.11
Config settings (``dict[str, str]``) passed to the ``get_requires_for_build_editable`` backend API endpoint.
.. conf::
:keys: config_settings_prepare_metadata_for_build_editable
:version_added: 4.11
Config settings (``dict[str, str]``) passed to the ``prepare_metadata_for_build_editable`` backend API endpoint.
.. conf::
:keys: config_settings_build_editable
:version_added: 4.11
Config settings (``dict[str, str]``) passed to the ``build_editable`` backend API endpoint.
Pip installer
~~~~~~~~~~~~~
.. conf::
:keys: install_command
:default: python -I -m pip install {opts} {packages}
:version_added: 1.6
Determines the command used for installing packages into the virtual environment; both the package under test and its
dependencies (defined with :ref:`deps`). Must contain the substitution key ``{packages}`` which will be replaced by
the package(s) to install. You should also accept ``{opts}`` -- it will contain index server options such as
``--pre`` (configured as ``pip_pre``).
.. note::
You can also provide arbitrary commands to the ``install_command``. Please take care that these commands can be
executed on the supported operating systems. When executing shell scripts we recommend to not specify the script
directly but instead pass it to the appropriate shell as argument (e.g. prefer ``bash script.sh`` over
``script.sh``).
.. conf::
:keys: list_dependencies_command
:default: python -m pip freeze --all
:version_added: 2.4
The ``list_dependencies_command`` setting is used for listing the packages installed into the virtual environment.
This command will be executed only if executing on Continuous Integrations is detected (for example set environment
variable ``CI=1``) or if journal is active.
.. conf::
:keys: pip_pre
:default: false
:version_added: 1.9
If ``true``, adds ``--pre`` to the ``opts`` passed to :ref:`install_command`. This will cause it to install the
latest available pre-release of any dependencies without a specified version. If ``false``, pip will only install
final releases of unpinned dependencies.
.. conf::
:keys: constrain_package_deps
:default: false
:version_added: 4.4.0
If ``constrain_package_deps`` is true, then tox will create and use ``{env_dir}{/}constraints.txt`` when installing
package dependencies during ``install_package_deps`` stage. When this value is set to false, any conflicting package
dependencies will override explicit dependencies and constraints passed to ``deps``.
.. conf::
:keys: use_frozen_constraints
:default: false
:version_added: 4.4.0
When ``use_frozen_constraints`` is true, then tox will use the ``list_dependencies_command`` to enumerate package
versions in order to create ``{env_dir}{/}constraints.txt``. Otherwise the package specifications explicitly listed
under ``deps`` (or in requirements / constraints files referenced in ``deps``) will be used as the constraints. If
``constrain_package_deps`` is false, then this setting has no effect.
User configuration
------------------
tox allows creation of user level config-file to modify default values of the CLI commands. It is located in the
OS-specific user config directory under ``tox/config.ini`` path, see ``tox --help`` output for exact location. It can be
changed via ``TOX_USER_CONFIG_FILE`` environment variable. Example configuration:
.. code-block:: ini
[tox]
skip_missing_interpreters = true
Substitutions
-------------
Any ``key=value`` setting in an ini-file can make use of **value substitution**
through the ``{...}`` string-substitution pattern.
The string inside the curly braces may reference a global or per-environment config key as described above.
In substitutions, the backslash character ``\`` will act as an escape when preceding
``{``, ``}``, ``:``, ``[``, or ``]``, otherwise the backslash will be
reproduced literally::
commands =
python -c 'print("\{posargs} = \{}".format("{posargs}"))'
python -c 'print("host: \{}".format("{env:HOSTNAME:host\: not set}")'
Note that any backslashes remaining after substitution may be processed by ``shlex`` during command parsing. On POSIX
platforms, the backslash will escape any following character; on windows, the backslash will escape any following quote,
whitespace, or backslash character (since it normally acts as a path delimiter).
Special substitutions that accept additional colon-delimited ``:`` parameters
cannot have a space after the ``:`` at the beginning of line (e.g. ``{posargs:
magic}`` would be parsed as factorial ``{posargs``, having value magic).
.. _`environment variable substitutions`:
Environment variable substitutions
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If you specify a substitution string like this::
{env:KEY}
then the value will be retrieved as ``os.environ['KEY']``
and raise an Error if the environment variable
does not exist.
Environment variable substitutions with default values
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
If you specify a substitution string like this::
{env:KEY:DEFAULTVALUE}
then the value will be retrieved as ``os.environ['KEY']``
and replace with DEFAULTVALUE if the environment variable does not
exist.
If you specify a substitution string like this::
{env:KEY:}
then the value will be retrieved as ``os.environ['KEY']``
and replace with an empty string if the environment variable does not
exist.
Substitutions can also be nested. In that case they are expanded starting
from the innermost expression::
{env:KEY:{env:DEFAULT_OF_KEY}}
the above example is roughly equivalent to
``os.environ.get('KEY', os.environ['DEFAULT_OF_KEY'])``
Interactive shell substitution
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.. versionadded:: 3.4.0
It's possible to inject a config value only when tox is running in interactive shell (standard input)::
{tty:ON_VALUE:OFF_VALUE}
The first value is the value to inject when the interactive terminal is
available, the second value is the value to use when it's not (optional). A good
use case for this is e.g. passing in the ``--pdb`` flag for pytest.
.. _`command positional substitution`:
.. _`positional substitution`:
Substitutions for positional arguments in commands
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.. versionadded:: 1.0
If you specify a substitution string like this::
{posargs:DEFAULTS}
then the value will be replaced with positional arguments as provided
to the tox command::
tox arg1 arg2
In this instance, the positional argument portion will be replaced with
``arg1 arg2``. If no positional arguments were specified, the value of
DEFAULTS will be used instead. If DEFAULTS contains other substitution
strings, such as ``{env:*}``, they will be interpreted.,
Use a double ``--`` if you also want to pass options to an underlying
test command, for example::
tox -- --opt1 ARG1
will make the ``--opt1 ARG1`` appear in all test commands where ``[]`` or
``{posargs}`` was specified. By default (see ``args_are_paths``
setting), ``tox`` rewrites each positional argument if it is a relative
path and exists on the filesystem to become a path relative to the
``changedir`` setting.
Substitution for values from other sections
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
.. versionadded:: 1.4
Values from other sections can be referred to via::
{[sectionname]valuename}
which you can use to avoid repetition of config values.
You can put default values in one section and reference them in others to avoid repeating the same values:
.. code-block:: ini
[base]
deps =
pytest
mock
pytest-xdist
[testenv:dulwich]
deps =
dulwich
{[base]deps}
[testenv:mercurial]
deps =
mercurial
{[base]deps}
Other Substitutions
~~~~~~~~~~~~~~~~~~~
* ``{}`` - replaced as ``os.pathsep``
* ``{/}`` - replaced as ``os.sep``
Overriding configuration from the command line
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
You can override options in the configuration file, from the command
line.
For example, given this config:
.. code-block:: ini
[testenv]
deps = pytest
setenv =
foo=bar
commands = pytest tests
You could enable ``ignore_errors`` by running:
.. code-block:: bash
tox --override testenv.ignore_errors=True
You could add additional dependencies by running:
.. code-block:: bash
tox --override testenv.deps+=pytest-xdist,pytest-cov
You could set additional environment variables by running:
.. code-block:: bash
tox --override testenv.setenv+=baz=quux
Set CLI flags via environment variables
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
All CLI flags can be set via environment variables too, the naming convention here is ``TOX_``. E.g.
``TOX_WORKDIR`` sets the ``--workdir`` flag, or ``TOX_OVERRIDE`` sets the ``--override`` flag. For flags accepting more
than one argument, use the ``;`` character to separate these values:
.. code-block:: bash
# set FOO and bar as passed environment variable
$ env 'TOX_OVERRIDE=testenv.pass_env=FOO,BAR' tox c -k pass_env -e py
[testenv:py]
pass_env =
BAR
FOO
# append FOO and bar as passed environment variable to the list already defined in
# the tox configuration
$ env 'TOX_OVERRIDE=testenv.pass_env+=FOO,BAR' tox c -k pass_env -e py
[testenv:py]
pass_env =
BAR
FOO
# set httpx and deps to and 3.12 as base_python
$ env 'TOX_OVERRIDE=testenv.deps=httpx;testenv.base_python=3.12' .tox/dev/bin/tox c \
-k deps base_python -e py
[testenv:py]
deps = httpx
base_python = 3.12
tox-4.13.0/docs/development.rst 0000664 0000000 0000000 00000033046 14564001166 0016426 0 ustar 00root root 0000000 0000000 Development
===========
Key points
----------
If you're already experienced with submitting GitHub PRs to open-source Python projects, the following are the key
points you need to know about this project. (If you're not, you should carefully read all the documentation after this
section. This section contains only highlights; it's not a substitute for reading this entire file.)
- Check the `style guide <#style-guide>`_ below. Note that ``tox -e fix`` will not catch the following:
- Lines wrapped at less than 120 characters. Lines should be wrapped at 120 characters, not the PEP-8 standard of 79.
- Variable names should be at least two characters long.
- Documentation is in `RST `_ format; beware the
differences from GitHub Markdown. The tox ``docs`` and ``fix`` targets will catch only some RST errors; documentation
changes *must* be checked visually (see below).
- All PRs that make changes visible to an end user require a changelog entry. This should reference an issue if it
closes that issue, otherwise reference the PR. Create one or more (if there's more than one issue)
``docs/changelog/####.{feature,bugfix,doc,removal,misc}.rst`` per the `changelog entry <#changelog-entries>`_ section
below.
- GitHub Actions will do a full set of `tests and checks <#automated-testing>`_ when the PR is submitted. For local
testing you'll need to install your own "top-level" tox (using `pipx`_ or similar is fine) and use the following
targets (tox environments):
- :samp:`tox -e py [-- {pytest-arg ...}]` to `test code changes <#running-tests>`_. This will skip tests for which
you are missing dependencies, but those tests will still be run by GitHub Actions.
- ``tox -e type`` to typecheck changes. (All new code should have complete type annotations.)
- ``tox -e docs`` to build documentation changes and update the changelog, followed by viewing (with a browser) the
generated HTML files under :file:`.tox/docs_out/`. The required changelog entry can be viewed at the "Release
History" link at the left.
- ``tox -e fix`` to lint code, documentation and any other changes to the repo. This will also fix the code and
write out the changed files; you can update your commit with `git commit --amend`.
Getting started
---------------
``tox`` is a volunteer maintained open source project and we welcome contributions of all forms. The sections below will
help you get started with development, testing, and documentation. We’re pleased that you are interested in working on
tox. This document is meant to get you setup to work on tox and to act as a guide and reference to the development
setup. If you face any issues during this process, please
:issue:`open an issue ` about it on the issue tracker.
Setup
~~~~~
tox is a command line application written in Python. To work on it, you'll need:
- **Source code**: available on :gh_repo:`GitHub `. You can use ``git`` to clone the repository:
.. code-block:: shell
git clone https://github.com/tox-dev/tox
cd tox
- **Python interpreter**: We recommend using ``CPython``. You can use
`this guide `_. As an example,
you can select tests using the various ways that pytest provides:
.. code-block:: shell
# Using markers
tox -e py -- -m "not slow"
# Using keywords
tox -e py -- -k "test_extra"
Some tests require additional dependencies to be run, such is the various shell activators (``bash``, ``fish``,
``powershell``, etc). The tests will be skipped automatically if the dependencies are not present. Please note however
that in CI all tests are run; so even if all tests succeed locally for you, they may still fail in the CI.
Running linters
~~~~~~~~~~~~~~~
tox uses :pypi:`pre-commit` for managing linting of the codebase. ``pre-commit`` performs various checks on all
files in tox and uses tools that help following a consistent code style within the codebase. To use linters locally,
run:
.. code-block:: shell
tox -e fix
.. note::
Avoid using ``# noqa`` comments to suppress linter warnings - wherever possible, warnings should be fixed instead.
``# noqa`` comments are reserved for rare cases where the recommended style causes severe readability problems or
sidestep bugs within the linters.
Code style guide
~~~~~~~~~~~~~~~~
- First and foremost, the linters configured for the project must pass; this generally means following PEP-8 rules,
as codified by: ``flake8``, ``black``, ``isort``, ``pyupgrade``.
- The supported Python versions (and the code syntax to use) are listed in the ``pyproject.toml`` file
in the ``project/requires-python`` entry. However, there are some files that have to be kept compatible
with Python 2.7 to allow and test for running Python 2 envs from tox. They are listed in ``.pre-commit-config.yaml``
under ``repo: https://github.com/asottile/pyupgrade`` under ``hooks/exclude``.
Please do not attempt to modernize them to Python 3.x.
- All code (tests too) must be type annotated as much as required by ``mypy``.
- We use a line length of 120.
- Exception messages should only be capitalized (and ended with a period/exclamation mark) if they are multi-sentenced,
which should be avoided. Otherwise, use statements that start with lowercase.
- All function (including test) names must follow PEP-8, so they must be fully snake cased. All classes are upper
camel-cased.
- Prefer f-strings instead of the ``str.format`` method.
- Tests should contain as little information as possible but do use descriptive variable names within it.
Building documentation
~~~~~~~~~~~~~~~~~~~~~~
tox's documentation is built using :pypi:`Sphinx`. The documentation is written in reStructuredText. To build it
locally, run:
.. code-block:: shell
tox -e docs
The built documentation can be found in the ``.tox/docs_out`` folder and may be viewed by opening ``index.html`` within
that folder.
Contributing
-------------
Submitting pull requests
~~~~~~~~~~~~~~~~~~~~~~~~
Submit pull requests (PRs) against the ``main`` branch, providing a good description of what you're doing and why. You
must have legal permission to distribute any code you contribute to tox and it must be available under the MIT License.
Provide tests that cover your changes and run the tests locally first. tox :ref:`supports `
multiple Python versions and operating systems. Any pull request must consider and work on all these platforms.
Pull requests should be small to facilitate review. Keep them self-contained, and limited in scope. Studies have shown
that review quality falls off as patch size grows. In particular, pull requests must not be treated as
"feature branches", with ongoing development work happening within the PR. Instead, the feature should be broken up into
smaller, independent parts which can be reviewed and merged individually.
Additionally, avoid including "cosmetic" changes to code that is unrelated to your change, as these make reviewing the
PR more difficult. Examples include re-flowing text in comments or documentation, or addition or removal of blank lines
or whitespace within lines. Such changes can be made separately, as a "formatting cleanup" PR, if needed.
Automated testing
~~~~~~~~~~~~~~~~~
All pull requests and merges to the ``main`` branch are tested using :gh:`GitHub Actions `
(configured by ``check.yml`` file inside the ``.github/workflows`` directory). You can find the status and the results
to the CI runs for your PR on GitHub's Web UI for the pull request. You can also find links to the CI services' pages
for the specific builds in the form of "Details" links, in case the CI run fails and you wish to view the output.
To trigger CI to run again for a pull request, you can close and open the pull request or submit another change to the
pull request. If needed, project maintainers can manually trigger a restart of a job/build.
Changelog entries
~~~~~~~~~~~~~~~~~
The ``changelog.rst`` file is managed using :pypi:`towncrier` and all changes must be accompanied by a changelog entry.
To add an entry to the changelog, first you need to have created an issue describing the change you want to make. A pull
request itself *may* function as such, but it is preferred to have a dedicated issue (for example, in case the PR ends
up rejected due to code quality reasons).
There is no need to create an issue for trivial changes, e.g. for typo fixes.
Once you have an issue or pull request, you take the number and you create a file inside of the ``docs/changelog``
directory named after that issue number with an extension of:
- ``feature.rst``,
- ``bugfix.rst``,
- ``doc.rst``,
- ``removal.rst``,
- ``misc.rst``.
Thus if your issue or PR number is ``1234`` and this change is fixing a bug, then you would create a file
``docs/changelog/1234.bugfix.rst``. PRs can span multiple categories by creating multiple files (for instance, if you
added a feature and deprecated/removed the old feature at the same time, you would create
``docs/changelog/1234.bugfix.rst`` and ``docs/changelog/1234.remove.rst``). Likewise if a PR touches multiple issues/PRs
you may create a file for each of them with the same contents and :pypi:`towncrier` will deduplicate them.
Contents of a changelog entry
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The content of this file is reStructuredText formatted text that will be used as the content of the changelog entry.
You do not need to reference the issue or PR numbers here as towncrier will automatically add a reference to all of the
affected issues when rendering the changelog. You may append ``- by :user:USERNAME``, with a GitHub username in
backticks, if you wish.
In order to maintain a consistent style in the ``changelog.rst`` file, it is preferred to keep the entries to the
point, in sentence case, shorter than 120 characters and in an imperative tone -- an entry should complete the sentence
``This change will …``. In rare cases, where one line is not enough, use a summary line in an imperative tone followed
by a blank line separating it from a description of the feature/change in one or more paragraphs, each wrapped at 120
characters. Remember that a changelog entry is meant for end users and should only contain details relevant to an end
user.
An example of ``docs/changelog/####.bugfix.rst`` contents is:
.. code-block::
Instead of raising ``UnicodeDecodeError`` when command output includes non-utf-8 bytes, ``tox`` will now use
``surrogateescape`` error handling to convert the unrecognized bytes to escape sequences according to :pep:`383`
- by :user:`masenf`
Becoming a maintainer
~~~~~~~~~~~~~~~~~~~~~
If you want to become an official maintainer, start by helping out. As a first step, we welcome you to triage issues on
tox's issue tracker. tox maintainers provide triage abilities to contributors once they have been around for some time
and contributed positively to the project. This is optional and highly recommended for becoming a tox maintainer. Later,
when you think you're ready, get in touch with one of the maintainers and they will initiate a vote among the existing
maintainers.
.. note::
Upon becoming a maintainer, a person should be given access to various tox-related tooling across multiple
platforms. These are noted here for future reference by the maintainers:
- GitHub Push Access (provides also CI administration capabilities)
- PyPI Publishing Access
- ReadTheDocs Administration capabilities (the root domain `tox.wiki
You need to replace ```` with an actual version number according to
`Semantic Versioning `
- :user:`Bernát Gábor `
- :user:`Jürgen Gmach `
- :user:`Masen Furer `
- :user:`Oliver Bestwalter `
tox-4.13.0/docs/faq.rst 0000664 0000000 0000000 00000043353 14564001166 0014655 0 ustar 00root root 0000000 0000000 .. _faq:
FAQ
===
Here you'll find answers to some frequently asked questions.
Breaking changes in tox 4
-------------------------
Version 4 of tox should be mostly backwards compatible with version 3.
Exceptions and guidance for migrating are given in the :ref:`upgrading doc `.
New features in tox 4
---------------------
Here is a non-exhaustive list of these.
- You can now build wheel(s) instead of a source distribution during the packaging phase by using the ``wheel`` setting
for the :ref:`package` setting. If your package is a universal wheel you'll likely want to set the
:ref:`wheel_build_env` to ``.pkg`` to avoid building a wheel for every Python version you target.
- Editable wheel support was added as defined by :pep:`660` via the :ref:`package` setting to ``editable``.
- We redesigned our CLI interface, we no longer try to squeeze everything under single command, instead now we have
multiple sub-commands. For backwards compatibility if you do not specify a subcommand we'll assume you want the tox 3
legacy interface (available under the legacy subcommand), for now the list of available commands are:
.. code-block:: bash
subcommands:
tox command to execute (by default legacy)
{run,r,run-parallel,p,depends,de,list,l,devenv,d,config,c,quickstart,q,exec,e,legacy,le}
run (r) run environments
run-parallel (p) run environments in parallel
depends (de) visualize tox environment dependencies
list (l) list environments
devenv (d) sets up a development environment at ENVDIR based on the tox configuration specified
config (c) show tox configuration
quickstart (q) Command line script to quickly create a tox config file for a Python project
exec (e) execute an arbitrary command within a tox environment
legacy (le) legacy entry-point command
The ``exec`` and ``depends`` are brand new features. Other subcommands are a more powerful versions of previously
existing single flags (e.g. ``-av`` is now succeeded by the ``list`` subcommand). All subcommands have a one or two
character shortcuts for less typing on the CLI (e.g. ``tox run`` can be abbreviated to ``tox r``). For more details
see :ref:`cli`.
- Startup times should be improved because now we no longer eagerly load all configurations for all environments, but
instead these are performed lazily when needed. Side-effect of this is that if you have an invalid configuration will
not be picked up until you try to use it.
- We now discover your package dependency changes (either via :pep:`621` or otherwise via :pep:`517`
``prepare_metadata_for_build_wheel``/``build_wheel`` metadata). If new dependencies are added these will be installed
on the next run. If a dependency is removed we'll recreate the entire environment. This works for ``requirements``
files within the :ref:`deps`. This means that you should never need to use ``--recreate`` flag, tox should be smart
enough to figure out when things change and automatically apply it.
- All tox defaults can now be changed via the user level config-file (see help message output for its location, can be
changed via ``TOX_CONFIG_FILE`` environment variable).
- All tox defaults can now be changed via an environment variable: ``TOX_`` prefix followed by the settings key,
e.g. ``TOX_PACKAGE=wheel``.
- Any configuration can be overridden via the CLI ``-x`` or ``--override`` flag, e.g.
``tox run -e py311 -x testenv:py311.package=editable`` would force the packaging of environment ``py311`` to be an
editable install independent what's in the configuration file.
- :ref:`basepython` is now a list, the first successfully detected python will be used to generate python environment.
- We now have support for inline tox plugins via the ``toxfile.py`` at the root of your project. At a later time this
will allow using Python only configuration, as seen with nox.
- You can now group tox environments via :ref:`labels` configuration, and you can invoke all tox environments within a
label by using the ``-m label`` CLI flag (instead of the ``-e list_of_envs``).
- You can now invoke all tox environments within a given factor via the ``-f factor`` CLI flag.
.. _faq_custom_pypi_server:
Using a custom PyPI server
--------------------------
By default tox uses pip to install Python dependencies. Therefore to change the index server you should configure pip
directly. pip accepts environment variables as configuration flags, therefore the easiest way to do this is to set the
``PIP_INDEX_URL`` environment variable:
.. code-block:: ini
set_env =
PIP_INDEX_URL = https://tox.wiki/pypi/simple
It's considered a best practice to allow the user to change the index server rather than hard code it, allowing them to
use for example a local cache when they are offline. Therefore, a better form of this would be:
.. code-block:: ini
set_env =
PIP_INDEX_URL = {env:PIP_INDEX_URL:https://tox.wiki/pypi/simple}
Here we use an environment substitution to set the index URL if not set by the user, but otherwise default to our target
URI.
Using two PyPI servers
----------------------
When you want to use two PyPI index servers because not all dependencies are found in either of them use the
``PIP_EXTRA_INDEX_URL`` environment variable:
.. code-block:: ini
set_env =
PIP_INDEX_URL = {env:PIP_INDEX_URL:https://tox.wiki/pypi/simple-first}
PIP_EXTRA_INDEX_URL = {env:PIP_EXTRA_INDEX_URL:https://tox.wiki/pypi/simple-second}
If the index server defined under ``PIP_INDEX_URL`` does not contain a package, pip will attempt to resolve it also from
the URI from ``PIP_EXTRA_INDEX_URL``.
.. warning::
Using an extra PyPI index for installing private packages may cause security issues. For example, if ``package1`` is
registered with the default PyPI index, pip will install ``package1`` from the default PyPI index, not from the extra
one.
Using constraint files
----------------------
`Constraint files `_ are a type of artifact, supported by
pip, that define not what requirements to install but instead what version constraints should be applied for the
otherwise specified requirements. The constraint file must always be specified together with the requirement(s) to
install. While creating a test environment tox will invoke pip multiple times, in separate phases:
1. If :ref:`deps` is specified, it will install a set of dependencies before installing the package.
2. If the target environment contains a package (the project does not have :ref:`package` ``skip`` or
:ref:`skip_install` is ``true``), it will:
1. install the dependencies of the package.
2. install the package itself.
Starting in tox 4.4.0, when ``constrain_package_deps = true`` is set in the test environment,
``{env_dir}{/}constraints.txt`` will be generated during ``install_deps`` based on the package specifications listed
under ``deps``. These constraints are subsequently passed to pip during the ``install_package_deps`` stage, causing an
error to be raised when the package dependencies conflict with the test environment dependencies.
For stronger guarantees, set ``use_frozen_constraints = true`` in the test environment to generate the constraints file
based on the exact versions enumerated by the ``list_dependencies_command`` (``pip freeze``). When using frozen
constraints, if the package deps are incompatible with any previously installed dependency, an error will be raised.
To use constraints with url, path, or "extras" (``.[tests]``) deps, then you must ``use_frozen_constraints``, as these
types of deps are not valid constraints as specified (see pypa/pip#8210).
Note constraint files are a subset of requirement files. Therefore, it's valid to pass a constraint file wherever you
can specify a requirement file.
.. _platform-specification:
Platform specification
----------------------
Assuming the following layout:
.. code-block:: shell
tox.ini # see below for content
setup.py # a classic distutils/setuptools setup.py file
and the following ``tox.ini`` content:
.. code-block:: ini
[tox]
min_version = 2.0 # platform specification support is available since version 2.0
envlist = py{310,39}-{lin,mac,win}
[testenv]
# environment will be skipped if regular expression does not match against the sys.platform string
platform = lin: linux
mac: darwin
win: win32
# you can specify dependencies and their versions based on platform filtered environments
deps = lin,mac: platformdirs==3
win: platformdirs==2
# upon tox invocation you will be greeted according to your platform
commands=
lin: python -c 'print("Hello, Linus!")'
mac: python -c 'print("Hello, Tim!")'
win: python -c 'print("Hello, Satya!")'
You can invoke ``tox`` in the directory where your ``tox.ini`` resides. ``tox`` creates two virtualenv environments
with the ``python3.10`` and ``python3.9`` interpreters, respectively, and will then run the specified command according
to platform you invoke ``tox`` at.
Ignoring the exit code of a given command
-----------------------------------------
When multiple commands are defined within the :ref:`commands` configuration field tox will run them sequentially until
one of them fails (by exiting with non zero exit code) or all of them are run. If you want to ignore the status code of
a given command add a ``-`` prefix to that line (similar syntax to how the GNU ``make`` handles this):
.. code-block:: ini
[testenv]
commands =
- python -c 'import sys; sys.exit(1)'
python --version
Customizing virtual environment creation
----------------------------------------
By default tox uses the :pypi:`virtualenv` to create Python virtual environments to run your tools in. To change how tox
creates virtual environments you can set environment variables to customize virtualenv. For example, to provision a
given pip version in the virtual environment you can set ``VIRTUALENV_PIP`` or to enable system site packages use the
``VIRTUALENV_SYSTEM_SITE_PACKAGES``:
.. code-block:: ini
[testenv]
setenv =
VIRTUALENV_PIP==22.1
VIRTUALENV_SYSTEM_SITE_PACKAGES=true
Consult the :pypi:`virtualenv` project for supported values (any CLI flag for virtualenv, in all upper case, prefixed by
the ``VIRTUALENV_`` key).
Building documentation with Sphinx
----------------------------------
It's possible to orchestrate the projects documentation with tox. The advantage of this is that now generating the
documentation can be part of the CI, and whenever any validations/checks/operations fail while generating the
documentation you'll catch it within tox.
We don't recommend using the Make and Batch file generated by Sphinx, as this makes your documentation generation
platform specific. A better solution is to use tox to setup a documentation build environment and invoke sphinx inside
it. This solution is cross platform.
For example if the sphinx file structure is under the ``docs`` folder the following configuration will generate the
documentation under ``.tox/docs_out/index.html`` and print out a link to the generated documentation:
.. code-block:: ini
[testenv:docs]
description = build documentation
basepython = python3.10
deps =
sphinx>=4
commands =
sphinx-build -d "{envtmpdir}{/}doctree" docs "{toxworkdir}{/}docs_out" --color -b html
python -c 'print(r"documentation available under file://{toxworkdir}{/}docs_out{/}index.html")'
Note here we also require Python 3.10, allowing us to use f-strings within the sphinx ``conf.py``.
Building documentation with mkdocs
----------------------------------
It's possible to orchestrate the projects documentation with tox. The advantage of this is that now generating the
documentation can be part of the CI, and whenever any validations/checks/operations fail while generating the
documentation you'll catch it within tox.
It's best to define one environment to write/generate the documentation, and another to deploy it. Use the config
substitution logic to avoid duplication:
.. code-block:: ini
[testenv:docs]
description = Run a development server for working on documentation
deps =
mkdocs>=1.3
mkdocs-material
commands =
mkdocs build --clean
python -c 'print("###### Starting local server. Press Control+C to stop server ######")'
mkdocs serve -a localhost:8080
[testenv:docs-deploy]
description = built fresh docs and deploy them
deps = {[testenv:docs]deps}
commands = mkdocs gh-deploy --clean
Understanding ``InvocationError`` exit codes
--------------------------------------------
When a command executed by tox fails, it always has a non-zero exit code and an ``InvocationError`` exception is raised:
.. code-block:: shell
ERROR: InvocationError for command
'' (exited with code 1)
Generally always check the documentation for the command executed to understand what the code means. For example for
:pypi:`pytest` you'd read `here `_. On unix
systems, there are some rather `common exit codes `_. This is why for
exit codes larger than 128, if a signal with number equal to `` - 128`` is found in the :py:mod:`signal`
module, an additional hint is given:
.. code-block:: shell
ERROR: InvocationError for command
'' (exited with code 139)
Note: this might indicate a fatal error signal (139 - 128 = 11: SIGSEGV)
The signal numbers (e.g. 11 for a segmentation fault) can be found in the "Standard signals" section of the
`signal man page `_. Their meaning is described in
`POSIX signals `_. Beware that programs may issue custom exit
codes with any value, so their documentation should be consulted.
Sometimes, no exit code is given at all. An example may be found in
:gh:`pytest-qt issue #170 `, where Qt was calling
`abort() `_ instead of ``exit()``.
Access full logs
----------------
If you want to access the full logs you need to write ``-q`` and ``-v`` as individual tox arguments and avoid combining
them into a single one.
Running within a Docker container
---------------------------------
If you want to run tox within a Docker container you can use `31z4/tox `_.
This Docker image neatly packages tox along with common build dependencies (e.g., ``make``, ``gcc``, etc) and currently
`active CPython versions `_. See more details in
its `GitHub repository `_.
The recommended way of using the image is to mount the directory that contains your tox configuration files and your
code as a volume. Assuming your project is within the current directory of the host, use the following command to run
tox without any flags:
.. code-block:: shell
docker run -v `pwd`:/tests -it --rm 31z4/tox
Because an entry point of the image is ``tox``, you can easily pass subcommands and flags:
.. code-block:: shell
docker run -v `pwd`:/tests -it --rm 31z4/tox run-parallel -e black,py311
Note, that the image is configured with a working directory at ``/tests``.
If you want to install additional Python versions/implementations or Ubuntu packages you can create a derivative image.
Just make sure you switch the user to ``root`` when needed and switch back to ``tox`` afterwards:
.. code-block:: Dockerfile
FROM 31z4/tox
USER root
RUN set -eux; \
apt-get update; \
DEBIAN_FRONTEND=noninteractive \
apt-get install -y --no-install-recommends \
python3.12; \
rm -rf /var/lib/apt/lists/*
USER tox
Testing end-of-life Python versions
-----------------------------------
``tox`` uses ``virtualenv`` under its hood for managing virtual environments.
`Virtualenv 20.22.0 `_ dropped support for all
Python versions smaller or equal to Python 3.6.
If you need to test against e.g. Python 2.7, 3.5 or 3.6, you need to add the following ``requires`` statement to your
``tox.ini`` configuration files.
.. code-block:: ini
[tox]
requires = virtualenv<20.22.0
In case you need to do this for many repositories, we recommend to use
`all-repos `_.
Testing with Pytest
-------------------
Running ``pytest`` from ``tox`` can be configured like this:
.. code-block:: ini
[tox]
envlist = py311, py312
[testenv]
commands = pytest
If required, ``tox`` positional arguments can be passed through to ``pytest``:
.. code-block:: ini
[testenv]
commands = pytest {posargs}
When running ``tox`` in parallel mode (:ref:`tox-run-parallel-(p)`), care should be taken to ensure concurrent
``pytest`` invocations are fully isolated.
This can be achieved by setting ``pytest``'s base temporary directory to a unique temporary directory for each virtual
environment as provided by ``tox``:
.. code-block:: ini
[testenv]
commands = pytest --basetemp="{env_tmp_dir}"
Setting the ``pytest`` ``--basetemp`` argument also causes all temporary ``pytest`` files to be deleted immediately
after the tests are completed. To restore the default ``pytest`` behavior to retain temporary files for the most recent
``pytest`` invocations, the system's temporary directory location could be configured like this instead:
.. code-block:: ini
[tox]
set_env =
TEMP = {env_tmp_dir}
[testenv]
commands = pytest
tox-4.13.0/docs/img/ 0000775 0000000 0000000 00000000000 14564001166 0014120 5 ustar 00root root 0000000 0000000 tox-4.13.0/docs/img/overview.mermaidjs 0000664 0000000 0000000 00000002250 14564001166 0017662 0 ustar 00root root 0000000 0000000 stateDiagram-v2
%%{init:{'state':{'nodeSpacing': 0, 'rankSpacing': 20}}}%%
[*] --> conf
conf --> tox_env
state tox_env {
state hdi <>
state hpi <>
state fpi <>
[*] --> create
create --> hdi : has (new) project dependencies (deps)
hdi --> deps: yes
hdi --> hpi: no, has package
deps --> hpi: has package
hpi --> fpi: yes, built package in this run
hpi --> commands : no
fpi --> install_deps: yes
fpi --> package: no
package --> install_deps
install_deps --> install
install --> commands
commands --> commands: for each entry
for each tox environment
for each tox environment
build configuration (CLI + files)
tox_env
has (new) project dependencies (deps)
yes
no, has package
has package
yes, built package in this run
no
yes
no
for each entry
pass outcome to report
create an isolated tox environment
install project dependencies (if has deps)
run command
install (new) package dependencies
build package
install package without dependencies
report the outcome of the run
for each tox environment
for each tox environment
build configuration (CLI + files)
tox_env
has (new) project dependencies (deps)
yes
no, has package
has package
yes, built package in this run
no
yes
no
for each entry
pass outcome to report
create an isolated tox environment
install project dependencies (if has deps)
run command
install (new) package dependencies
build package
install package without dependencies
report the outcome of the run
`_).
.. image:: https://img.shields.io/pypi/v/tox?style=flat-square
:target: https://pypi.org/project/tox/#history
:alt: Latest version on PyPI
.. image:: https://img.shields.io/pypi/implementation/tox?style=flat-square
:alt: PyPI - Implementation
.. image:: https://img.shields.io/pypi/pyversions/tox?style=flat-square
:alt: PyPI - Python Version
.. image:: https://readthedocs.org/projects/tox/badge/?version=latest&style=flat-square
:target: https://tox.wiki/en/latest/
:alt: Documentation status
.. image:: https://img.shields.io/discord/802911963368783933?style=flat-square
:target: https://discord.com/invite/tox
:alt: Discord
.. image:: https://img.shields.io/pypi/dm/tox?style=flat-square
:target: https://pypistats.org/packages/tox
:alt: PyPI - Downloads
.. image:: https://img.shields.io/pypi/l/tox?style=flat-square
:target: https://opensource.org/license/mit/
:alt: PyPI - License
.. image:: https://img.shields.io/github/issues/tox-dev/tox?style=flat-square
:target: https://github.com/tox-dev/tox/issues
:alt: Open issues
.. image:: https://img.shields.io/github/issues-pr/tox-dev/tox?style=flat-square
:target: https://github.com/tox-dev/tox/pulls
:alt: Open pull requests
.. image:: https://img.shields.io/github/stars/tox-dev/tox?style=flat-square
:target: https://pypistats.org/packages/tox
:alt: Package popularity
tox is a generic virtual environment management and test command line tool you can use for:
* checking your package builds and installs correctly under different environments (such as different Python
implementations, versions or installation dependencies),
* running your tests in each of the environments with the test tool of choice,
* acting as a frontend to continuous integration servers, greatly reducing boilerplate and merging CI and
shell-based testing.
Useful links
------------
**Related projects**
tox has influenced several other projects in the Python test automation space. If tox doesn't quite fit your needs or
you want to do more research, we recommend taking a look at these projects:
- `Invoke `_
* `Bernat Gabor - Standardize Testing in Python `_
.. comment: split here
.. toctree::
:hidden:
installation
user_guide
cli_interface
config
faq
plugins
plugins_api
development
changelog
upgrading
tox-4.13.0/docs/installation.rst 0000664 0000000 0000000 00000005566 14564001166 0016613 0 ustar 00root root 0000000 0000000 Installation
============
via pipx
--------
:pypi:`tox` is a CLI tool that needs a Python interpreter (version 3.7 or higher) to run. We recommend :pypi:`pipx` to
install tox into an isolated environment. This has the added benefit that later you'll be able to upgrade tox without
affecting other parts of the system.
.. code-block:: bash
python -m pip install pipx-in-pipx --user
pipx install tox
tox --help
via pip
-------
Alternatively you can install it within the global Python interpreter itself (perhaps as a user package via the
``--user`` flag). Be cautious if you are using a Python installation that is managed by your operating system or
another package manager. ``pip`` might not coordinate with those tools, and may leave your system in an inconsistent
state. Note, if you go down this path you need to ensure pip is new enough per the subsections below:
.. code-block:: bash
python -m pip install --user tox
python -m tox --help
wheel
~~~~~
Installing tox via a wheel (default with pip) requires an installer that can understand the ``python-requires`` tag (see
:pep:`503`), with pip this is version ``9.0.0`` (released in November 2016). Furthermore, in case you're not installing
it via PyPI you need to use a mirror that correctly forwards the ``python-requires`` tag (notably the OpenStack mirrors
don't do this, or older :gh_repo:`devpi/devpi` versions - added with version ``4.7.0``).
.. _sdist:
sdist
~~~~~
When installing via a source distribution you need an installer that handles the :pep:`517` specification. In case of
``pip`` this is version ``18.0.0`` or later (released in July 2018). If you cannot upgrade your pip to support this you
need to ensure that the build requirements from :gh:`pyproject.toml ` are
satisfied before triggering the installation.
via ``setup.py``
----------------
We don't recommend and officially support this method. You should prefer using an installer that supports :pep:`517`
interface, such as pip ``19.0.0`` or later. That being said you might be able to still install a package via this method
if you satisfy build dependencies before calling the installation command (as described under :ref:`sdist`).
latest unreleased
-----------------
Installing an unreleased version is discouraged and should be only done for testing purposes. If you do so you'll need
a pip version of at least ``18.0.0`` and use the following command:
.. code-block:: bash
pip install git+https://github.com/tox-dev/tox.git@rewrite
.. _compatibility-requirements:
Python and OS Compatibility
---------------------------
tox works with the following Python interpreter implementations:
- `CPython `,
- wait for the green light by one of our maintainers (see :ref:`current-maintainers`),
- follow the `guidance by Github
`_,
- (optionally) add at least one other people as co-maintainer on PyPI.
Migration from tox 3
~~~~~~~~~~~~~~~~~~~~
This section explains how the plugin interface changed between tox 3 and 4, and provides guidance for plugin developers
on how to migrate.
``tox_get_python_executable``
-----------------------------
With tox 4 the Python discovery is performed ``tox.tox_env.python.virtual_env.api._get_python`` that delegates the job
to ``virtualenv``. Therefore first `define a new virtualenv discovery mechanism
`_ and then set that by setting the
``VIRTUALENV_DISCOVERY`` environment variable.
``tox_package``
---------------
Register new packager types via :func:`tox_register_tox_env `.
``tox_addoption``
-----------------
Renamed to :func:`tox_add_option `.
tox-4.13.0/docs/plugins_api.rst 0000664 0000000 0000000 00000005236 14564001166 0016416 0 ustar 00root root 0000000 0000000 API
===
tox objects
~~~~~~~~~~~
register
--------
.. automodule:: tox.tox_env.register
:members:
:exclude-members: REGISTER
.. autodata:: REGISTER
:no-value:
config
------
.. autoclass:: tox.config.cli.parser.ArgumentParserWithEnvAndConfig
:members:
.. autoclass:: tox.config.cli.parser.ToxParser
:members:
.. autoclass:: tox.config.cli.parser.Parsed
:members:
.. autoclass:: tox.config.main.Config
:members:
:exclude-members: __init__, make
.. autoclass:: tox.config.loader.section.Section
:members:
.. autoclass:: tox.config.loader.api.ConfigLoadArgs
:members:
.. autoclass:: tox.config.sets.ConfigSet
:members:
:special-members: __iter__, __contains__
.. autoclass:: tox.config.sets.CoreConfigSet
:members:
.. autoclass:: tox.config.sets.EnvConfigSet
:members:
.. autoclass:: tox.config.of_type.ConfigDefinition
:members:
.. autoclass:: tox.config.of_type.ConfigDynamicDefinition
:members:
.. autoclass:: tox.config.of_type.ConfigConstantDefinition
:members:
.. autoclass:: tox.config.source.api.Source
:members:
.. autoclass:: tox.config.loader.api.Override
:members:
.. autoclass:: tox.config.loader.api.Loader
:members:
.. autoclass:: tox.config.loader.convert.Convert
:members:
.. autoclass:: tox.config.types.EnvList
:members:
:special-members: __bool__, __iter__
.. autoclass:: tox.config.types.Command
:members:
.. autoclass:: tox.config.loader.convert.Factory
:members:
environments
------------
.. autoclass:: tox.tox_env.api.ToxEnv
:members:
.. autoclass:: tox.tox_env.runner.RunToxEnv
:members:
.. autoclass:: tox.tox_env.package.PackageToxEnv
:members:
.. autoclass:: tox.tox_env.package.Package
:members:
journal
-------
.. autoclass:: tox.journal.env.EnvJournal
:members:
:exclude-members: __init__
:special-members: __bool__, __setitem__
report
------
.. autoclass:: tox.report.ToxHandler
:members:
:exclude-members: stream, format, patch_thread, write_out_err, suspend_out_err
execute
-------
.. autoclass:: tox.execute.request.ExecuteRequest
:members:
.. autoclass:: tox.execute.request.StdinSource
:members:
.. autoclass:: tox.execute.api.Outcome
:members:
.. autoclass:: tox.execute.api.Execute
:members:
.. autoclass:: tox.execute.api.ExecuteStatus
:members:
.. autoclass:: tox.execute.api.ExecuteInstance
:members:
.. autoclass:: tox.execute.stream.SyncWrite
:members:
installer
---------
.. autoclass:: tox.tox_env.installer.Installer
:members:
session
-------
.. autoclass:: tox.session.state.State
:members:
.. autoclass:: tox.session.env_select.EnvSelector
:members:
.. autoclass:: tox.tox_env.info.Info
:members:
tox-4.13.0/docs/tox_conf.py 0000664 0000000 0000000 00000007011 14564001166 0015534 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING, Any, ClassVar, cast
from docutils.nodes import Element, Node, Text, container, fully_normalize_name, literal, paragraph, reference, strong
from docutils.parsers.rst.directives import flag, unchanged, unchanged_required
from docutils.statemachine import StringList, string2lines
from sphinx.domains.std import StandardDomain
from sphinx.locale import __
from sphinx.util.docutils import SphinxDirective
from sphinx.util.logging import getLogger
if TYPE_CHECKING:
from typing import Final
from docutils.parsers.rst.states import RSTState, RSTStateMachine
LOGGER = getLogger(__name__)
class ToxConfig(SphinxDirective):
name = "conf"
has_content = True
option_spec: Final[ClassVar[dict[str, Any]]] = {
"keys": unchanged_required,
"version_added": unchanged,
"version_changed": unchanged,
"default": unchanged,
"constant": flag,
"ref_suffix": unchanged,
}
def __init__( # noqa: PLR0913
self,
name: str,
arguments: list[str],
options: dict[str, str],
content: StringList,
lineno: int,
content_offset: int,
block_text: str,
state: RSTState,
state_machine: RSTStateMachine,
) -> None:
super().__init__(
name,
arguments,
options,
content,
lineno,
content_offset,
block_text,
state,
state_machine,
)
self._std_domain: StandardDomain = cast(StandardDomain, self.env.get_domain("std"))
def run(self) -> list[Node]:
self.env.note_reread() # this document needs to be always updated
line = paragraph()
line += Text("■" if "constant" in self.options else "⚙️")
for key in (i.strip() for i in self.options["keys"].split(",")):
line += Text(" ")
self._mk_key(line, key)
if "default" in self.options:
default = self.options["default"]
line += Text(" with default value of ")
line += literal(default, default)
if "version_added" in self.options:
line += Text(" 📢 added in ")
ver = self.options["version_added"]
line += literal(ver, ver)
p = container("")
self.state.nested_parse(StringList(string2lines("\n".join(f" {i}" for i in self.content))), 0, p)
line += p
return [line]
def _mk_key(self, line: paragraph, key: str) -> None:
ref_id = key if "ref_suffix" not in self.options else f"{key}-{self.options['ref_suffix']}"
ref = reference("", refid=ref_id, reftitle=key)
line.attributes["ids"].append(ref_id)
st = strong()
st += literal(text=key)
ref += st
self._register_ref(ref_id, ref_id, ref)
line += ref
def _register_ref(self, ref_name: str, ref_title: str, node: Element) -> None:
of_name, doc_name = fully_normalize_name(ref_name), self.env.docname
if of_name in self._std_domain.labels:
LOGGER.warning(
__("duplicate label %s, other instance in %s"),
of_name,
self.env.doc2path(self._std_domain.labels[of_name][0]),
location=node,
type="sphinx-argparse-cli",
subtype=self.env.docname,
)
self._std_domain.anonlabels[of_name] = doc_name, ref_name
self._std_domain.labels[of_name] = doc_name, ref_name, ref_title
tox-4.13.0/docs/upgrading.rst 0000664 0000000 0000000 00000027557 14564001166 0016076 0 ustar 00root root 0000000 0000000 .. _upgrading:
Upgrading to tox v4
===================
Version 4 is mostly backwards compatible.
This document covers all breaking changes and, where applicable, includes guidance on how to update.
See also the list of new features in the :ref:`FAQ `.
Python support
--------------
- tox now requires Python ``3.7`` or later and is tested only against CPython. You can still create test environments
for earlier Python versions or different Python interpreters. PyPy support is best effort, meaning we do not test it
as part of our CI runs, however if you discover issues under PyPy we will accept PRs addressing it.
Changed INI rules
-----------------
- The hash sign (``#``) now always acts as comment within ``tox.ini`` or ``setup.cfg`` tox configuration file. Where you
need to pass on a ``#`` character you will need to escape it in form of ``\#`` so tox does not handle everything right
of the ``#`` character as a comment. Valid in tox 3:
.. code-block:: ini
# valid in tox 3
commands = bash -c "echo 'foo#bar'"
# valid in tox 4
commands = bash -c "echo 'foo\#bar'"
- Within the ``pass_env`` you can no longer use space as value separator, instead you need to use the ``,`` or the
newline character. This is to have the same value separation rules for all tox configuration lines.
.. code-block:: ini
# valid in tox 3
passenv = ALPHA BETA
passenv =
ALPHA
BETA
# valid in tox 4
passenv = ALPHA, BETA
passenv =
ALPHA
BETA
- tox 4 now errors when using the ``-U`` flag when defining dependencies, e.g. ``deps = -Ur requirements.txt``. While
this worked in tox 3, it was never supported officially. Additionally, in the context of a new virtual environment
this flag makes no sense anyway.
- tox 4 requires the ``install_command`` to evaluate to a non-empty value for each target environment. In tox 3, an
empty value would be substituted for the default install command.
Known regressions
-----------------
- On Windows, the tty trait of the caller environment is no longer passed through. The most notable impact of this
change is that some tools no longer show colored output. You may need to force colorization to be for such enabled
for such tools. See :issue:`2337` for more details.
New plugin system
-----------------
tox 4 is a grounds up rewrite of the code base, and while we kept the configuration layer compatibility no such effort
has been made for the programmatic API. Therefore, all plugins will need to redo their integration against the new code
base. If you're a plugin developer refer to the `plugin documentation `_ for
more information.
Removed tox.ini keys
--------------------
+--------------------------+-----------------------------------------------------------------+
| Configuration key | Migration path |
+==========================+=================================================================+
| ``indexserver`` | See :ref:`Using a custom PyPI server `. |
+--------------------------+-----------------------------------------------------------------+
| ``whitelist_externals`` | Use :ref:`allowlist_externals` key instead. |
+--------------------------+-----------------------------------------------------------------+
| ``isolated_build`` | Isolated builds are now always used. |
+--------------------------+-----------------------------------------------------------------+
| ``distdir`` | Use the ``TOX_PACKAGE`` environment variable. |
+--------------------------+-----------------------------------------------------------------+
basepython not resolved
-----------------------
The base python configuration is no longer resolved to ``pythonx.y`` format, instead is kept as ``py39``, and is
the virtualenv project that handles mapping that to a Python interpreter. If you were using this variable we recommend
moving to the newly added ``py_impl`` and ``py_dot_ver`` variables, for example:
.. code-block:: ini
deps = -r{py_impl}{py_dot_ver}-req.txt
Failure when all environments are skipped
-----------------------------------------
A run that results in all environments being skipped will no longer result in success. Instead, a failure will be
reported. For example, consider a host that does not support Python 3.5:
.. code-block:: bash
tox run --skip-missing-interpreters=true -e py35
This will now result in a failure.
Substitutions removed
---------------------
- The ``distshare`` and ``homedir`` substitutions have been removed.
Disallowed env names
--------------------
- Environment names that contain multiple Python variants, such as ``name-py39-pypy`` or ``py39-py310`` will now raise
an error, previously this only warned, you can use :ref:`ignore_basepython_conflict` to disable this error, but we
recommend changing the name to avoid this name that can be confusing.
CLI arguments changed
---------------------
- The ``--parallel--safe-build`` CLI argument has been removed, no longer needed.
- When you want to pass an option to a test command, e.g. to ``pytest``, now you must use ``--`` as a separator, this
worked with version 3 also, but any unknown trailing arguments were automatically passed through, while now this is
no longer the case.
- Running ``--showconfig`` or ``--help-ini`` with the ``-v`` flag will add interleaved debugging information, whereas
tox 3 added additional lines at the start. If you want to generate valid ini files you must not use the ``-v`` flag.
- The ``--index-url`` is now removed, use ``PIP_INDEX_URL`` in :ref:`set_env` instead.
Output changes
--------------
- We now use colors for reporting, to help make the output easier to read for humans. This can be disabled via the
``TERM=dumb`` or ``NO_COLOR=1`` environment variables, or the ``--colored no`` CLI argument.
Reuse of environments
----------------------
- It is no longer possible to reuse environments. While this might have been possible with tox version 3, this
behavior was never supported, and possibly caused wrong results as illustrated in the following example.
.. code-block:: ini
[testenv]
envdir = .tox/venv
[testenv:a]
deps = pytest>7
[testenv:b]
deps = pytest<7
CLI command compatibility
-------------------------
``tox`` 4 introduced dedicated subcommands for various usages.
However, when no subcommand is given the legacy entry point which imitates ``tox`` 3 is used.
This compatibility feature makes most ``tox`` 3 commands work in ``tox`` 4, but there are some exceptions.
Updating usage with ``-e``
++++++++++++++++++++++++++
In ``tox`` 3, environments could be specified to run with the ``-e`` flag.
In ``tox`` 4, environments should always be specified using the ``-e`` flag to the ``run`` subcommand.
Rewrite usages as follows
.. code:: bash
# tox 3
tox -e py310,style
# tox 4
tox run -e py310,style
# or, tox 4 with the short alias
tox r -e py310,style
Environment names matching commands
+++++++++++++++++++++++++++++++++++
Now that ``tox`` has subcommands, it is possible for arguments to ``tox`` or its options to match those subcommand
names.
When that happens, parsing can become ambiguous between the ``tox`` 4 usage and the legacy fallback behavior.
For example, consider the following tox config:
.. code-block:: ini
[tox]
env_list = py39,py310
[testenv]
commands =
python -c 'print("hi")'
[testenv:list]
commands =
python -c 'print("a, b, c")'
This defines an environment whose name matches a ``tox`` 4 command, ``list``.
Under ``tox`` 3, ``tox -e list`` specified the ``list`` environment.
However, under ``tox`` 4, the parse of this usage as an invocation of ``tox list`` takes precedence over the legacy
behavior.
Therefore, attempting that same usage results in an error:
.. code:: bash
$ tox -e list
...
tox: error: unrecognized arguments: -e
This is best avoided by updating to non-legacy usage:
.. code:: bash
$ tox run -e list
# or, equivalently...
$ tox r -e list
Packaging environments
----------------------
Isolated environment on by default
++++++++++++++++++++++++++++++++++
``tox`` now always uses an isolated build environment when building your projects package. The previous flag to enable
this called ``isolated_build`` has been removed.
Packaging configuration and inheritance
+++++++++++++++++++++++++++++++++++++++
Isolated build environments are tox environments themselves and may be configured on their own. Their name is defined
as follows:
- For source distributions this environment will match a virtual environment with the same python interpreter as tox is
using. The name of this environment will by default ``.pkg`` (can be changed via :ref:`package_env` config on a per
test environment basis).
- For wheels (including editable wheels as defined by :pep:`660`) their name will be ``.pkg-``, so
for example if you're building a wheel for a Python 3.10 environment the packaging environment will be
``.pkg-cpython311`` (can be changed via :ref:`wheel_build_env` config on a per test environment basis).
To change a packaging environments settings you can use:
.. code-block:: ini
[testenv:.pkg]
pass_env =
PKG_CONFIG
PKG_CONFIG_PATH
PKG_CONFIG_SYSROOT_DIR
[testenv:.pkg-cpython311]
pass_env =
PKG_CONFIG
PKG_CONFIG_PATH
PKG_CONFIG_SYSROOT_DIR
Packaging environments no longer inherit their settings from the ``testenv`` section, as this caused issues when
some test environment settings conflicted with packaging setting. However starting with ``tox>=4.2`` all packaging
environments inherit from the ``pkgenv`` section, allowing you to define packaging common packaging settings in one
central place, while still allowing you to override it when needed on a per package environment basis:
.. code-block:: ini
[pkgenv]
pass_env =
PKG_CONFIG
PKG_CONFIG_PATH
PKG_CONFIG_SYSROOT_DIR
[testenv:.pkg-cpython311]
pass_env =
{[pkgenv]pass_env}
IS_311 = yes
[testenv:magic]
package = sdist
pass_env = {[pkgenv]pass_env} # sdist install builds wheel -> need packaging settings
Note that specific packaging environments are defined under ``testenv:.pkg`` and **not** ``pkgenv:.pkg``, this is due
backwards compatibility.
Universal wheels
++++++++++++++++
If your project builds universal wheels you can avoid using multiple build environments for each targeted python by
setting :ref:`wheel_build_env` to the same packaging environment via:
.. code-block:: ini
[testenv]
package = wheel
wheel_build_env = .pkg
Editable mode
+++++++++++++
``tox`` now defaults to using editable wheels when develop mode is enabled and the build backend supports it,
as defined by :pep:`660` by setting :ref:`package` to ``editable``. In case the backend does not support it, will
fallback to :ref:`package` to ``editable-legacy``, and invoke pip with ``-e``. In the later case will also print a
message to make this setting explicit in your configuration (explicit better than implicit):
.. code-block:: ini
[testenv:dev]
package = editable-legacy
If you want to use the new standardized method to achieve the editable install effect you should ensure your backend
version is above the version this feature was added to it, for example for setuptools:
.. code-block:: ini
[testenv:dev]
deps = setuptools>=64
package = editable
Provisioning environment
------------------------
The provisioning environment is triggered when ``minversion`` or ``requires`` are specified and the current environment
does not satisfy the requirement. In tox 4, the provisioning environment (``.tox`` by default) must be explicitly
configured and will not inherit values from ``[testenv]`` section.
tox-4.13.0/docs/user_guide.rst 0000664 0000000 0000000 00000061346 14564001166 0016243 0 ustar 00root root 0000000 0000000 User Guide
==========
Overview
--------
tox is an environment orchestrator. Use it to define how to setup and execute various tools on your projects. The
tool can set up environments for and invoke:
- test runners (such as :pypi:`pytest`),
- linters (e.g., :pypi:`flake8`),
- formatters (for example :pypi:`black` or :pypi:`isort`),
- documentation generators (e.g., :pypi:`Sphinx`),
- build and publishing tools (e.g., :pypi:`build` with :pypi:`twine`),
- ...
Configuration
-------------
*tox* needs a configuration file where you define what tools you need to run and how to provision a test environment for
these. The canonical file for this is the ``tox.ini`` file. For example:
.. code-block:: ini
[tox]
requires =
tox>=4
env_list = lint, type, py{38,39,310,311}
[testenv]
description = run unit tests
deps =
pytest>=7
pytest-sugar
commands =
pytest {posargs:tests}
[testenv:lint]
description = run linters
skip_install = true
deps =
black==22.12
commands = black {posargs:.}
[testenv:type]
description = run type checks
deps =
mypy>=0.991
commands =
mypy {posargs:src tests}
.. tip::
You can also generate a ``tox.ini`` file automatically by running ``tox quickstart`` and then answering a few
questions.
The configuration is split into two type of configuration: core settings are hosted under a core ``tox`` section while
per run environment settings hosted under ``testenv`` and ``testenv:`` sections.
Core settings
~~~~~~~~~~~~~
Core settings that affect all test environments or configure how tox itself is invoked are defined under the ``tox``
section.
.. code-block:: ini
[tox]
requires =
tox>=4
env_list = lint, type, py{38,39,310,311}
We can use it to specify things such as the minimum version of *tox* required or the location of the package under test.
A list of all supported configuration options for the ``tox`` section can be found in the :ref:`configuration guide
`.
Test environments
~~~~~~~~~~~~~~~~~
Test environments are defined under the ``testenv`` section and individual ``testenv:`` sections, where
```` is the name of a specific environment.
.. code-block:: ini
[testenv]
description = run unit tests
deps =
pytest>=7
pytest-sugar
commands =
pytest {posargs:tests}
[testenv:lint]
description = run linters
skip_install = true
deps =
black==22.12
commands = black {posargs:.}
[testenv:type]
description = run type checks
deps =
mypy>=0.991
commands =
mypy {posargs:src tests}
Settings defined in the top-level ``testenv`` section are automatically inherited by individual environments unless
overridden. Test environment names can consist of alphanumeric characters and dashes; for example: ``py311-django42``.
The name will be split on dashes into multiple factors, meaning ``py311-django42`` will be split into two factors:
``py311`` and ``django42``. *tox* defines a number of default factors, which correspond to various versions and
implementations of Python and provide default values for ``base_python``:
- ``pyNM``: configures ``basepython = pythonN.M``
- ``pypyNM``: configures ``basepython = pypyN.M``
- ``jythonNM``: configures ``basepython = jythonN.M``
- ``cpythonNM``: configures ``basepython = cpythonN.M``
- ``ironpythonNM``: configures ``basepython = ironpythonN.M``
- ``rustpythonNM``: configures ``basepython = rustpythonN.M``
You can also specify these factors with a period between the major and minor versions (e.g. ``pyN.M``), without a minor
version (e.g. ``pyN``), or without any version information whatsoever (e.g. ``py``)
A list of all supported configuration options for the ``testenv`` and ``testenv:`` sections can be found in
the :ref:`configuration guide `.
Basic example
-------------
.. code-block:: ini
[tox]
env_list =
format
py310
[testenv:format]
description = install black in a virtual environment and invoke it on the current folder
deps = black==22.3.0
skip_install = true
commands = black .
[testenv:py310]
description = install pytest in a virtual environment and invoke it on the tests folder
deps =
pytest>=7
pytest-sugar
commands = pytest tests {posargs}
This example contains a global ``tox`` section as well as two test environments. Taking the core section first, we use
the :ref:`env_list` setting to indicate that this project has two run environments named ``format`` and ``py310`` that
should be run by default when ``tox run`` is invoked without a specific environment.
The formatting environment and test environment are defined separately via the ``testenv:format`` and ``testenv:py310``
sections, respectively. For example to format the project we:
- add a description (visible when you type ``tox list`` into the command line) via the :ref:`description` setting
- define that it requires the :pypi:`black` dependency with version ``22.3.0`` via the :ref:`deps` setting
- disable installation of the project under test into the test environment via the :ref:`skip_install` setting -
``black`` does not need it installed
- indicate the commands to be run via the :ref:`commands` setting
For testing the project we use the ``py310`` environment. For this environment we:
- define a text description of the environment via the :ref:`description` setting
- specify that we should install :pypi:`pytest` v7.0 or later together with the :pypi:`pytest-sugar` project via the
:ref:`deps` setting
- indicate the command(s) to be run - in this case ``pytest tests`` - via the :ref:`commands` setting
``{posargs}`` is a place holder part for the CLI command that allows us to pass additional flags to the pytest
invocation, for example if we'd want to run ``pytest tests -v`` as a one off, instead of ``tox run -e py310`` we'd type
``tox run -e py310 -- -v``. The ``--`` delimits flags for the tox tool and what should be forwarded to the tool within.
tox, by default, always creates a fresh virtual environment for every run environment. The Python version to use for a
given environment can be controlled via the :ref:`base_python` configuration, however if not set will try to use the
environment name to determine something sensible: if the name is in the format of ``pyxy`` then tox will create an environment with CPython
with version ``x.y`` (for example ``py310`` means CPython ``3.10``). If the name does not match this pattern it will
use a virtual environment with the same Python version as the one tox is installed into (this is the case for
``format``).
tox environments are reused between runs, so while the first ``tox run -e py310`` will take a while as tox needs to
create a virtual environment and install ``pytest`` and ``pytest-sugar`` in it, subsequent runs only need to reinstall
your project, as long as the environments dependency list does not change.
Almost every step and aspect of virtual environments and command execution can be customized. You'll find
an exhaustive list of configuration flags (together with what it does and detailed explanation of what values are
accepted) at our :ref:`configuration page `.
System overview
---------------
Below is a graphical representation of the tox states and transition pathways between them:
.. image:: img/overview_light.svg
:align: center
:class: only-light
.. image:: img/overview_dark.svg
:align: center
:class: only-dark
The primary tox states are:
#. **Configuration:** load tox configuration files (such as ``tox.ini``, ``pyproject.toml`` and ``toxfile.py``) and
merge it with options from the command line plus the operating system environment variables.
#. **Environment**: for each selected tox environment (e.g. ``py310``, ``format``) do:
#. **Creation**: create a fresh environment; by default :pypi:`virtualenv` is used, but configurable via
:ref:`runner`. For `virtualenv` tox will use the `virtualenv discovery logic
`_ where the python specification is
defined by the tox environments :ref:`base_python` (if not set will default to the environments name). This is
created at first run only to be re-used at subsequent runs. If certain aspects of the project change (python
version, dependencies removed, etc.), a re-creation of the environment is automatically triggered. To force the
recreation tox can be invoked with the :ref:`recreate` flag (``-r``).
#. **Install dependencies** (optional): install the environment dependencies specified inside the ``deps``
configuration section, and then the earlier packaged source distribution. By default ``pip`` is used to install
packages, however one can customize this via ``install_command``. Note ``pip`` will not update project
dependencies (specified either in the ``install_requires`` or the ``extras`` section of the ``setup.py``) if any
version already exists in the virtual environment; therefore we recommend to recreate your environments whenever
your project dependencies change.
#. **Packaging** (optional): create a distribution of the current project.
#. **Build**: If the tox environment has a package configured tox will build a package from the current source
tree. If multiple tox environments are run and the package built are compatible in between them then it will be
reused. This is to ensure that we build the package as rare as needed. By default for Python a source
distribution is built as defined via the ``pyproject.toml`` style build (see PEP-517 and PEP-518).
#. **Install the package dependencies**. If this has not changed since the last run this step will be skipped.
#. **Install the package**. This operation will force reinstall the package without its dependencies.
#. **Commands**: run the specified commands in the specified order. Whenever the exit code of any of them is not
zero, stop and mark the environment failed. When you start a command with a dash character, the exit code will be
ignored.
#. **Report** print out a report of outcomes for each tox environment:
.. code:: bash
____________________ summary ____________________
py37: commands succeeded
ERROR: py38: commands failed
Only if all environments ran successfully tox will return exit code ``0`` (success). In this case you'll also see the
message ``congratulations :)``.
tox will take care of environment variable isolation for you. That means it will remove system environment variables not specified via
``passenv``. Furthermore, it will also alter the ``PATH`` variable so that your commands resolve within the current
active tox environment. In general, all executables outside of the tox environment are available in ``commands``, but
external commands need to be explicitly allowed via the :ref:`allowlist_externals` configuration.
Main features
-------------
* **automation of tedious Python related test activities**
* **test your Python package against many interpreter and dependency configurations**
- automatic customizable (re)creation of :pypi:`virtualenv` test environments
- installs your project into each virtual environment
- test-tool agnostic: runs pytest, nose or unittest in a uniform manner
* ``plugin system`` to modify tox execution with simple hooks.
* uses :pypi:`pip` and :pypi:`virtualenv` by default. Support for plugins replacing it with their own.
* **cross-Python compatible**: tox requires CPython 3.7 and higher, but it can create environments 2.7 or later
* **cross-platform**: Windows, macOS and Unix style environments
* **full interoperability with devpi**: is integrated with and is used for testing in the :pypi:`devpi` system, a
versatile PyPI index server and release managing tool
* **driven by a simple (but flexible to allow expressing more complicated variants) ini-style config file**
* **documented** examples and configuration
* **concise reporting** about tool invocations and configuration errors
* supports using different / multiple PyPI index servers
Related projects
----------------
tox has influenced several other projects in the Python test automation space. If tox doesn't quite fit your needs or
you want to do more research, we recommend taking a look at these projects:
- `nox {re.escape(env or '.*')}(:(?P[^]]+))?|(?P[-\w]+))])? # env/section
(?P[-a-zA-Z0-9_]+) # key
(:(?P.*))? # default value
$
""",
re.VERBOSE,
)
def replace_reference( # noqa: PLR0912, C901
conf: Config,
loader: IniLoader,
value: str,
conf_args: ConfigLoadArgs,
) -> str | None:
# a return value of None indicates could not replace
pattern = _replace_ref(loader.section.prefix or loader.section.name)
match = pattern.match(value)
if match:
settings = match.groupdict()
key = settings["key"]
if settings["section"] is None and settings["full_env"]:
settings["section"] = settings["full_env"]
exception: Exception | None = None
try:
for src in _config_value_sources(settings["env"], settings["section"], conf_args.env_name, conf, loader):
try:
if isinstance(src, SectionProxy):
return loader.process_raw(conf, conf_args.env_name, src[key])
value = src.load(key, conf_args.chain)
except KeyError as exc: # if fails, keep trying maybe another source can satisfy # noqa: PERF203
exception = exc
else:
as_str, _ = stringify(value)
return as_str.replace("#", r"\#") # escape comment characters as these will be stripped
except Exception as exc: # noqa: BLE001
exception = exc
if exception is not None:
if isinstance(exception, KeyError): # if the lookup failed replace - else keep
default = settings["default"]
if default is not None:
return default
# we cannot raise here as that would mean users could not write factorials: depends = {py39,py38}-{,b}
else:
raise exception
return None
def _config_value_sources(
env: str | None,
section: str | None,
current_env: str | None,
conf: Config,
loader: IniLoader,
) -> Iterator[SectionProxy | ConfigSet]:
# if we have an env name specified take only from there
if env is not None and env in conf:
yield conf.get_env(env)
if section is None:
# if no section specified perhaps it's an unregistered config:
# 1. try first from core conf
yield conf.core
# 2. and then fallback to our own environment
if current_env is not None:
yield conf.get_env(current_env)
return
# if there's a section, special handle the core section
if section == loader.core_section.name:
yield conf.core # try via registered configs
value = loader.get_section(section) # fallback to section
if value is not None:
yield value
def replace_pos_args(conf: Config, args: list[str], conf_args: ConfigLoadArgs) -> str:
to_path: Path | None = None
if conf_args.env_name is not None: # pragma: no branch
env_conf = conf.get_env(conf_args.env_name)
try:
if env_conf["args_are_paths"]: # pragma: no branch
to_path = env_conf["change_dir"]
except KeyError:
pass
pos_args = conf.pos_args(to_path)
# if we use the defaults join back remaining args else take shell cmd
return ARG_DELIMITER.join(args) if pos_args is None else shell_cmd(pos_args)
def replace_env(conf: Config, args: list[str], conf_args: ConfigLoadArgs) -> str:
if not args or not args[0]:
msg = "No variable name was supplied in {env} substitution"
raise MatchError(msg)
key = args[0]
new_key = f"env:{key}"
if conf_args.env_name is not None: # on core no set env support # pragma: no branch
if new_key not in conf_args.chain: # check if set env
conf_args.chain.append(new_key)
env_conf = conf.get_env(conf_args.env_name)
set_env: SetEnv = env_conf["set_env"]
if key in set_env:
return set_env.load(key, conf_args)
elif conf_args.chain[-1] != new_key: # if there's a chain but only self-refers than use os.environ
circular = ", ".join(i[4:] for i in conf_args.chain[conf_args.chain.index(new_key) :])
msg = f"circular chain between set env {circular}"
raise MatchRecursionError(msg)
if key in os.environ:
return os.environ[key]
return "" if len(args) == 1 else ARG_DELIMITER.join(args[1:])
def replace_tty(args: list[str]) -> str:
return (args[0] if len(args) > 0 else "") if sys.stdout.isatty() else args[1] if len(args) > 1 else ""
__all__ = (
"MatchArg",
"MatchError",
"MatchExpression",
"find_replace_expr",
"replace",
)
tox-4.13.0/src/tox/config/loader/memory.py 0000664 0000000 0000000 00000003540 14564001166 0020414 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from pathlib import Path
from typing import TYPE_CHECKING, Any, Iterator
from tox.config.types import Command, EnvList
from .api import Loader
from .section import Section
from .str_convert import StrConvert
if TYPE_CHECKING:
from tox.config.main import Config
class MemoryLoader(Loader[Any]):
def __init__(self, **kwargs: Any) -> None:
super().__init__(Section(prefix="", name=str(id(self))), [])
self.raw: dict[str, Any] = {**kwargs}
def load_raw(self, key: Any, conf: Config | None, env_name: str | None) -> Any: # noqa: ARG002
return self.raw[key]
def found_keys(self) -> set[str]:
return set(self.raw.keys())
@staticmethod
def to_bool(value: Any) -> bool:
return bool(value)
@staticmethod
def to_str(value: Any) -> str:
return str(value)
@staticmethod
def to_list(value: Any, of_type: type[Any]) -> Iterator[Any]: # noqa: ARG004
return iter(value)
@staticmethod
def to_set(value: Any, of_type: type[Any]) -> Iterator[Any]: # noqa: ARG004
return iter(value)
@staticmethod
def to_dict(value: Any, of_type: tuple[type[Any], type[Any]]) -> Iterator[tuple[Any, Any]]: # noqa: ARG004
return value.items() # type: ignore[no-any-return]
@staticmethod
def to_path(value: Any) -> Path:
return Path(value)
@staticmethod
def to_command(value: Any) -> Command:
if isinstance(value, Command):
return value
if isinstance(value, str):
return StrConvert.to_command(value)
raise TypeError(value)
@staticmethod
def to_env_list(value: Any) -> EnvList:
if isinstance(value, EnvList):
return value
if isinstance(value, str):
return StrConvert.to_env_list(value)
raise TypeError(value)
tox-4.13.0/src/tox/config/loader/section.py 0000664 0000000 0000000 00000003370 14564001166 0020551 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
import sys
if sys.version_info >= (3, 11): # pragma: no cover (py311+)
from typing import Self
else: # pragma: no cover ( None:
self._prefix = prefix
self._name = name
@classmethod
def from_key(cls: type[Self], key: str) -> Self:
"""
Create a section from a section key.
:param key: the section key
:return: the constructed section
"""
sep_at = key.find(cls.SEP)
if sep_at == -1:
prefix, name = None, key
else:
prefix, name = key[:sep_at], key[sep_at + 1 :]
return cls(prefix, name)
@property
def prefix(self) -> str | None:
""":return: the prefix of the section"""
return self._prefix
@property
def name(self) -> str:
""":return: the name of the section"""
return self._name
@property
def key(self) -> str:
""":return: the section key"""
return self.SEP.join(i for i in (self._prefix, self._name) if i is not None)
def __str__(self) -> str:
return self.key
def __repr__(self) -> str:
return f"{self.__class__.__name__}(prefix={self._prefix!r}, name={self._name!r})"
def __eq__(self, other: object) -> bool:
return isinstance(other, self.__class__) and (self._prefix, self._name) == (
other._prefix,
other.name,
)
__all__ = [
"Section",
]
tox-4.13.0/src/tox/config/loader/str_convert.py 0000664 0000000 0000000 00000011526 14564001166 0021457 0 ustar 00root root 0000000 0000000 """Convert string configuration values to tox python configuration objects."""
from __future__ import annotations
import shlex
import sys
from itertools import chain
from pathlib import Path
from typing import TYPE_CHECKING, Any, Iterator
from tox.config.loader.convert import Convert
from tox.config.types import Command, EnvList
if TYPE_CHECKING:
from typing import Final
class StrConvert(Convert[str]):
"""A class converting string values to tox types."""
@staticmethod
def to_str(value: str) -> str:
return str(value).strip()
@staticmethod
def to_path(value: str) -> Path:
return Path(value)
@staticmethod
def to_list(value: str, of_type: type[Any]) -> Iterator[str]:
splitter = "\n" if issubclass(of_type, Command) or "\n" in value else ","
splitter = splitter.replace("\r", "")
for token in value.split(splitter):
value = token.strip()
if value:
yield value
@staticmethod
def to_set(value: str, of_type: type[Any]) -> Iterator[str]:
yield from StrConvert.to_list(value, of_type)
@staticmethod
def to_dict(value: str, of_type: tuple[type[Any], type[Any]]) -> Iterator[tuple[str, str]]: # noqa: ARG004
for row in value.split("\n"):
if row.strip():
key, sep, value = row.partition("=")
if sep:
yield key.strip(), value.strip()
else:
msg = f"dictionary lines must be of form key=value, found {row!r}"
raise TypeError(msg)
@staticmethod
def _win32_process_path_backslash(value: str, escape: str, special_chars: str) -> str:
"""
Escape backslash in value that is not followed by a special character.
This allows windows paths to be written without double backslash, while
retaining the POSIX backslash escape semantics for quotes and escapes.
"""
result = []
for ix, char in enumerate(value):
result.append(char)
if char == escape:
last_char = value[ix - 1 : ix]
if last_char == escape:
continue
next_char = value[ix + 1 : ix + 2]
if next_char not in {escape, *special_chars}:
result.append(escape) # escape escapes that are not themselves escaping a special character
return "".join(result)
@staticmethod
def to_command(value: str) -> Command:
"""
At this point, ``value`` has already been substituted out, and all punctuation / escapes are final.
Value will typically be stripped of whitespace when coming from an ini file.
"""
value = value.replace(r"\#", "#")
is_win = sys.platform == "win32"
if is_win: # pragma: win32 cover
s = shlex.shlex(posix=True)
value = StrConvert._win32_process_path_backslash(
value,
escape=s.escape,
special_chars=s.quotes + s.whitespace,
)
splitter = shlex.shlex(value, posix=True)
splitter.whitespace_split = True
splitter.commenters = "" # comments handled earlier, and the shlex does not know escaped comment characters
args: list[str] = []
pos = 0
try:
for arg in splitter:
if is_win and len(arg) > 1 and arg[0] == arg[-1] and arg.startswith(("'", '"')): # pragma: win32 cover
# on Windows quoted arguments will remain quoted, strip it
arg = arg[1:-1] # noqa: PLW2901
args.append(arg)
pos = splitter.instream.tell()
except ValueError:
args.append(value[pos:])
if len(args) == 0:
msg = f"attempting to parse {value!r} into a command failed"
raise ValueError(msg)
if args[0] != "-" and args[0].startswith("-"):
args[0] = args[0][1:]
args = ["-", *args]
return Command(args)
@staticmethod
def to_env_list(value: str) -> EnvList:
from tox.config.loader.ini.factor import extend_factors # noqa: PLC0415
elements = list(chain.from_iterable(extend_factors(expr) for expr in value.split("\n")))
return EnvList(elements)
TRUTHFUL_VALUES: Final[set[str]] = {"true", "1", "yes", "on"}
FALSE_VALUES: Final[set[str]] = {"false", "0", "no", "off", ""}
VALID_BOOL = sorted(TRUTHFUL_VALUES | FALSE_VALUES)
@staticmethod
def to_bool(value: str) -> bool:
norm = str(value).strip().lower()
if norm in StrConvert.TRUTHFUL_VALUES:
return True
if norm in StrConvert.FALSE_VALUES:
return False
msg = f"value {value!r} cannot be transformed to bool, valid: {', '.join(StrConvert.VALID_BOOL)}"
raise TypeError(msg)
__all__ = ("StrConvert",)
tox-4.13.0/src/tox/config/loader/stringify.py 0000664 0000000 0000000 00000002457 14564001166 0021130 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from pathlib import Path
from typing import Any, Mapping, Sequence, Set
from tox.config.set_env import SetEnv
from tox.config.types import Command, EnvList
from tox.tox_env.python.pip.req_file import PythonDeps
def stringify(value: Any) -> tuple[str, bool]: # noqa: PLR0911
"""
Transform a value into a string representation.
:param value: the value in question
:return: a tuple, first the value as str, second a flag if the value if a multi-line one
"""
if isinstance(value, str):
return value, False
if isinstance(value, (Path, float, int, bool)):
return str(value), False
if isinstance(value, Mapping):
return "\n".join(f"{stringify(k)[0]}={stringify(v)[0]}" for k, v in value.items()), True
if isinstance(value, (Sequence, Set)):
return "\n".join(stringify(i)[0] for i in value), True
if isinstance(value, EnvList):
return "\n".join(e for e in value.envs), True
if isinstance(value, Command):
return value.shell, True
if isinstance(value, SetEnv):
env_var_keys = sorted(value)
return stringify({k: value.load(k) for k in env_var_keys})
if isinstance(value, PythonDeps):
return stringify(value.lines())
return str(value), False
__all__ = ("stringify",)
tox-4.13.0/src/tox/config/main.py 0000664 0000000 0000000 00000014652 14564001166 0016570 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
from collections import OrderedDict, defaultdict
from pathlib import Path
from typing import TYPE_CHECKING, Any, Iterator, Sequence, TypeVar
from .sets import ConfigSet, CoreConfigSet, EnvConfigSet
if TYPE_CHECKING:
from tox.config.loader.api import Loader, OverrideMap
from .cli.parser import Parsed
from .loader.memory import MemoryLoader
from .loader.section import Section
from .source import Source
T = TypeVar("T", bound=ConfigSet)
class Config:
"""Main configuration object for tox."""
def __init__( # noqa: PLR0913
self,
config_source: Source,
options: Parsed,
root: Path,
pos_args: Sequence[str] | None,
work_dir: Path,
) -> None:
self._pos_args = None if pos_args is None else tuple(pos_args)
self._work_dir = work_dir
self._root = root
self._options = options
self._overrides: OverrideMap = defaultdict(list)
for override in options.override:
self._overrides[override.namespace].append(override)
self._src = config_source
self._key_to_conf_set: dict[tuple[str, str], ConfigSet] = OrderedDict()
self._core_set: CoreConfigSet | None = None
self.memory_seed_loaders: defaultdict[str, list[MemoryLoader]] = defaultdict(list)
def pos_args(self, to_path: Path | None) -> tuple[str, ...] | None:
"""
:param to_path: if not None rewrite relative posargs paths from cwd to to_path
:return: positional argument
"""
if self._pos_args is not None and to_path is not None and Path.cwd() != to_path:
args = []
# we use os.path to unroll .. in path without resolve
to_path_str = os.path.abspath(str(to_path)) # noqa: PTH100
for arg in self._pos_args:
path_arg = Path(arg)
if path_arg.exists() and not path_arg.is_absolute():
# we use os.path to unroll .. in path without resolve
path_arg_str = os.path.abspath(str(path_arg)) # noqa: PTH100
# we use os.path to not fail when not within
relative = os.path.relpath(path_arg_str, to_path_str)
args.append(relative)
else:
args.append(arg)
return tuple(args)
return self._pos_args
@property
def work_dir(self) -> Path:
""":return: working directory for this project"""
return self._work_dir
@property
def src_path(self) -> Path:
""":return: the location of the tox configuration source"""
return self._src.path
def __iter__(self) -> Iterator[str]:
""":return: an iterator that goes through existing environments"""
return self._src.envs(self.core)
def sections(self) -> Iterator[Section]:
yield from self._src.sections()
def __repr__(self) -> str:
return f"{type(self).__name__}(config_source={self._src!r})"
def __contains__(self, item: str) -> bool:
""":return: check if an environment already exists"""
return any(name for name in self if name == item)
@classmethod
def make(cls, parsed: Parsed, pos_args: Sequence[str] | None, source: Source) -> Config:
"""Make a tox configuration object."""
# root is the project root, where the configuration file is at
# work dir is where we put our own files
root: Path = source.path.parent if parsed.root_dir is None else parsed.root_dir
work_dir: Path = source.path.parent if parsed.work_dir is None else parsed.work_dir
# if these are relative we need to expand them them to ensure paths built on this can resolve independent on cwd
root = root.resolve()
work_dir = work_dir.resolve()
return cls(
config_source=source,
options=parsed,
pos_args=pos_args,
root=root,
work_dir=work_dir,
)
@property
def options(self) -> Parsed:
return self._options
@property
def core(self) -> CoreConfigSet:
""":return: the core configuration"""
if self._core_set is not None:
return self._core_set
core_section = self._src.get_core_section()
core = CoreConfigSet(self, core_section, self._root, self.src_path)
core.loaders.extend(self._src.get_loaders(core_section, base=[], override_map=self._overrides, conf=core))
self._core_set = core
return core
def get_section_config( # noqa: PLR0913
self,
section: Section,
base: list[str] | None,
of_type: type[T],
for_env: str | None,
loaders: Sequence[Loader[Any]] | None = None,
) -> T:
key = section.key, for_env or ""
try:
return self._key_to_conf_set[key] # type: ignore[return-value] # expected T but found ConfigSet
except KeyError:
conf_set = of_type(self, section, for_env)
self._key_to_conf_set[key] = conf_set
if for_env is not None:
conf_set.loaders.extend(self.memory_seed_loaders.get(for_env, []))
for loader in self._src.get_loaders(section, base, self._overrides, conf_set):
conf_set.loaders.append(loader)
if loaders is not None:
conf_set.loaders.extend(loaders)
return conf_set
def get_env(
self,
item: str,
package: bool = False, # noqa: FBT001, FBT002
loaders: Sequence[Loader[Any]] | None = None,
) -> EnvConfigSet:
"""
Return the configuration for a given tox environment (will create if not exist yet).
:param item: the name of the environment
:param package: a flag indicating if the environment is of type packaging or not (only used for creation)
:param loaders: loaders to use for this configuration (only used for creation)
:return: the tox environments config
"""
section, base_test, base_pkg = self._src.get_tox_env_section(item)
return self.get_section_config(
section,
base=base_pkg if package else base_test,
of_type=EnvConfigSet,
for_env=item,
loaders=loaders,
)
def clear_env(self, name: str) -> None:
section, _, __ = self._src.get_tox_env_section(name)
del self._key_to_conf_set[(section.key, name)]
___all__ = [
"Config",
]
tox-4.13.0/src/tox/config/of_type.py 0000664 0000000 0000000 00000010335 14564001166 0017303 0 ustar 00root root 0000000 0000000 """Group together configuration values (such as base tox configuration, tox environment configs)."""
from __future__ import annotations
from abc import ABC, abstractmethod
from itertools import product
from typing import TYPE_CHECKING, Callable, Generic, Iterable, TypeVar, cast
from tox.config.loader.api import ConfigLoadArgs, Loader
if TYPE_CHECKING:
from tox.config.loader.convert import Factory
from tox.config.main import Config # pragma: no cover
T = TypeVar("T")
V = TypeVar("V")
class ConfigDefinition(ABC, Generic[T]): # noqa: PLW1641
"""Abstract base class for configuration definitions."""
def __init__(self, keys: Iterable[str], desc: str) -> None:
self.keys = keys
self.desc = desc
@abstractmethod
def __call__(self, conf: Config, loaders: list[Loader[T]], args: ConfigLoadArgs) -> T:
raise NotImplementedError
def __eq__(self, o: object) -> bool:
return type(self) == type(o) and (self.keys, self.desc) == (o.keys, o.desc) # type: ignore[attr-defined]
def __ne__(self, o: object) -> bool:
return not (self == o)
class ConfigConstantDefinition(ConfigDefinition[T]): # noqa: PLW1641
"""A configuration definition whose value is defined upfront (such as the tox environment name)."""
def __init__(
self,
keys: Iterable[str],
desc: str,
value: Callable[[], T] | T,
) -> None:
super().__init__(keys, desc)
self.value = value
def __call__(
self,
conf: Config, # noqa: ARG002
loaders: list[Loader[T]], # noqa: ARG002
args: ConfigLoadArgs, # noqa: ARG002
) -> T:
return self.value() if callable(self.value) else self.value
def __eq__(self, o: object) -> bool:
return type(self) == type(o) and super().__eq__(o) and self.value == o.value # type: ignore[attr-defined]
_PLACE_HOLDER = object()
class ConfigDynamicDefinition(ConfigDefinition[T]): # noqa: PLW1641
"""A configuration definition that comes from a source (such as in memory, an ini file, a toml file, etc.)."""
def __init__( # noqa: PLR0913
self,
keys: Iterable[str],
desc: str,
of_type: type[T],
default: Callable[[Config, str | None], T] | T,
post_process: Callable[[T], T] | None = None,
factory: Factory[T] | None = None,
) -> None:
super().__init__(keys, desc)
self.of_type = of_type
self.default = default
self.post_process = post_process
self.factory = factory
self._cache: object | T = _PLACE_HOLDER
def __call__(
self,
conf: Config,
loaders: list[Loader[T]],
args: ConfigLoadArgs,
) -> T:
if self._cache is _PLACE_HOLDER:
for key, loader in product(self.keys, loaders):
chain_key = f"{loader.section.key}.{key}"
if chain_key in args.chain:
msg = f"circular chain detected {', '.join(args.chain[args.chain.index(chain_key):])}"
raise ValueError(msg)
args.chain.append(chain_key)
try:
value = loader.load(key, self.of_type, self.factory, conf, args)
except KeyError:
continue
else:
break
finally:
del args.chain[-1]
else:
value = self.default(conf, args.env_name) if callable(self.default) else self.default
if self.post_process is not None:
value = self.post_process(value)
self._cache = value
return cast(T, self._cache)
def __repr__(self) -> str:
values = ((k, v) for k, v in vars(self).items() if k != "post_process" and v is not None)
return f"{type(self).__name__}({', '.join(f'{k}={v}' for k, v in values)})"
def __eq__(self, o: object) -> bool:
return (
type(self) == type(o)
and super().__eq__(o)
and (self.of_type, self.default, self.post_process) == (o.of_type, o.default, o.post_process) # type: ignore[attr-defined]
)
__all__ = [
"ConfigConstantDefinition",
"ConfigDefinition",
"ConfigDynamicDefinition",
"ConfigLoadArgs",
]
tox-4.13.0/src/tox/config/set_env.py 0000664 0000000 0000000 00000011621 14564001166 0017300 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from pathlib import Path
from typing import Callable, Iterator, Mapping
from tox.config.loader.api import ConfigLoadArgs
from tox.tox_env.errors import Fail
Replacer = Callable[[str, ConfigLoadArgs], str]
class SetEnv:
def __init__(self, raw: str, name: str, env_name: str | None, root: Path) -> None:
self.changed = False
self._materialized: dict[str, str] = {} # env vars we already loaded
self._raw: dict[str, str] = {} # could still need replacement
self._needs_replacement: list[str] = [] # env vars that need replacement
self._env_files: list[str] = []
self._replacer: Replacer = lambda s, c: s # noqa: ARG005
self._name, self._env_name, self._root = name, env_name, root
from .loader.ini.replace import MatchExpression, find_replace_expr # noqa: PLC0415
for line in raw.splitlines(): # noqa: PLR1702
if line.strip():
if line.startswith("file|"):
self._env_files.append(line[len("file|") :])
else:
try:
key, value = self._extract_key_value(line)
if "{" in key:
msg = f"invalid line {line!r} in set_env"
raise ValueError(msg) # noqa: TRY301
except ValueError:
for expr in find_replace_expr(line):
if isinstance(expr, MatchExpression):
self._needs_replacement.append(line)
break
else:
raise
else:
self._raw[key] = value
def use_replacer(self, value: Replacer, args: ConfigLoadArgs) -> None:
self._replacer = value
for filename in self._env_files:
self._read_env_file(filename, args)
def _read_env_file(self, filename: str, args: ConfigLoadArgs) -> None:
# Our rules in the documentation, some upstream environment file rules (we follow mostly the docker one):
# - https://www.npmjs.com/package/dotenv#rules
# - https://docs.docker.com/compose/env-file/
env_file = Path(self._replacer(filename, args.copy())) # apply any replace options
env_file = env_file if env_file.is_absolute() else self._root / env_file
if not env_file.exists():
msg = f"{env_file} does not exist for set_env"
raise Fail(msg)
for env_line in env_file.read_text().splitlines():
env_line = env_line.strip() # noqa: PLW2901
if not env_line or env_line.startswith("#"):
continue
key, value = self._extract_key_value(env_line)
self._raw[key] = value
@staticmethod
def _extract_key_value(line: str) -> tuple[str, str]:
key, sep, value = line.partition("=")
if sep:
return key.strip(), value.strip()
msg = f"invalid line {line!r} in set_env"
raise ValueError(msg)
def load(self, item: str, args: ConfigLoadArgs | None = None) -> str:
if item in self._materialized:
return self._materialized[item]
raw = self._raw[item]
args = ConfigLoadArgs([], self._name, self._env_name) if args is None else args
args.chain.append(f"env:{item}")
result = self._replacer(raw, args) # apply any replace options
result = result.replace(r"\#", "#") # unroll escaped comment with replacement
self._materialized[item] = result
self._raw.pop(item, None) # if the replace requires the env we may be called again, so allow pop to fail
return result
def __contains__(self, item: object) -> bool:
return isinstance(item, str) and item in iter(self)
def __iter__(self) -> Iterator[str]:
# start with the materialized ones, maybe we don't need to materialize the raw ones
yield from self._materialized.keys()
yield from list(self._raw.keys()) # iterating over this may trigger materialization and change the dict
while self._needs_replacement:
line = self._needs_replacement.pop(0)
expanded_line = self._replacer(line, ConfigLoadArgs([], self._name, self._env_name))
sub_raw = dict(self._extract_key_value(sub_line) for sub_line in expanded_line.splitlines() if sub_line)
self._raw.update(sub_raw)
yield from sub_raw.keys()
def update(self, param: Mapping[str, str] | SetEnv, *, override: bool = True) -> None:
for key in param:
# do not override something already set explicitly
if override or (key not in self._raw and key not in self._materialized):
value = param.load(key) if isinstance(param, SetEnv) else param[key]
self._materialized[key] = value
self.changed = True
__all__ = ("SetEnv",)
tox-4.13.0/src/tox/config/sets.py 0000664 0000000 0000000 00000023430 14564001166 0016614 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from abc import ABC, abstractmethod
from pathlib import Path
from typing import TYPE_CHECKING, Any, Callable, Iterator, Mapping, Sequence, TypeVar, cast
from .of_type import ConfigConstantDefinition, ConfigDefinition, ConfigDynamicDefinition, ConfigLoadArgs
from .set_env import SetEnv
from .types import EnvList
if TYPE_CHECKING:
from tox.config.loader.api import Loader
from tox.config.main import Config
from .loader.convert import Factory
from .loader.section import Section
V = TypeVar("V")
class ConfigSet(ABC):
"""A set of configuration that belong together (such as a tox environment settings, core tox settings)."""
def __init__(self, conf: Config, section: Section, env_name: str | None) -> None:
self._section = section
self._env_name = env_name
self._conf = conf
self.loaders: list[Loader[Any]] = [] #: active configuration loaders, can alter to change configuration values
self._defined: dict[str, ConfigDefinition[Any]] = {}
self._keys: dict[str, None] = {}
self._alias: dict[str, str] = {}
self._final = False
self.register_config()
@abstractmethod
def register_config(self) -> None:
raise NotImplementedError
def mark_finalized(self) -> None:
self._final = True
def add_config( # noqa: PLR0913
self,
keys: str | Sequence[str],
of_type: type[V],
default: Callable[[Config, str | None], V] | V,
desc: str,
post_process: Callable[[V], V] | None = None,
factory: Factory[Any] | None = None,
) -> ConfigDynamicDefinition[V]:
"""
Add configuration value.
:param keys: the keys under what to register the config (first is primary key)
:param of_type: the type of the config value
:param default: the default value of the config value
:param desc: a help message describing the configuration
:param post_process: a callback to post-process the configuration value after it has been loaded
:param factory: factory method used to build contained objects (if ``of_type`` is a container type it
should perform the contained item creation, otherwise creates objects that match the type)
:return: the new dynamic config definition
"""
if self._final:
msg = "config set has been marked final and cannot be extended"
raise RuntimeError(msg)
keys_ = self._make_keys(keys)
definition = ConfigDynamicDefinition(keys_, desc, of_type, default, post_process, factory)
result = self._add_conf(keys_, definition)
return cast(ConfigDynamicDefinition[V], result)
def add_constant(self, keys: str | Sequence[str], desc: str, value: V) -> ConfigConstantDefinition[V]:
"""
Add a constant value.
:param keys: the keys under what to register the config (first is primary key)
:param desc: a help message describing the configuration
:param value: the config value to use
:return: the new constant config value
"""
if self._final:
msg = "config set has been marked final and cannot be extended"
raise RuntimeError(msg)
keys_ = self._make_keys(keys)
definition = ConfigConstantDefinition(keys_, desc, value)
result = self._add_conf(keys_, definition)
return cast(ConfigConstantDefinition[V], result)
@staticmethod
def _make_keys(keys: str | Sequence[str]) -> Sequence[str]:
return (keys,) if isinstance(keys, str) else keys
def _add_conf(self, keys: Sequence[str], definition: ConfigDefinition[V]) -> ConfigDefinition[V]:
key = keys[0]
if key in self._defined:
self._on_duplicate_conf(key, definition)
else:
self._keys[key] = None
for item in keys:
self._alias[item] = key
for key in keys:
self._defined[key] = definition
return definition
def _on_duplicate_conf(self, key: str, definition: ConfigDefinition[V]) -> None:
earlier = self._defined[key]
if definition != earlier: # pragma: no branch
msg = f"config {key} already defined"
raise ValueError(msg)
def __getitem__(self, item: str) -> Any:
"""
Get the config value for a given key (will materialize in case of dynamic config).
:param item: the config key
:return: the configuration value
"""
return self.load(item)
def load(self, item: str, chain: list[str] | None = None) -> Any:
"""
Get the config value for a given key (will materialize in case of dynamic config).
:param item: the config key
:param chain: a chain of configuration keys already loaded for this load operation (used to detect circles)
:return: the configuration value
"""
config_definition = self._defined[item]
return config_definition.__call__(self._conf, self.loaders, ConfigLoadArgs(chain, self.name, self.env_name)) # noqa: PLC2801
def __repr__(self) -> str:
return f"{self.__class__.__name__}(loaders={self.loaders!r})"
def __iter__(self) -> Iterator[str]:
""":return: iterate through the defined config keys (primary keys used)"""
return iter(self._keys.keys())
def __contains__(self, item: str) -> bool:
"""
Check if a configuration key is within the config set.
:param item: the configuration value
:return: a boolean indicating the truthiness of the statement
"""
return item in self._alias
def unused(self) -> list[str]:
""":return: Return a list of keys present in the config source but not used"""
found: set[str] = set()
# keys within loaders (only if the loader is not a parent too)
parents = {id(i.parent) for i in self.loaders if i.parent is not None}
for loader in self.loaders:
if id(loader) not in parents:
found.update(loader.found_keys())
found -= self._defined.keys()
return sorted(found)
def primary_key(self, key: str) -> str:
"""
Get the primary key for a config key.
:param key: the config key
:return: the key that's considered the primary for the input key
"""
return self._alias[key]
@property
def name(self) -> str:
return self._section.name
@property
def env_name(self) -> str | None:
return self._env_name
class CoreConfigSet(ConfigSet):
"""Configuration set for the core tox config."""
def __init__(self, conf: Config, section: Section, root: Path, src_path: Path) -> None:
self._root = root
self._src_path = src_path
super().__init__(conf, section=section, env_name=None)
desc = "define environments to automatically run"
self.add_config(keys=["env_list", "envlist"], of_type=EnvList, default=EnvList([]), desc=desc)
def _default_work_dir(self, conf: Config, env_name: str | None) -> Path: # noqa: ARG002
return cast(Path, self["tox_root"] / ".tox")
def _default_temp_dir(self, conf: Config, env_name: str | None) -> Path: # noqa: ARG002
return cast(Path, self["work_dir"] / ".tmp")
def _work_dir_post_process(self, folder: Path) -> Path:
return self._conf.work_dir if self._conf.options.work_dir else folder
def register_config(self) -> None:
self.add_constant(keys=["config_file_path"], desc="path to the configuration file", value=self._src_path)
self.add_config(
keys=["tox_root", "toxinidir"],
of_type=Path,
default=self._root,
desc="the root directory (where the configuration file is found)",
)
self.add_config(
keys=["work_dir", "toxworkdir"],
of_type=Path,
default=self._default_work_dir,
post_process=self._work_dir_post_process,
desc="working directory",
)
self.add_config(
keys=["temp_dir"],
of_type=Path,
default=self._default_temp_dir,
desc="a folder for temporary files (is not cleaned at start)",
)
self.add_constant("host_python", "the host python executable path", sys.executable)
def _on_duplicate_conf(self, key: str, definition: ConfigDefinition[V]) -> None:
pass # core definitions may be defined multiple times as long as all their options match, first defined wins
class EnvConfigSet(ConfigSet):
"""Configuration set for a tox environment."""
def __init__(self, conf: Config, section: Section, env_name: str) -> None:
super().__init__(conf, section, env_name)
self.default_set_env_loader: Callable[[], Mapping[str, str]] = dict
def register_config(self) -> None:
def set_env_post_process(values: SetEnv) -> SetEnv:
values.update(self.default_set_env_loader(), override=False)
values.update({"PYTHONIOENCODING": "utf-8"}, override=True)
return values
def set_env_factory(raw: object) -> SetEnv:
if not isinstance(raw, str):
raise TypeError(raw)
return SetEnv(raw, self.name, self.env_name, root)
root = self._conf.core["tox_root"]
self.add_config(
keys=["set_env", "setenv"],
of_type=SetEnv,
factory=set_env_factory,
default=SetEnv("", self.name, self.env_name, root),
desc="environment variables to set when running commands in the tox environment",
post_process=set_env_post_process,
)
def __repr__(self) -> str:
return f"{self.__class__.__name__}(name={self._env_name!r}, loaders={self.loaders!r})"
__all__ = (
"ConfigSet",
"CoreConfigSet",
"EnvConfigSet",
)
tox-4.13.0/src/tox/config/source/ 0000775 0000000 0000000 00000000000 14564001166 0016562 5 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/config/source/__init__.py 0000664 0000000 0000000 00000000226 14564001166 0020673 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from .api import Source
from .discover import discover_source
__all__ = (
"Source",
"discover_source",
)
tox-4.13.0/src/tox/config/source/api.py 0000664 0000000 0000000 00000007052 14564001166 0017711 0 ustar 00root root 0000000 0000000 """Sources."""
from __future__ import annotations
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING, Any, Iterator, List
from tox.config.loader.section import Section
if TYPE_CHECKING:
from pathlib import Path
from tox.config.loader.api import Loader, OverrideMap
from tox.config.sets import ConfigSet, CoreConfigSet
class Source(ABC):
"""Source is able to return a configuration value (for either the core or per environment source)."""
FILENAME = ""
def __init__(self, path: Path) -> None:
self.path: Path = path #: the path to the configuration source
self._section_to_loaders: dict[str, list[Loader[Any]]] = {}
def get_loaders(
self,
section: Section,
base: list[str] | None,
override_map: OverrideMap,
conf: ConfigSet,
) -> Iterator[Loader[Any]]:
"""
Return a loader that loads settings from a given section name.
:param section: the section to load
:param base: base sections to fallback to
:param override_map: a list of overrides to apply
:param conf: the config set to use
:returns: the loaders to use
"""
section = self.transform_section(section)
key = section.key
if key in self._section_to_loaders:
yield from self._section_to_loaders[key]
return
loaders: list[Loader[Any]] = []
self._section_to_loaders[key] = loaders
loader: Loader[Any] | None = self.get_loader(section, override_map)
if loader is not None:
loaders.append(loader)
yield loader
if base is not None:
conf.add_config(
keys="base",
of_type=List[str],
desc="inherit missing keys from these sections",
default=base,
)
for base_section in self.get_base_sections(conf["base"], section):
child = loader
loader = self.get_loader(base_section, override_map)
if loader is None:
loader = child
continue
if child is not None and loader is not None:
child.parent = loader
yield loader
loaders.append(loader)
@abstractmethod
def transform_section(self, section: Section) -> Section:
raise NotImplementedError
@abstractmethod
def get_loader(self, section: Section, override_map: OverrideMap) -> Loader[Any] | None:
raise NotImplementedError
@abstractmethod
def get_base_sections(self, base: list[str], in_section: Section) -> Iterator[Section]:
raise NotImplementedError
@abstractmethod
def sections(self) -> Iterator[Section]:
"""
Return a loader that loads the core configuration values.
:returns: the core loader from this source
"""
raise NotImplementedError
@abstractmethod
def envs(self, core_conf: CoreConfigSet) -> Iterator[str]:
"""
:param core_conf: the core configuration set
:returns: a list of environments defined within this source
"""
raise NotImplementedError
@abstractmethod
def get_tox_env_section(self, item: str) -> tuple[Section, list[str], list[str]]:
""":returns: the section for a tox environment"""
raise NotImplementedError
@abstractmethod
def get_core_section(self) -> Section:
""":returns: the core section"""
raise NotImplementedError
__all__ = [
"Section",
"Source",
]
tox-4.13.0/src/tox/config/source/discover.py 0000664 0000000 0000000 00000005403 14564001166 0020754 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import logging
from itertools import chain
from pathlib import Path
from typing import TYPE_CHECKING
from tox.report import HandledError
from .legacy_toml import LegacyToml
from .setup_cfg import SetupCfg
from .tox_ini import ToxIni
if TYPE_CHECKING:
from .api import Source
SOURCE_TYPES: tuple[type[Source], ...] = (ToxIni, SetupCfg, LegacyToml)
def discover_source(config_file: Path | None, root_dir: Path | None) -> Source:
"""
Discover a source for configuration.
:param config_file: the file storing the source
:param root_dir: the root directory as set by the user (None means not set)
:return: the source of the config
"""
if config_file is None:
src = _locate_source()
if src is None:
src = _create_default_source(root_dir)
elif config_file.is_dir():
src = None
for src_type in SOURCE_TYPES:
candidate: Path = config_file / src_type.FILENAME
try:
src = src_type(candidate)
break
except ValueError:
continue
if src is None:
msg = f"could not find any config file in {config_file}"
raise HandledError(msg)
else:
src = _load_exact_source(config_file)
return src
def _locate_source() -> Source | None:
folder = Path.cwd()
for base in chain([folder], folder.parents):
for src_type in SOURCE_TYPES:
candidate: Path = base / src_type.FILENAME
try:
return src_type(candidate)
except ValueError:
pass
return None
def _load_exact_source(config_file: Path) -> Source:
# if the filename matches to the letter some config file name do not fallback to other source types
exact_match = next((s for s in SOURCE_TYPES if config_file.name == s.FILENAME), None) # pragma: no cover
for src_type in (exact_match,) if exact_match is not None else SOURCE_TYPES: # pragma: no branch
try:
return src_type(config_file)
except ValueError: # noqa: PERF203
pass
msg = f"could not recognize config file {config_file}"
raise HandledError(msg)
def _create_default_source(root_dir: Path | None) -> Source:
if root_dir is None: # if set use that
empty = Path.cwd()
for base in chain([empty], empty.parents):
if (base / "pyproject.toml").exists():
empty = base
break
else: # if not set use where we find pyproject.toml in the tree or cwd
empty = root_dir
logging.warning("No %s found, assuming empty tox.ini at %s", " or ".join(i.FILENAME for i in SOURCE_TYPES), empty)
return ToxIni(empty / "tox.ini", content="")
__all__ = ("discover_source",)
tox-4.13.0/src/tox/config/source/ini.py 0000664 0000000 0000000 00000010636 14564001166 0017721 0 ustar 00root root 0000000 0000000 """Load."""
from __future__ import annotations
from collections import defaultdict
from configparser import ConfigParser
from itertools import chain
from typing import TYPE_CHECKING, Iterable, Iterator
from tox.config.loader.ini import IniLoader
from tox.config.loader.ini.factor import find_envs
from tox.config.loader.section import Section
from .api import Source
from .ini_section import CORE, PKG_ENV_PREFIX, TEST_ENV_PREFIX, IniSection
if TYPE_CHECKING:
from pathlib import Path
from tox.config.loader.api import OverrideMap
from tox.config.sets import ConfigSet
class IniSource(Source):
"""Configuration sourced from a ini file (such as tox.ini)."""
CORE_SECTION = CORE
def __init__(self, path: Path, content: str | None = None) -> None:
super().__init__(path)
self._parser = ConfigParser(interpolation=None)
if content is None:
if not path.exists():
raise ValueError
content = path.read_text()
self._parser.read_string(content, str(path))
self._section_mapping: defaultdict[str, list[str]] = defaultdict(list)
def transform_section(self, section: Section) -> Section: # noqa: PLR6301
return IniSection(section.prefix, section.name)
def sections(self) -> Iterator[IniSection]:
for section in self._parser.sections():
yield IniSection.from_key(section)
def get_loader(self, section: Section, override_map: OverrideMap) -> IniLoader | None:
# look up requested section name in the generative testenv mapping to find the real config source
for key in self._section_mapping.get(section.name) or []:
if section.prefix is None or Section.from_key(key).prefix == section.prefix:
break
else:
# if no matching section/prefix is found, use the requested section key as-is (for custom prefixes)
key = section.key
if self._parser.has_section(key):
return IniLoader(
section=section,
parser=self._parser,
overrides=override_map.get(section.key, []),
core_section=self.CORE_SECTION,
section_key=key,
)
return None
def get_core_section(self) -> Section:
return self.CORE_SECTION
def get_base_sections(self, base: list[str], in_section: Section) -> Iterator[Section]: # noqa: PLR6301
for a_base in base:
section = IniSection.from_key(a_base)
yield section # the base specifier is explicit
if in_section.prefix is not None: # no prefix specified, so this could imply our own prefix
yield IniSection(in_section.prefix, a_base)
def get_tox_env_section(self, item: str) -> tuple[Section, list[str], list[str]]: # noqa: PLR6301
return IniSection.test_env(item), [TEST_ENV_PREFIX], [PKG_ENV_PREFIX]
def envs(self, core_config: ConfigSet) -> Iterator[str]:
seen = set()
for name in self._discover_tox_envs(core_config):
if name not in seen:
seen.add(name)
yield name
def _discover_tox_envs(self, core_config: ConfigSet) -> Iterator[str]:
def register_factors(envs: Iterable[str]) -> None:
known_factors.update(chain.from_iterable(e.split("-") for e in envs))
explicit = list(core_config["env_list"])
yield from explicit
known_factors: set[str] = set()
register_factors(explicit)
# discover all additional defined environments, including generative section headers
for section in self.sections():
if section.is_test_env:
register_factors(section.names)
for name in section.names:
self._section_mapping[name].append(section.key)
yield name
# add all conditional markers that are not part of the explicitly defined sections
for section in self.sections():
yield from self._discover_from_section(section, known_factors)
def _discover_from_section(self, section: IniSection, known_factors: set[str]) -> Iterator[str]:
for value in self._parser[section.key].values():
for env in find_envs(value):
if set(env.split("-")) - known_factors:
yield env
def __repr__(self) -> str:
return f"{type(self).__name__}(path={self.path})"
__all__ = [
"IniSource",
]
tox-4.13.0/src/tox/config/source/ini_section.py 0000664 0000000 0000000 00000001203 14564001166 0021433 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from tox.config.loader.ini.factor import extend_factors
from tox.config.loader.section import Section
class IniSection(Section):
@classmethod
def test_env(cls, name: str) -> IniSection:
return cls(TEST_ENV_PREFIX, name)
@property
def is_test_env(self) -> bool:
return self.prefix == TEST_ENV_PREFIX
@property
def names(self) -> list[str]:
return list(extend_factors(self.name))
TEST_ENV_PREFIX = "testenv"
PKG_ENV_PREFIX = "pkgenv"
CORE = IniSection(None, "tox")
__all__ = [
"CORE",
"PKG_ENV_PREFIX",
"TEST_ENV_PREFIX",
"IniSection",
]
tox-4.13.0/src/tox/config/source/legacy_toml.py 0000664 0000000 0000000 00000001500 14564001166 0021427 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
if sys.version_info >= (3, 11): # pragma: no cover (py311+)
import tomllib
else: # pragma: no cover (py311+)
import tomli as tomllib
from typing import TYPE_CHECKING
from .ini import IniSource
if TYPE_CHECKING:
from pathlib import Path
class LegacyToml(IniSource):
FILENAME = "pyproject.toml"
def __init__(self, path: Path) -> None:
if path.name != self.FILENAME or not path.exists():
raise ValueError
with path.open("rb") as file_handler:
toml_content = tomllib.load(file_handler)
try:
content = toml_content["tool"]["tox"]["legacy_tox_ini"]
except KeyError as exc:
raise ValueError(path) from exc
super().__init__(path, content=content)
__all__ = ("LegacyToml",)
tox-4.13.0/src/tox/config/source/setup_cfg.py 0000664 0000000 0000000 00000001022 14564001166 0021106 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
from .ini import IniSource
from .ini_section import IniSection
if TYPE_CHECKING:
from pathlib import Path
class SetupCfg(IniSource):
"""Configuration sourced from a tox.ini file."""
CORE_SECTION = IniSection("tox", "tox")
FILENAME = "setup.cfg"
def __init__(self, path: Path) -> None:
super().__init__(path)
if not self._parser.has_section(self.CORE_SECTION.key):
raise ValueError
__all__ = ("SetupCfg",)
tox-4.13.0/src/tox/config/source/tox_ini.py 0000664 0000000 0000000 00000000301 14564001166 0020577 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from .ini import IniSource
class ToxIni(IniSource):
"""Configuration sourced from a tox.ini file."""
FILENAME = "tox.ini"
__all__ = ("ToxIni",)
tox-4.13.0/src/tox/config/types.py 0000664 0000000 0000000 00000004075 14564001166 0017006 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from collections import OrderedDict
from typing import Iterator, Sequence
from tox.execute.request import shell_cmd
class Command: # noqa: PLW1641
"""A command to execute."""
def __init__(self, args: list[str]) -> None:
"""
Create a new command to execute.
:param args: the command line arguments (first value can be ``-`` to indicate ignore the exit code)
"""
self.ignore_exit_code: bool = args[0] == "-" #: a flag indicating if the exit code should be ignored
self.args: list[str] = args[1:] if self.ignore_exit_code else args #: the command line arguments
def __repr__(self) -> str:
return f"{type(self).__name__}(args={(['-'] if self.ignore_exit_code else []) + self.args!r})"
def __eq__(self, other: object) -> bool:
return type(self) == type(other) and (self.args, self.ignore_exit_code) == (
other.args, # type: ignore[attr-defined]
other.ignore_exit_code, # type: ignore[attr-defined]
)
def __ne__(self, other: object) -> bool:
return not (self == other)
@property
def shell(self) -> str:
""":return: a shell representation of the command (platform dependent)"""
return shell_cmd(self.args)
class EnvList: # noqa: PLW1641
"""A tox environment list."""
def __init__(self, envs: Sequence[str]) -> None:
"""
Crate a new tox environment list.
:param envs: the list of tox environments
"""
self.envs = list(OrderedDict((e, None) for e in envs).keys())
def __repr__(self) -> str:
return f"{type(self).__name__}({self.envs!r})"
def __eq__(self, other: object) -> bool:
return type(self) == type(other) and self.envs == other.envs # type: ignore[attr-defined]
def __ne__(self, other: object) -> bool:
return not (self == other)
def __iter__(self) -> Iterator[str]:
""":return: iterator that goes through the defined env-list"""
return iter(self.envs)
__all__ = (
"Command",
"EnvList",
)
tox-4.13.0/src/tox/execute/ 0000775 0000000 0000000 00000000000 14564001166 0015457 5 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/execute/__init__.py 0000664 0000000 0000000 00000000340 14564001166 0017565 0 ustar 00root root 0000000 0000000 """Package that handles execution of commands within tox environments."""
from __future__ import annotations
from .api import Outcome
from .request import ExecuteRequest
__all__ = (
"ExecuteRequest",
"Outcome",
)
tox-4.13.0/src/tox/execute/api.py 0000664 0000000 0000000 00000022064 14564001166 0016606 0 ustar 00root root 0000000 0000000 """Abstract base API for executing commands within tox environments."""
from __future__ import annotations
import logging
import sys
import time
from abc import ABC, abstractmethod
from contextlib import contextmanager
from typing import TYPE_CHECKING, Any, Callable, Iterator, NoReturn, Sequence, cast
from colorama import Fore
from .request import ExecuteRequest, StdinSource
from .stream import SyncWrite
if TYPE_CHECKING:
from types import TracebackType
from tox.report import OutErr
from tox.tox_env.api import ToxEnv
ContentHandler = Callable[[bytes], None]
Executor = Callable[[ExecuteRequest, ContentHandler, ContentHandler], int]
LOGGER = logging.getLogger(__name__)
class ExecuteOptions:
def __init__(self, env: ToxEnv) -> None:
self._env = env
@classmethod
def register_conf(cls, env: ToxEnv) -> None:
env.conf.add_config(
keys=["suicide_timeout"],
desc="timeout to allow process to exit before sending SIGINT",
of_type=float,
default=0.0,
)
env.conf.add_config(
keys=["interrupt_timeout"],
desc="timeout before sending SIGTERM after SIGINT",
of_type=float,
default=0.3,
)
env.conf.add_config(
keys=["terminate_timeout"],
desc="timeout before sending SIGKILL after SIGTERM",
of_type=float,
default=0.2,
)
@property
def suicide_timeout(self) -> float:
return cast(float, self._env.conf["suicide_timeout"])
@property
def interrupt_timeout(self) -> float:
return cast(float, self._env.conf["interrupt_timeout"])
@property
def terminate_timeout(self) -> float:
return cast(float, self._env.conf["terminate_timeout"])
class ExecuteStatus(ABC):
def __init__(self, options: ExecuteOptions, out: SyncWrite, err: SyncWrite) -> None:
self.outcome: Outcome | None = None
self.options = options
self._out = out
self._err = err
@property
@abstractmethod
def exit_code(self) -> int | None:
raise NotImplementedError
@abstractmethod
def wait(self, timeout: float | None = None) -> int | None:
raise NotImplementedError
@abstractmethod
def write_stdin(self, content: str) -> None:
raise NotImplementedError
@abstractmethod
def interrupt(self) -> None:
raise NotImplementedError
def set_out_err(self, out: SyncWrite, err: SyncWrite) -> tuple[SyncWrite, SyncWrite]:
res = self._out, self._err
self._out, self._err = out, err
return res
@property
def out(self) -> bytearray:
return self._out.content
@property
def err(self) -> bytearray:
return self._err.content
@property
def metadata(self) -> dict[str, Any]:
return {}
class Execute(ABC):
"""Abstract API for execution of a tox environment."""
_option_class: type[ExecuteOptions] = ExecuteOptions
def __init__(self, colored: bool) -> None: # noqa: FBT001
self._colored = colored
@contextmanager
def call(
self,
request: ExecuteRequest,
show: bool, # noqa: FBT001
out_err: OutErr,
env: ToxEnv,
) -> Iterator[ExecuteStatus]:
start = time.monotonic()
try:
# collector is what forwards the content from the file streams to the standard streams
out, err = out_err[0].buffer, out_err[1].buffer
out_sync = SyncWrite(out.name, out if show else None)
err_sync = SyncWrite(err.name, err if show else None, Fore.RED if self._colored else None)
with out_sync, err_sync:
instance = self.build_instance(request, self._option_class(env), out_sync, err_sync)
with instance as status:
yield status
exit_code = status.exit_code
finally:
end = time.monotonic()
status.outcome = Outcome(
request,
show,
exit_code,
out_sync.text,
err_sync.text,
start,
end,
instance.cmd,
status.metadata,
)
@abstractmethod
def build_instance(
self,
request: ExecuteRequest,
options: ExecuteOptions,
out: SyncWrite,
err: SyncWrite,
) -> ExecuteInstance:
raise NotImplementedError
@classmethod
def register_conf(cls, env: ToxEnv) -> None:
cls._option_class.register_conf(env)
class ExecuteInstance(ABC):
"""An instance of a command execution."""
def __init__(self, request: ExecuteRequest, options: ExecuteOptions, out: SyncWrite, err: SyncWrite) -> None:
self.request = request
self.options = options
self._out = out
self._err = err
@property
def out_handler(self) -> ContentHandler:
return self._out.handler
@property
def err_handler(self) -> ContentHandler:
return self._err.handler
@abstractmethod
def __enter__(self) -> ExecuteStatus:
raise NotImplementedError
@abstractmethod
def __exit__(
self,
exc_type: type[BaseException] | None,
exc_val: BaseException | None,
exc_tb: TracebackType | None,
) -> None:
raise NotImplementedError
@property
@abstractmethod
def cmd(self) -> Sequence[str]:
raise NotImplementedError
class Outcome:
"""Result of a command execution."""
OK = 0
def __init__( # noqa: PLR0913
self,
request: ExecuteRequest,
show_on_standard: bool, # noqa: FBT001
exit_code: int | None,
out: str,
err: str,
start: float,
end: float,
cmd: Sequence[str],
metadata: dict[str, Any],
) -> None:
"""
Create a new execution outcome.
:param request: the execution request
:param show_on_standard: a flag indicating if the execution was shown on stdout/stderr
:param exit_code: the exit code for the execution
:param out: the standard output of the execution
:param err: the standard error of the execution
:param start: a timer sample for the start of the execution
:param end: a timer sample for the end of the execution
:param cmd: the command as executed
:param metadata: additional metadata attached to the execution
"""
self.request = request #: the execution request
self.show_on_standard = show_on_standard #: a flag indicating if the execution was shown on stdout/stderr
self.exit_code = exit_code #: the exit code for the execution
self.out = out #: the standard output of the execution
self.err = err #: the standard error of the execution
self.start = start #: a timer sample for the start of the execution
self.end = end #: a timer sample for the end of the execution
self.cmd = cmd #: the command as executed
self.metadata = metadata #: additional metadata attached to the execution
def __bool__(self) -> bool:
return self.exit_code == self.OK
def __repr__(self) -> str:
return (
f"{self.__class__.__name__}: exit {self.exit_code} in {self.elapsed:.2f} seconds"
f" for {self.request.shell_cmd}"
)
def assert_success(self) -> None:
"""Assert that the execution succeeded."""
if self.exit_code is not None and self.exit_code != self.OK:
self._assert_fail()
self.log_run_done(logging.INFO)
def _assert_fail(self) -> NoReturn:
if self.show_on_standard is False:
if self.out:
sys.stdout.write(self.out)
if not self.out.endswith("\n"):
sys.stdout.write("\n")
if self.err:
sys.stderr.write(Fore.RED)
sys.stderr.write(self.err)
sys.stderr.write(Fore.RESET)
if not self.err.endswith("\n"):
sys.stderr.write("\n")
self.log_run_done(logging.CRITICAL)
raise SystemExit(self.exit_code)
def log_run_done(self, lvl: int) -> None:
"""
Log that the run was done.
:param lvl: the level on what to log as interpreted by :func:`logging.log`
"""
req = self.request
metadata = ""
if self.metadata:
metadata = f" {', '.join(f'{k}={v}' for k, v in self.metadata.items())}"
LOGGER.log(
lvl,
"exit %s (%.2f seconds) %s> %s%s",
self.exit_code,
self.elapsed,
req.cwd,
req.shell_cmd,
metadata,
)
@property
def elapsed(self) -> float:
""":return: time the execution took in seconds"""
return self.end - self.start
def out_err(self) -> tuple[str, str]:
""":return: a tuple of the standard output and standard error"""
return self.out, self.err
__all__ = (
"ContentHandler",
"Execute",
"ExecuteInstance",
"ExecuteOptions",
"ExecuteStatus",
"Outcome",
"StdinSource",
)
tox-4.13.0/src/tox/execute/local_sub_process/ 0000775 0000000 0000000 00000000000 14564001166 0021160 5 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/execute/local_sub_process/__init__.py 0000664 0000000 0000000 00000033753 14564001166 0023304 0 ustar 00root root 0000000 0000000 """Execute that runs on local file system via subprocess-es."""
from __future__ import annotations
import fnmatch
import logging
import os
import shutil
import sys
from subprocess import DEVNULL, PIPE, TimeoutExpired
from typing import TYPE_CHECKING, Any, Generator, Sequence
from tox.execute.api import Execute, ExecuteInstance, ExecuteOptions, ExecuteStatus
from tox.execute.request import ExecuteRequest, StdinSource
from tox.execute.util import shebang
from tox.tox_env.errors import Fail
if TYPE_CHECKING:
import io
from types import TracebackType
from tox.execute.stream import SyncWrite
# mypy: warn-unused-ignores=false
if sys.platform == "win32": # explicit check for mypy # pragma: win32 cover
# needs stdin/stdout handlers backed by overlapped IO
if TYPE_CHECKING: # the typeshed libraries don't contain this, so replace it with normal one
from subprocess import Popen
else:
from asyncio.windows_utils import Popen
from signal import CTRL_C_EVENT as SIG_INTERRUPT
from signal import SIGTERM
from .read_via_thread_windows import ReadViaThreadWindows as ReadViaThread
else: # pragma: win32 no cover
from signal import SIGINT as SIG_INTERRUPT
from signal import SIGKILL, SIGTERM
from subprocess import Popen
from .read_via_thread_unix import ReadViaThreadUnix as ReadViaThread
IS_WIN = sys.platform == "win32"
class LocalSubProcessExecutor(Execute):
def build_instance( # noqa: PLR6301
self,
request: ExecuteRequest,
options: ExecuteOptions,
out: SyncWrite,
err: SyncWrite,
) -> ExecuteInstance:
return LocalSubProcessExecuteInstance(request, options, out, err)
class LocalSubprocessExecuteStatus(ExecuteStatus):
def __init__(self, options: ExecuteOptions, out: SyncWrite, err: SyncWrite, process: Popen[bytes]) -> None:
self._process: Popen[bytes] = process
super().__init__(options, out, err)
self._interrupted = False
@property
def exit_code(self) -> int | None:
# need to poll here, to make sure the returncode we get is current
self._process.poll()
return self._process.returncode
def interrupt(self) -> None:
self._interrupted = True
if self._process is not None: # pragma: no branch
# A three level stop mechanism for children - INT -> TERM -> KILL
# communicate will wait for the app to stop, and then drain the standard streams and close them
to_pid, host_pid = self._process.pid, os.getpid()
msg = "requested interrupt of %d from %d, activate in %.2f"
logging.warning(msg, to_pid, host_pid, self.options.suicide_timeout)
if self.wait(self.options.suicide_timeout) is None: # still alive -> INT
# on Windows everyone in the same process group, so they got the message
if sys.platform != "win32": # pragma: win32 cover
msg = "send signal %s to %d from %d with timeout %.2f"
logging.warning(msg, f"SIGINT({SIG_INTERRUPT})", to_pid, host_pid, self.options.interrupt_timeout)
self._process.send_signal(SIG_INTERRUPT)
if self.wait(self.options.interrupt_timeout) is None: # still alive -> TERM # pragma: no branch
terminate_output = self.options.terminate_timeout
logging.warning(msg, f"SIGTERM({SIGTERM})", to_pid, host_pid, terminate_output)
self._process.terminate()
# Windows terminate is UNIX kill
if sys.platform != "win32" and self.wait(terminate_output) is None: # pragma: no branch
logging.warning(msg[:-18], f"SIGKILL({SIGKILL})", to_pid, host_pid)
self._process.kill() # still alive -> KILL
self.wait() # unconditional wait as kill should soon bring down the process
logging.warning("interrupt finished with success")
else: # pragma: no cover # difficult to test, process must die just as it's being interrupted
logging.warning("process already dead with %s within %s", self._process.returncode, host_pid)
def wait(self, timeout: float | None = None) -> int | None:
try: # note wait in general might deadlock if output large, but we drain in background threads so not an issue
return self._process.wait(timeout=timeout)
except TimeoutExpired:
return None
def write_stdin(self, content: str) -> None:
stdin = self._process.stdin
if stdin is None: # pragma: no branch
return # pragma: no cover
bytes_content = content.encode()
try:
if sys.platform == "win32": # explicit check for mypy # pragma: win32 cover
# on Windows we have a PipeHandle object here rather than a file stream
import _overlapped # type: ignore[import] # noqa: PLC0415,PLC2701
ov = _overlapped.Overlapped(0)
ov.WriteFile(stdin.handle, bytes_content) # type: ignore[attr-defined]
result = ov.getresult(10) # wait up to 10ms to perform the operation
if result != len(bytes_content):
msg = f"failed to write to {stdin!r}"
raise RuntimeError(msg)
else:
stdin.write(bytes_content)
stdin.flush()
except OSError: # pragma: no cover
if self._interrupted: # pragma: no cover
pass # pragma: no cover # if the process was asked to exit in the meantime ignore write errors
raise # pragma: no cover
def __repr__(self) -> str:
return f"{self.__class__.__name__}(pid={self._process.pid}, returncode={self._process.returncode!r})"
@property
def metadata(self) -> dict[str, Any]:
return {"pid": self._process.pid} if self._process.pid else {}
class LocalSubprocessExecuteFailedStatus(ExecuteStatus):
def __init__(self, options: ExecuteOptions, out: SyncWrite, err: SyncWrite, exit_code: int | None) -> None:
super().__init__(options, out, err)
self._exit_code = exit_code
@property
def exit_code(self) -> int | None:
return self._exit_code
def wait(self, timeout: float | None = None) -> int | None: # noqa: ARG002
return self._exit_code # pragma: no cover
def write_stdin(self, content: str) -> None:
"""Cannot write."""
def interrupt(self) -> None: # noqa: PLR6301
return None # pragma: no cover # nothing running so nothing to interrupt
class LocalSubProcessExecuteInstance(ExecuteInstance):
def __init__( # noqa: PLR0913
self,
request: ExecuteRequest,
options: ExecuteOptions,
out: SyncWrite,
err: SyncWrite,
on_exit_drain: bool = True, # noqa: FBT001, FBT002
) -> None:
super().__init__(request, options, out, err)
self.process: Popen[bytes] | None = None
self._cmd: list[str] | None = None
self._read_stderr: ReadViaThread | None = None
self._read_stdout: ReadViaThread | None = None
self._on_exit_drain = on_exit_drain
@property
def cmd(self) -> Sequence[str]:
if self._cmd is None:
base = self.request.cmd[0]
executable = shutil.which(base, path=self.request.env["PATH"])
if executable is None:
cmd = self.request.cmd # if failed to find leave as it is
else:
if self.request.allow is not None:
for allow in self.request.allow:
# 1. allow matches just the original name of the executable
# 2. allow matches the entire resolved path
if fnmatch.fnmatch(self.request.cmd[0], allow) or fnmatch.fnmatch(executable, allow):
break
else:
msg = f"{base} (resolves to {executable})" if base == executable else base
msg = f"{msg} is not allowed, use allowlist_externals to allow it"
raise Fail(msg)
cmd = [executable]
if sys.platform != "win32" and self.request.env.get("TOX_LIMITED_SHEBANG", "").strip():
shebang_line = shebang(executable)
if shebang_line:
cmd = [*shebang_line, executable]
cmd.extend(self.request.cmd[1:])
self._cmd = cmd
return self._cmd
def __enter__(self) -> ExecuteStatus:
# adjust sub-process terminal size
columns, lines = shutil.get_terminal_size(fallback=(-1, -1))
if columns != -1: # pragma: no branch
self.request.env.setdefault("COLUMNS", str(columns))
if lines != -1: # pragma: no branch
self.request.env.setdefault("LINES", str(lines))
stdout, stderr = self.get_stream_file_no("stdout"), self.get_stream_file_no("stderr")
try:
self.process = process = Popen(
self.cmd, # noqa: S603
stdout=next(stdout),
stderr=next(stderr),
stdin={StdinSource.USER: None, StdinSource.OFF: DEVNULL, StdinSource.API: PIPE}[self.request.stdin],
cwd=str(self.request.cwd),
env=self.request.env,
)
except OSError as exception:
return LocalSubprocessExecuteFailedStatus(self.options, self._out, self._err, exception.errno)
status = LocalSubprocessExecuteStatus(self.options, self._out, self._err, process)
drain, pid = self._on_exit_drain, self.process.pid
self._read_stderr = ReadViaThread(stderr.send(process), self.err_handler, name=f"err-{pid}", drain=drain)
self._read_stderr.__enter__()
self._read_stdout = ReadViaThread(stdout.send(process), self.out_handler, name=f"out-{pid}", drain=drain)
self._read_stdout.__enter__()
if sys.platform == "win32": # explicit check for mypy: # pragma: win32 cover
process.stderr.read = self._read_stderr._drain_stream # type: ignore[assignment,union-attr] # noqa: SLF001
process.stdout.read = self._read_stdout._drain_stream # type: ignore[assignment,union-attr] # noqa: SLF001
return status
def __exit__(
self,
exc_type: type[BaseException] | None,
exc_val: BaseException | None,
exc_tb: TracebackType | None,
) -> None:
if self._read_stderr is not None:
self._read_stderr.__exit__(exc_type, exc_val, exc_tb)
if self._read_stdout is not None:
self._read_stdout.__exit__(exc_type, exc_val, exc_tb)
if self.process is not None: # cleanup the file handlers
for stream in (self.process.stdout, self.process.stderr, self.process.stdin):
if stream is not None and not getattr(stream, "closed", False):
try:
stream.close()
except OSError as exc: # pragma: no cover
logging.warning("error while trying to close %r with %r", stream, exc) # pragma: no cover
@staticmethod
def get_stream_file_no(key: str) -> Generator[int, Popen[bytes], None]:
allocated_pty = _pty(key)
if allocated_pty is not None:
main_fd, child_fd = allocated_pty
yield child_fd
os.close(child_fd) # close the child process pipe
yield main_fd
else:
process = yield PIPE
stream = getattr(process, key)
if sys.platform == "win32": # explicit check for mypy # pragma: win32 cover
yield stream.handle
else:
yield stream.name
def set_out_err(self, out: SyncWrite, err: SyncWrite) -> tuple[SyncWrite, SyncWrite]:
prev = self._out, self._err
if self._read_stdout is not None: # pragma: no branch
self._read_stdout.handler = out.handler
if self._read_stderr is not None: # pragma: no branch
self._read_stderr.handler = err.handler
return prev
def _pty(key: str) -> tuple[int, int] | None:
"""
Allocate a virtual terminal (pty) for a subprocess.
A virtual terminal allows a process to perform syscalls that fetch attributes related to the tty,
for example to determine whether to use colored output or enter interactive mode.
The termios attributes of the controlling terminal stream will be copied to the allocated pty.
:param key: The stream to copy attributes from. Either "stdout" or "stderr".
:return: (main_fd, child_fd) of an allocated pty; or None on error or if unsupported (win32).
"""
if sys.platform == "win32": # explicit check for mypy # pragma: win32 cover
return None
stream: io.TextIOWrapper = getattr(sys, key)
# when our current stream is a tty, emulate pty for the child
# to allow host streams traits to be inherited
if not stream.isatty():
return None
try:
import fcntl # noqa: PLC0415
import pty # noqa: PLC0415
import struct # noqa: PLC0415
import termios # noqa: PLC0415
except ImportError: # pragma: no cover
return None # cannot proceed on platforms without pty support
try:
main, child = pty.openpty()
except OSError: # could not open a tty
return None # pragma: no cover
try:
mode = termios.tcgetattr(stream)
termios.tcsetattr(child, termios.TCSANOW, mode)
except (termios.error, OSError): # could not inherit traits
return None # pragma: no cover
# adjust sub-process terminal size
columns, lines = shutil.get_terminal_size(fallback=(-1, -1))
if columns != -1 and lines != -1:
size = struct.pack("HHHH", lines, columns, 0, 0)
fcntl.ioctl(child, termios.TIOCSWINSZ, size)
return main, child
__all__ = (
"CREATION_FLAGS",
"SIG_INTERRUPT",
"LocalSubProcessExecuteInstance",
"LocalSubProcessExecutor",
"LocalSubprocessExecuteFailedStatus",
"LocalSubprocessExecuteStatus",
)
tox-4.13.0/src/tox/execute/local_sub_process/read_via_thread.py 0000664 0000000 0000000 00000003043 14564001166 0024633 0 ustar 00root root 0000000 0000000 """A reader that drain a stream via its file no on a background thread."""
from __future__ import annotations
from abc import ABC, abstractmethod
from threading import Event, Thread
from typing import TYPE_CHECKING, Callable
if TYPE_CHECKING:
import sys
from types import TracebackType
if sys.version_info >= (3, 11): # pragma: no cover (py311+)
from typing import Self
else: # pragma: no cover ( None: # noqa: FBT001
self.file_no = file_no
self.stop = Event()
self.thread = Thread(target=self._read_stream, name=f"tox-r-{name}-{file_no}")
self.handler = handler
self._on_exit_drain = drain
def __enter__(self) -> Self:
self.thread.start()
return self
def __exit__(
self,
exc_type: type[BaseException] | None,
exc_val: BaseException | None,
exc_tb: TracebackType | None,
) -> None:
self.stop.set() # signal thread to stop
while self.thread.is_alive(): # wait until it stops
self.thread.join(WAIT_GENERAL)
self._drain_stream() # read anything left
@abstractmethod
def _read_stream(self) -> None:
raise NotImplementedError
@abstractmethod
def _drain_stream(self) -> None:
raise NotImplementedError
tox-4.13.0/src/tox/execute/local_sub_process/read_via_thread_unix.py 0000664 0000000 0000000 00000003700 14564001166 0025676 0 ustar 00root root 0000000 0000000 """On UNIX we use select.select to ensure we drain in a non-blocking fashion."""
from __future__ import annotations
import errno # pragma: win32 no cover
import os # pragma: win32 no cover
import select # pragma: win32 no cover
from typing import Callable
from .read_via_thread import ReadViaThread # pragma: win32 no cover
STOP_EVENT_CHECK_PERIODICITY_IN_MS = 0.01 # pragma: win32 no cover
class ReadViaThreadUnix(ReadViaThread): # pragma: win32 no cover
def __init__(self, file_no: int, handler: Callable[[bytes], None], name: str, drain: bool) -> None: # noqa: FBT001
super().__init__(file_no, handler, name, drain)
def _read_stream(self) -> None:
while not self.stop.is_set():
# we need to drain the stream, but periodically give chance for the thread to break if the stop event has
# been set (this is so that an interrupt can be handled)
if self._read_available() is None: # pragma: no branch
break # pragma: no cover
def _drain_stream(self) -> None:
# no block just poll
while True:
if self._read_available(timeout=0) is not True: # pragma: no branch
break # pragma: no cover
def _read_available(self, timeout: float = STOP_EVENT_CHECK_PERIODICITY_IN_MS) -> bool | None:
try:
ready, __, ___ = select.select([self.file_no], [], [], timeout)
if ready:
data = os.read(self.file_no, 1024) # read up to 1024 characters
# If the end of the file referred to by fd has been reached, an empty bytes object is returned.
if data:
self.handler(data)
return True
except OSError as exception: # pragma: no cover
# Bad file descriptor or Input/output error
if exception.errno in {errno.EBADF, errno.EIO}:
return None
raise
else:
return False
tox-4.13.0/src/tox/execute/local_sub_process/read_via_thread_windows.py 0000664 0000000 0000000 00000005535 14564001166 0026415 0 ustar 00root root 0000000 0000000 """On Windows we use overlapped mechanism, borrowing it from asyncio (but without the event loop)."""
from __future__ import annotations # pragma: win32 cover
import logging # pragma: win32 cover
from asyncio.windows_utils import BUFSIZE # type: ignore[attr-defined] # pragma: win32 cover
from time import sleep # pragma: win32 cover
from typing import Callable # pragma: win32 cover
import _overlapped # type: ignore[import] # pragma: win32 cover # noqa: PLC2701
from .read_via_thread import ReadViaThread # pragma: win32 cover
# mypy: warn-unused-ignores=false
class ReadViaThreadWindows(ReadViaThread): # pragma: win32 cover
def __init__(self, file_no: int, handler: Callable[[bytes], None], name: str, drain: bool) -> None: # noqa: FBT001
super().__init__(file_no, handler, name, drain)
self.closed = False
self._ov: _overlapped.Overlapped | None = None
self._waiting_for_read = False
def _read_stream(self) -> None:
keep_reading = True
while keep_reading: # try to read at least once
wait = self._read_batch()
if wait is None:
break
if wait is True:
sleep(0.01) # sleep for 10ms if there was no data to read and try again
keep_reading = not self.stop.is_set()
def _drain_stream(self) -> None:
wait: bool | None = self.closed
while wait is False:
wait = self._read_batch()
def _read_batch(self) -> bool | None:
""":returns: None means error can no longer read, True wait for result, False try again"""
if self._waiting_for_read is False:
self._ov = _overlapped.Overlapped(0) # can use it only once to read a batch
try: # read up to BUFSIZE at a time
self._ov.ReadFile(self.file_no, BUFSIZE) # type: ignore[attr-defined]
self._waiting_for_read = True
except OSError:
self.closed = True
return None
try: # wait=False to not block and give chance for the stop check
data = self._ov.getresult(False) # type: ignore[union-attr] # noqa: FBT003
except OSError as exception:
# 996 (0x3E4) Overlapped I/O event is not in a signaled state.
# 995 (0x3E3) The I/O operation has been aborted because of either a thread exit or an application request.
win_error = getattr(exception, "winerror", None)
if win_error == 996: # noqa: PLR2004
return True
if win_error != 995: # noqa: PLR2004
logging.error("failed to read %r", exception) # noqa: TRY400
return None
else:
self._ov = None
self._waiting_for_read = False
if data:
self.handler(data)
else:
return None
return False
tox-4.13.0/src/tox/execute/pep517_backend.py 0000664 0000000 0000000 00000012127 14564001166 0020524 0 ustar 00root root 0000000 0000000 """A executor that reuses a single subprocess for all backend calls (saving on python startup/import overhead)."""
from __future__ import annotations
import time
from subprocess import TimeoutExpired
from threading import Lock
from typing import TYPE_CHECKING, Sequence
from pyproject_api import BackendFailed
from tox.execute import ExecuteRequest
from tox.execute.api import Execute, ExecuteInstance, ExecuteOptions, ExecuteStatus
from tox.execute.local_sub_process import LocalSubProcessExecuteInstance
from tox.execute.request import StdinSource
from tox.execute.stream import SyncWrite
if TYPE_CHECKING:
from pathlib import Path
from types import TracebackType
class LocalSubProcessPep517Executor(Execute):
"""Executor holding the backend process."""
def __init__(self, colored: bool, cmd: Sequence[str], env: dict[str, str], cwd: Path) -> None: # noqa: FBT001
super().__init__(colored)
self.cmd = cmd
self.env = env
self.cwd = cwd
self._local_execute: tuple[LocalSubProcessExecuteInstance, ExecuteStatus] | None = None
self._exc: Exception | None = None
self.is_alive: bool = False
def build_instance(
self,
request: ExecuteRequest,
options: ExecuteOptions,
out: SyncWrite,
err: SyncWrite,
) -> ExecuteInstance:
return LocalSubProcessPep517ExecuteInstance(request, options, out, err, self.local_execute(options))
def local_execute(self, options: ExecuteOptions) -> tuple[LocalSubProcessExecuteInstance, ExecuteStatus]:
if self._exc is not None:
raise self._exc
if self._local_execute is None:
request = ExecuteRequest(cmd=self.cmd, cwd=self.cwd, env=self.env, stdin=StdinSource.API, run_id="pep517")
instance = LocalSubProcessExecuteInstance(
request=request,
options=options,
out=SyncWrite(name="pep517-out", target=None, color=None), # not enabled no need to enter/exit
err=SyncWrite(name="pep517-err", target=None, color=None), # not enabled no need to enter/exit
on_exit_drain=False,
)
status = instance.__enter__() # noqa: PLC2801
self._local_execute = instance, status
while True:
if b"started backend " in status.out:
self.is_alive = True
break
if b"failed to start backend" in status.err:
from tox.tox_env.python.virtual_env.package.pyproject import ToxBackendFailed # noqa: PLC0415
failure = BackendFailed(
result={
"code": -5,
"exc_type": "FailedToStart",
"exc_msg": "could not start backend",
},
out=status.out.decode(),
err=status.err.decode(),
)
self._exc = ToxBackendFailed(failure)
raise self._exc
time.sleep(0.01) # wait a short while for the output to populate
return self._local_execute
@staticmethod
def _handler(into: bytearray, content: bytes) -> None:
"""Ignore content generated."""
into.extend(content) # pragma: no cover
def close(self) -> None:
if self._local_execute is not None: # pragma: no branch
execute, _status = self._local_execute
execute.__exit__(None, None, None)
if execute.process is not None and execute.process.returncode is None: # pragma: no cover
try: # pragma: no cover
execute.process.wait(timeout=0.1) # pragma: no cover
except TimeoutExpired: # pragma: no cover
execute.process.terminate() # pragma: no cover # if does not stop on its own kill it
self.is_alive = False
class LocalSubProcessPep517ExecuteInstance(ExecuteInstance):
"""A backend invocation."""
def __init__( # noqa: PLR0913
self,
request: ExecuteRequest,
options: ExecuteOptions,
out: SyncWrite,
err: SyncWrite,
instance_status: tuple[LocalSubProcessExecuteInstance, ExecuteStatus],
) -> None:
super().__init__(request, options, out, err)
self._instance, self._status = instance_status
self._lock = Lock()
@property
def cmd(self) -> Sequence[str]:
return self._instance.cmd
def __enter__(self) -> ExecuteStatus:
self._lock.acquire()
self._swap_out_err()
return self._status
def __exit__(
self,
exc_type: type[BaseException] | None,
exc_val: BaseException | None,
exc_tb: TracebackType | None,
) -> None:
self._swap_out_err()
self._lock.release()
def _swap_out_err(self) -> None:
out, err = self._out, self._err
# update status to see the newly collected content
self._out, self._err = self._instance.set_out_err(out, err)
# update the thread out/err
self._status.set_out_err(out, err)
tox-4.13.0/src/tox/execute/request.py 0000664 0000000 0000000 00000005133 14564001166 0017523 0 ustar 00root root 0000000 0000000 """Module declaring a command execution request."""
from __future__ import annotations
import sys
from enum import Enum
from pathlib import Path
from typing import Sequence
class StdinSource(Enum):
OFF = 0 #: input disabled
USER = 1 #: input via the standard input
API = 2 #: input via programmatic access
@staticmethod
def user_only() -> StdinSource:
""":return: ``USER`` if the standard input is tty type else ``OFF``"""
return StdinSource.USER if sys.stdin.isatty() else StdinSource.OFF
class ExecuteRequest:
"""Defines a commands execution request."""
def __init__( # noqa: PLR0913
self,
cmd: Sequence[str | Path],
cwd: Path,
env: dict[str, str],
stdin: StdinSource,
run_id: str,
allow: list[str] | None = None,
) -> None:
"""
Create a new execution request.
:param cmd: the command to run
:param cwd: the current working directory
:param env: the environment variables
:param stdin: the type of standard input allowed
:param run_id: an id to identify this run
"""
if len(cmd) == 0:
msg = "cannot execute an empty command"
raise ValueError(msg)
self.cmd: list[str] = [str(i) for i in cmd] #: the command to run
self.cwd = cwd #: the working directory to use
self.env = env #: the environment variables to use
self.stdin = stdin #: the type of standard input interaction allowed
self.run_id = run_id #: an id to identify this run
if allow is not None and "*" in allow:
allow = None # if we allow everything we can just disable the check
self.allow = allow
@property
def shell_cmd(self) -> str:
""":return: the command to run as a shell command"""
try:
exe = str(Path(self.cmd[0]).relative_to(self.cwd))
except ValueError:
exe = self.cmd[0]
_cmd = [exe]
_cmd.extend(self.cmd[1:])
return shell_cmd(_cmd)
def __repr__(self) -> str:
return f"{self.__class__.__name__}(cmd={self.cmd!r}, cwd={self.cwd!r}, env=..., stdin={self.stdin!r})"
def shell_cmd(cmd: Sequence[str]) -> str:
if sys.platform == "win32": # pragma: win32 cover
from subprocess import list2cmdline # noqa: PLC0415
return list2cmdline(tuple(str(x) for x in cmd))
# pragma: win32 no cover
from shlex import quote as shlex_quote # noqa: PLC0415
return " ".join(shlex_quote(str(x)) for x in cmd)
__all__ = (
"ExecuteRequest",
"StdinSource",
"shell_cmd",
)
tox-4.13.0/src/tox/execute/stream.py 0000664 0000000 0000000 00000007114 14564001166 0017327 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from contextlib import contextmanager
from threading import Event, Lock, Timer
from typing import IO, TYPE_CHECKING, Iterator
from colorama import Fore
if TYPE_CHECKING:
import sys
from types import TracebackType
if sys.version_info >= (3, 11): # pragma: no cover (py311+)
from typing import Self
else: # pragma: no cover ( None:
self._content = bytearray()
self._target: IO[bytes] | None = target
self._target_enabled: bool = target is not None
self._keep_printing: Event = Event()
self._content_lock: Lock = Lock()
self._lock: Lock = Lock()
self._at: int = 0
self._color: str | None = color
self.name = name
def __repr__(self) -> str:
return f"{self.__class__.__name__}(name={self.name!r}, target={self._target!r}, color={self._color!r})"
def __enter__(self) -> Self:
if self._target_enabled:
self._start()
return self
def __exit__(
self,
exc_type: type[BaseException] | None,
exc_val: BaseException | None,
exc_tb: TracebackType | None,
) -> None:
if self._target_enabled:
self._cancel()
self._write(len(self._content))
def handler(self, content: bytes) -> None:
"""A callback called whenever content is written."""
with self._content_lock:
self._content.extend(content)
if self._target_enabled is False:
return
at = content.rfind(b"\n")
if at != -1: # pragma: no branch
at = len(self._content) - len(content) + at + 1
self._cancel()
try:
if at != -1:
self._write(at)
finally:
self._start()
def _start(self) -> None:
self.timer = Timer(self.REFRESH_RATE, self._trigger_timer)
self.timer.name = f"{self.name}-sync-timer"
self.timer.start()
def _cancel(self) -> None:
self.timer.cancel()
def _trigger_timer(self) -> None:
with self._content_lock:
at = len(self._content)
self._write(at)
def _write(self, at: int) -> None:
assert self._target is not None # because _do_print is guarding the call of this method # noqa: S101
with self._lock:
if at > self._at: # pragma: no branch
try:
with self.colored():
self._target.write(self._content[self._at : at])
self._target.flush()
finally:
self._at = at
@contextmanager
def colored(self) -> Iterator[None]:
if self._color is None or self._target is None:
yield
else:
self._target.write(self._color.encode("utf-8"))
try:
yield
finally:
self._target.write(Fore.RESET.encode("utf-8"))
@property
def text(self) -> str:
with self._content_lock:
return self._content.decode("utf-8", errors="surrogateescape")
@property
def content(self) -> bytearray:
with self._content_lock:
return self._content
tox-4.13.0/src/tox/execute/util.py 0000664 0000000 0000000 00000001776 14564001166 0017021 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from pathlib import Path
def shebang(exe: str) -> list[str] | None:
"""
:param exe: the executable
:return: the shebang interpreter arguments
"""
# When invoking a command using a shebang line that exceeds the OS shebang limit (e.g. Linux has a limit of 128;
# BINPRM_BUF_SIZE) the invocation will fail. In this case you'd want to replace the shebang invocation with an
# explicit invocation.
# see https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/fs/binfmt_script.c#n34
try:
with Path(exe).open("rb") as file_handler:
marker = file_handler.read(2)
if marker != b"#!":
return None
shebang_line = file_handler.readline()
except OSError:
return None
try:
decoded = shebang_line.decode("UTF-8")
except UnicodeDecodeError:
return None
return [i.strip() for i in decoded.strip().split() if i.strip()]
__all__ = [
"shebang",
]
tox-4.13.0/src/tox/journal/ 0000775 0000000 0000000 00000000000 14564001166 0015467 5 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/journal/__init__.py 0000664 0000000 0000000 00000000775 14564001166 0017611 0 ustar 00root root 0000000 0000000 """This module handles collecting and persisting in json format a tox session."""
from __future__ import annotations
import json
from pathlib import Path
from .env import EnvJournal
from .main import Journal
def write_journal(path: Path | None, journal: Journal) -> None:
if path is None:
return
with Path(path).open("w") as file_handler:
json.dump(journal.content, file_handler, indent=2, ensure_ascii=False)
__all__ = (
"EnvJournal",
"Journal",
"write_journal",
)
tox-4.13.0/src/tox/journal/env.py 0000664 0000000 0000000 00000004150 14564001166 0016631 0 ustar 00root root 0000000 0000000 """Record information about tox environments."""
from __future__ import annotations
from typing import TYPE_CHECKING, Any
if TYPE_CHECKING:
from tox.execute import Outcome
class EnvJournal:
"""Report the status of a tox environment."""
def __init__(self, enabled: bool, name: str) -> None: # noqa: FBT001
self._enabled = enabled
self.name = name
self._content: dict[str, Any] = {}
self._executes: list[tuple[str, Outcome]] = []
def __setitem__(self, key: str, value: Any) -> None:
"""
Add a new entry under key into the event journal.
:param key: the key under what to add the data
:param value: the data to add
"""
self._content[key] = value
def __bool__(self) -> bool:
""":return: a flag indicating if the event journal is on or not"""
return self._enabled
def add_execute(self, outcome: Outcome, run_id: str) -> None:
"""
Add a command execution to the journal.
:param outcome: the execution outcome
:param run_id: the execution id
"""
self._executes.append((run_id, outcome))
@property
def content(self) -> dict[str, Any]:
""":return: the env journal content (merges explicit keys and execution commands)"""
tests: list[dict[str, Any]] = []
setup: list[dict[str, Any]] = []
for run_id, outcome in self._executes:
one = {
"command": outcome.cmd,
"output": outcome.out,
"err": outcome.err,
"retcode": outcome.exit_code,
"elapsed": outcome.elapsed,
"show_on_standard": outcome.show_on_standard,
"run_id": run_id,
"start": outcome.start,
"end": outcome.end,
}
if run_id.startswith(("commands", "build")):
tests.append(one)
else:
setup.append(one)
if tests:
self["test"] = tests
if setup:
self["setup"] = setup
return self._content
__all__ = ("EnvJournal",)
tox-4.13.0/src/tox/journal/main.py 0000664 0000000 0000000 00000002574 14564001166 0016775 0 ustar 00root root 0000000 0000000 """Generate json report of a tox run."""
from __future__ import annotations
import socket
import sys
from typing import Any
from tox.version import version
from .env import EnvJournal
class Journal:
"""The result of a tox session."""
def __init__(self, enabled: bool) -> None: # noqa: FBT001
self._enabled = enabled
self._content: dict[str, Any] = {}
self._env: dict[str, EnvJournal] = {}
if self._enabled:
self._content.update(
{
"reportversion": "1",
"toxversion": version,
"platform": sys.platform,
"host": socket.getfqdn(),
},
)
def get_env_journal(self, name: str) -> EnvJournal:
"""Return the env log of an environment (create on first call)."""
if name not in self._env:
env = EnvJournal(self._enabled, name)
self._env[name] = env
return self._env[name]
@property
def content(self) -> dict[str, Any]:
test_env_journals: dict[str, Any] = {}
for name, value in self._env.items():
test_env_journals[name] = value.content
if test_env_journals:
self._content["testenvs"] = test_env_journals
return self._content
def __bool__(self) -> bool:
return self._enabled
__all__ = ("Journal",)
tox-4.13.0/src/tox/plugin/ 0000775 0000000 0000000 00000000000 14564001166 0015313 5 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/plugin/__init__.py 0000664 0000000 0000000 00000002772 14564001166 0017434 0 ustar 00root root 0000000 0000000 """
tox uses `pluggy "
raise HandledError(msg)
loader.raw["commands"] = [Command(list(pos_args))]
return run_sequential(state)
tox-4.13.0/src/tox/session/cmd/legacy.py 0000664 0000000 0000000 00000012710 14564001166 0020062 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from pathlib import Path
from typing import TYPE_CHECKING, cast
from packaging.requirements import InvalidRequirement, Requirement
from tox.config.cli.parser import DEFAULT_VERBOSITY, Parsed, ToxParser
from tox.config.loader.memory import MemoryLoader
from tox.config.set_env import SetEnv
from tox.plugin import impl
from tox.session.cmd.run.common import env_run_create_flags
from tox.session.cmd.run.parallel import OFF_VALUE, parallel_flags, run_parallel
from tox.session.cmd.run.sequential import run_sequential
from tox.session.env_select import CliEnv, EnvSelector, register_env_select_flags
from tox.tox_env.python.pip.req_file import PythonDeps
from .devenv import devenv
from .list_env import list_env
from .show_config import show_config
if TYPE_CHECKING:
from tox.session.state import State
@impl
def tox_add_option(parser: ToxParser) -> None:
our = parser.add_command("legacy", ["le"], "legacy entry-point command", legacy)
our.add_argument("--help-ini", "--hi", action="store_true", help="show live configuration", dest="show_config")
our.add_argument(
"--showconfig",
action="store_true",
help="show live configuration (by default all env, with -l only default targets, specific via TOXENV/-e)",
dest="show_config",
)
our.add_argument(
"-a",
"--listenvs-all",
action="store_true",
help="show list of all defined environments (with description if verbose)",
dest="list_envs_all",
)
our.add_argument(
"-l",
"--listenvs",
action="store_true",
help="show list of test environments (with description if verbose)",
dest="list_envs",
)
our.add_argument(
"--devenv",
help="sets up a development environment at ENVDIR based on the env's tox configuration specified by"
"`-e` (-e defaults to py)",
dest="devenv_path",
metavar="ENVDIR",
default=None,
of_type=Path,
)
register_env_select_flags(our, default=CliEnv())
env_run_create_flags(our, mode="legacy")
parallel_flags(our, default_parallel=OFF_VALUE, no_args=True)
our.add_argument(
"--pre",
action="store_true",
help="deprecated use PIP_PRE in set_env instead - install pre-releases and development versions of"
"dependencies; this will set PIP_PRE=1 environment variable",
)
our.add_argument(
"--force-dep",
action="append",
metavar="req",
default=[],
help="Forces a certain version of one of the dependencies when configuring the virtual environment. REQ "
"Examples 'pytest<6.1' or 'django>=2.2'.",
type=Requirement,
)
our.add_argument(
"--sitepackages",
action="store_true",
help="deprecated use VIRTUALENV_SYSTEM_SITE_PACKAGES=1, override sitepackages setting to True in all envs",
dest="site_packages",
)
our.add_argument(
"--alwayscopy",
action="store_true",
help="deprecated use VIRTUALENV_ALWAYS_COPY=1, override always copy setting to True in all envs",
dest="always_copy",
)
def legacy(state: State) -> int:
option = state.conf.options
if option.show_config:
option.list_keys_only = []
option.show_core = not bool(option.env)
if option.list_envs or option.list_envs_all:
state.envs.on_empty_fallback_py = False
option.list_no_description = option.verbosity <= DEFAULT_VERBOSITY
option.list_default_only = not option.list_envs_all
option.show_core = False
_handle_legacy_only_flags(option, state.envs)
if option.show_config:
return show_config(state)
if option.list_envs or option.list_envs_all:
return list_env(state)
if option.devenv_path:
if option.env.is_default_list:
option.env = CliEnv(["py"])
option.devenv_path = Path(option.devenv_path)
return devenv(state)
if option.parallel_no_spinner is True or option.parallel != 0: # only 0 means sequential
return run_parallel(state)
return run_sequential(state)
def _handle_legacy_only_flags(option: Parsed, envs: EnvSelector) -> None: # noqa: C901
override = {}
if getattr(option, "site_packages", False):
override["system_site_packages"] = True
if getattr(option, "always_copy", False):
override["always_copy"] = True
set_env = {}
if getattr(option, "pre", False):
set_env["PIP_PRE"] = "1"
forced = {j.name: j for j in getattr(option, "force_dep", [])}
if override or set_env or forced:
for env in envs.iter(only_active=True, package=False):
env_conf = envs[env].conf
if override:
env_conf.loaders.insert(0, MemoryLoader(**override))
if set_env:
cast(SetEnv, env_conf["set_env"]).update(set_env, override=True)
if forced:
to_force = forced.copy()
deps = cast(PythonDeps, env_conf["deps"])
as_root_args = deps.as_root_args
for at, entry in enumerate(as_root_args):
try:
req = Requirement(entry)
except InvalidRequirement:
continue
if req.name in to_force:
as_root_args[at] = str(to_force[req.name])
del to_force[req.name]
as_root_args.extend(str(v) for v in to_force.values())
tox-4.13.0/src/tox/session/cmd/list_env.py 0000664 0000000 0000000 00000004104 14564001166 0020437 0 ustar 00root root 0000000 0000000 """Print available tox environments."""
from __future__ import annotations
from itertools import chain
from typing import TYPE_CHECKING
from tox.plugin import impl
from tox.session.env_select import register_env_select_flags
if TYPE_CHECKING:
from tox.config.cli.parser import ToxParser
from tox.session.state import State
@impl
def tox_add_option(parser: ToxParser) -> None:
our = parser.add_command("list", ["l"], "list environments", list_env)
our.add_argument("--no-desc", action="store_true", help="do not show description", dest="list_no_description")
d = register_env_select_flags(our, default=None, group_only=True)
d.add_argument("-d", action="store_true", help="list just default envs", dest="list_default_only")
def list_env(state: State) -> int:
option = state.conf.options
has_group_select = bool(option.factors or option.labels)
active_only = has_group_select or option.list_default_only
active = dict.fromkeys(state.envs.iter())
inactive = {} if active_only else {env: None for env in state.envs.iter(only_active=False) if env not in active}
if not has_group_select and not option.list_no_description and active:
print("default environments:") # noqa: T201
max_length = max((len(env) for env in chain(active, inactive)), default=0)
def report_env(name: str) -> None:
if not option.list_no_description:
tox_env = state.envs[name]
text = tox_env.conf["description"]
if not text.strip():
text = "[no description]"
text = text.replace("\n", " ")
msg = f"{env.ljust(max_length)} -> {text}".strip()
else:
msg = env
print(msg) # noqa: T201
for env in active:
report_env(env)
if not has_group_select and not option.list_default_only and inactive:
if not option.list_no_description:
if active: # pragma: no branch
print() # noqa: T201
print("additional environments:") # noqa: T201
for env in inactive:
report_env(env)
return 0
tox-4.13.0/src/tox/session/cmd/quickstart.py 0000664 0000000 0000000 00000003304 14564001166 0021007 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from pathlib import Path
from textwrap import dedent
from typing import TYPE_CHECKING
from packaging.version import Version
from tox.plugin import impl
from tox.version import version as __version__
if TYPE_CHECKING:
from tox.config.cli.parser import ToxParser
from tox.session.state import State
@impl
def tox_add_option(parser: ToxParser) -> None:
our = parser.add_command(
"quickstart",
["q"],
"Command line script to quickly create a tox config file for a Python project",
quickstart,
)
our.add_argument(
"quickstart_root",
metavar="root",
default=Path().absolute(),
nargs="?",
help="folder to create the tox.ini file",
type=Path,
)
def quickstart(state: State) -> int:
root = state.conf.options.quickstart_root.absolute()
tox_ini = root / "tox.ini"
if tox_ini.exists():
print(f"{tox_ini} already exist, refusing to overwrite") # noqa: T201
return 1
version = str(Version(__version__.split("+")[0]))
text = f"""
[tox]
env_list =
py{''.join(str(i) for i in sys.version_info[0:2])}
minversion = {version}
[testenv]
description = run the tests with pytest
package = wheel
wheel_build_env = .pkg
deps =
pytest>=6
commands =
pytest {{tty:--color=yes}} {{posargs}}
"""
content = dedent(text).lstrip()
print(f"tox {__version__} quickstart utility, will create {tox_ini}:") # noqa: T201
print(content, end="") # noqa: T201
root.mkdir(parents=True, exist_ok=True)
tox_ini.write_text(content)
return 0
tox-4.13.0/src/tox/session/cmd/run/ 0000775 0000000 0000000 00000000000 14564001166 0017047 5 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/session/cmd/run/__init__.py 0000664 0000000 0000000 00000000124 14564001166 0021155 0 ustar 00root root 0000000 0000000 """Defines how we execute a tox environment."""
from __future__ import annotations
tox-4.13.0/src/tox/session/cmd/run/common.py 0000664 0000000 0000000 00000042402 14564001166 0020713 0 ustar 00root root 0000000 0000000 """Common functionality shared across multiple type of runs."""
from __future__ import annotations
import logging
import os
import random
import sys
import time
from argparse import Action, ArgumentError, ArgumentParser, Namespace
from concurrent.futures import CancelledError, Future, ThreadPoolExecutor, as_completed
from pathlib import Path
from signal import SIGINT, Handlers, signal
from threading import Event, Thread
from typing import TYPE_CHECKING, Any, Iterator, Optional, Sequence, cast
from colorama import Fore
from tox.config.types import EnvList
from tox.execute import Outcome
from tox.journal import write_journal
from tox.session.cmd.run.single import ToxEnvRunResult, run_one
from tox.tox_env.runner import RunToxEnv
from tox.util.ci import is_ci
from tox.util.graph import stable_topological_sort
from tox.util.spinner import MISS_DURATION, Spinner
if TYPE_CHECKING:
from tox.session.state import State
from tox.tox_env.api import ToxEnv
class SkipMissingInterpreterAction(Action):
def __call__(
self,
parser: ArgumentParser, # noqa: ARG002
namespace: Namespace,
values: str | Sequence[Any] | None,
option_string: str | None = None, # noqa: ARG002
) -> None:
value = "true" if values is None else values
if value not in {"config", "true", "false"}:
raise ArgumentError(self, f"value must be 'config', 'true', or 'false' (got {value!r})")
setattr(namespace, self.dest, value)
class InstallPackageAction(Action):
def __call__(
self,
parser: ArgumentParser, # noqa: ARG002
namespace: Namespace,
values: str | Sequence[Any] | None,
option_string: str | None = None, # noqa: ARG002
) -> None:
if not values:
raise ArgumentError(self, "cannot be empty")
path = Path(cast(str, values)).absolute()
if not path.exists():
raise ArgumentError(self, f"{path} does not exist")
if not path.is_file():
raise ArgumentError(self, f"{path} is not a file")
setattr(namespace, self.dest, path)
def env_run_create_flags(parser: ArgumentParser, mode: str) -> None: # noqa: C901
# mode can be one of: run, run-parallel, legacy, devenv, config
if mode not in {"config", "depends"}:
parser.add_argument(
"--result-json",
dest="result_json",
metavar="path",
of_type=Path,
default=None,
help="write a JSON file with detailed information about all commands and results involved",
)
if mode not in {"devenv", "depends"}:
parser.add_argument(
"-s",
"--skip-missing-interpreters",
default="config",
metavar="v",
nargs="?",
action=SkipMissingInterpreterAction,
help="don't fail tests for missing interpreters: {config,true,false} choice",
)
if mode not in {"devenv", "config", "depends"}:
parser.add_argument(
"-n",
"--notest",
dest="no_test",
help="do not run the test commands",
action="store_true",
)
parser.add_argument(
"-b",
"--pkg-only",
"--sdistonly",
action="store_true",
help="only perform the packaging activity",
dest="package_only",
)
parser.add_argument(
"--installpkg",
help="use specified package for installation into venv, instead of packaging the project",
default=None,
of_type=Optional[Path],
action=InstallPackageAction,
dest="install_pkg",
)
if mode not in {"devenv", "depends"}:
parser.add_argument(
"--develop",
action="store_true",
help="install package in development mode",
dest="develop",
)
if mode != "depends":
class SeedAction(Action):
def __call__(
self,
parser: ArgumentParser, # noqa: ARG002
namespace: Namespace,
values: str | Sequence[Any] | None,
option_string: str | None = None, # noqa: ARG002
) -> None:
if values == "notset":
result = None
else:
try:
result = int(cast(str, values))
if result <= 0:
msg = "must be greater than zero"
raise ValueError(msg) # noqa: TRY301
except ValueError as exc:
raise ArgumentError(self, str(exc)) from exc
setattr(namespace, self.dest, result)
if os.environ.get("PYTHONHASHSEED", "random") != "random":
hashseed_default = int(os.environ["PYTHONHASHSEED"])
else:
hashseed_default = random.randint(1, 1024 if sys.platform == "win32" else 4294967295) # noqa: S311
parser.add_argument(
"--hashseed",
metavar="SEED",
help="set PYTHONHASHSEED to SEED before running commands. Defaults to a random integer in the range "
"[1, 4294967295] ([1, 1024] on Windows). Passing 'notset' suppresses this behavior.",
action=SeedAction,
of_type=Optional[int],
default=hashseed_default,
dest="hash_seed",
)
parser.add_argument(
"--discover",
dest="discover",
nargs="+",
metavar="path",
help="for Python discovery first try the Python executables under these paths",
default=[],
)
if mode != "depends":
parser.add_argument(
"--no-recreate-pkg",
dest="no_recreate_pkg",
help="if recreate is set do not recreate packaging tox environment(s)",
action="store_true",
)
list_deps = parser.add_mutually_exclusive_group()
list_deps.add_argument(
"--list-dependencies",
action="store_true",
default=is_ci(),
help="list the dependencies installed during environment setup",
)
list_deps.add_argument(
"--no-list-dependencies",
action="store_false",
dest="list_dependencies",
help="never list the dependencies installed during environment setup",
)
if mode not in {"devenv", "config", "depends"}:
parser.add_argument(
"--skip-pkg-install",
dest="skip_pkg_install",
help="skip package installation for this run",
action="store_true",
)
def report(start: float, runs: list[ToxEnvRunResult], is_colored: bool, verbosity: int) -> int: # noqa: FBT001
def _print(color_: int, message: str) -> None:
if verbosity:
print(f"{color_ if is_colored else ''}{message}{Fore.RESET if is_colored else ''}") # noqa: T201
successful, skipped = [], []
for run in runs:
successful.append(run.code == Outcome.OK or run.ignore_outcome)
skipped.append(run.skipped)
duration_individual = [o.elapsed for o in run.outcomes] if verbosity >= 2 else [] # noqa: PLR2004
extra = f"+cmd[{','.join(f'{i:.2f}' for i in duration_individual)}]" if duration_individual else ""
setup = run.duration - sum(duration_individual)
msg, color = _get_outcome_message(run)
out = f" {run.name}: {msg} ({run.duration:.2f}{f'=setup[{setup:.2f}]{extra}' if extra else ''} seconds)"
_print(color, out)
duration = time.monotonic() - start
all_good = all(successful) and not all(skipped)
if all_good:
_print(Fore.GREEN, f" congratulations :) ({duration:.2f} seconds)")
return Outcome.OK
_print(Fore.RED, f" evaluation failed :( ({duration:.2f} seconds)")
if len(runs) == 1:
return runs[0].code if not runs[0].skipped else -1
return -1
def _get_outcome_message(run: ToxEnvRunResult) -> tuple[str, int]:
if run.skipped:
msg, color = "SKIP", Fore.YELLOW
elif run.code == Outcome.OK:
msg, color = "OK", Fore.GREEN
elif run.ignore_outcome:
msg, color = f"IGNORED FAIL code {run.code}", Fore.YELLOW
else:
msg, color = f"FAIL code {run.code}", Fore.RED
return msg, color
logger = logging.getLogger(__name__)
def execute(state: State, max_workers: int | None, has_spinner: bool, live: bool) -> int: # noqa: FBT001
interrupt, done = Event(), Event()
results: list[ToxEnvRunResult] = []
future_to_env: dict[Future[ToxEnvRunResult], ToxEnv] = {}
state.envs.ensure_only_run_env_is_active()
to_run_list: list[str] = list(state.envs.iter())
for name in to_run_list:
cast(RunToxEnv, state.envs[name]).mark_active()
previous, has_previous = None, False
try:
spinner = ToxSpinner(has_spinner, state, len(to_run_list))
thread = Thread(
target=_queue_and_wait,
name="tox-interrupt",
args=(state, to_run_list, results, future_to_env, interrupt, done, max_workers, spinner, live),
)
thread.start()
try:
thread.join()
except KeyboardInterrupt:
previous, has_previous = signal(SIGINT, Handlers.SIG_IGN), True
spinner.print_report = False # no need to print reports at this point, final report coming up
logger.error("[%s] KeyboardInterrupt - teardown started", os.getpid()) # noqa: TRY400
interrupt.set()
# cancel in reverse order to not allow submitting new jobs as we cancel running ones
for future, tox_env in reversed(list(future_to_env.items())):
canceled = future.cancel()
# if cannot be canceled and not done -> still runs
if canceled is False and not future.done(): # pragma: no branch
tox_env.interrupt()
done.wait()
# workaround for https://bugs.python.org/issue45274
lock = getattr(thread, "_tstate_lock", None)
if lock is not None and lock.locked(): # pragma: no branch
lock.release() # pragma: no cover
# calling private method to fix thread state
thread._stop() # type: ignore[attr-defined] # pragma: no cover # noqa: SLF001
thread.join()
finally:
name_to_run = {r.name: r for r in results}
ordered_results: list[ToxEnvRunResult] = [name_to_run[env] for env in to_run_list]
# write the journal
write_journal(getattr(state.conf.options, "result_json", None), state._journal) # noqa: SLF001
# report the outcome
exit_code = report(
state.conf.options.start,
ordered_results,
state.conf.options.is_colored,
state.conf.options.verbosity,
)
if has_previous:
signal(SIGINT, previous)
return exit_code
class ToxSpinner(Spinner):
def __init__(self, enabled: bool, state: State, total: int) -> None: # noqa: FBT001
super().__init__(
enabled=enabled,
colored=state.conf.options.is_colored,
stream=state._options.log_handler.stdout, # noqa: SLF001
total=total,
)
def update_spinner(self, result: ToxEnvRunResult, success: bool) -> None: # noqa: FBT001
done = (self.skip if result.skipped else self.succeed) if success else self.fail
done(result.name)
def _queue_and_wait( # noqa: C901, PLR0913, PLR0915
state: State,
to_run_list: list[str],
results: list[ToxEnvRunResult],
future_to_env: dict[Future[ToxEnvRunResult], ToxEnv],
interrupt: Event,
done: Event,
max_workers: int | None,
spinner: ToxSpinner,
live: bool, # noqa: FBT001
) -> None:
try: # noqa: PLR1702
options = state._options # noqa: SLF001
with spinner:
max_workers = len(to_run_list) if max_workers is None else max_workers
completed: set[str] = set()
envs_to_run_generator = ready_to_run_envs(state, to_run_list, completed)
def _run(tox_env: RunToxEnv) -> ToxEnvRunResult:
spinner.add(tox_env.conf.name)
return run_one(
tox_env,
options.parsed.no_test or options.parsed.package_only,
suspend_display=live is False,
)
try:
executor = ThreadPoolExecutor(max_workers=max_workers, thread_name_prefix="tox-driver")
env_list: list[str] = []
while True:
for env in env_list: # queue all available
tox_env_to_run = cast(RunToxEnv, state.envs[env])
if interrupt.is_set(): # queue the rest as failed upfront
tox_env_to_run.teardown()
future: Future[ToxEnvRunResult] = Future()
res = ToxEnvRunResult(name=env, skipped=False, code=-2, outcomes=[], duration=MISS_DURATION)
future.set_result(res)
else:
future = executor.submit(_run, tox_env_to_run)
future_to_env[future] = tox_env_to_run
if not future_to_env:
result: ToxEnvRunResult | None = None
else: # if we have queued wait for completed
future = next(as_completed(future_to_env))
tox_env_done = future_to_env.pop(future)
try:
result = future.result()
except CancelledError:
tox_env_done.teardown()
name = tox_env_done.conf.name
result = ToxEnvRunResult(
name=name,
skipped=False,
code=-3,
outcomes=[],
duration=MISS_DURATION,
)
results.append(result)
completed.add(result.name)
env_list = next(envs_to_run_generator, [])
# if nothing running and nothing more to run we're done
final_run = not env_list and not future_to_env
if final_run: # disable report on final env
spinner.print_report = False
if result is not None:
_handle_one_run_done(result, spinner, state, live)
if final_run:
break
except BaseException: # pragma: no cover
logging.exception("Internal Error") # pragma: no cover
raise # pragma: no cover
finally:
executor.shutdown(wait=True)
finally:
try:
# call teardown - configuration only environments for example could not be finished
for name in to_run_list:
state.envs[name].teardown()
finally:
done.set()
def _handle_one_run_done(
result: ToxEnvRunResult,
spinner: ToxSpinner,
state: State,
live: bool, # noqa: FBT001
) -> None:
success = result.code == Outcome.OK
spinner.update_spinner(result, success)
tox_env = cast(RunToxEnv, state.envs[result.name])
if tox_env.journal: # add overall journal entry
tox_env.journal["result"] = {
"success": success,
"exit_code": result.code,
"duration": result.duration,
}
if live is False and state.conf.options.parallel_live is False: # teardown background run
out_err = tox_env.close_and_read_out_err() # sync writes from buffer to stdout/stderr
pkg_out_err_list = []
for package_env in tox_env.package_envs:
pkg_out_err = package_env.close_and_read_out_err()
if pkg_out_err is not None: # pragma: no branch
pkg_out_err_list.append(pkg_out_err)
if not success or tox_env.conf["parallel_show_output"]:
for pkg_out_err in pkg_out_err_list:
state._options.log_handler.write_out_err(pkg_out_err) # pragma: no cover # noqa: SLF001
if out_err is not None: # pragma: no branch # first show package build
state._options.log_handler.write_out_err(out_err) # noqa: SLF001
def ready_to_run_envs(state: State, to_run: list[str], completed: set[str]) -> Iterator[list[str]]:
"""Generate tox environments ready to run."""
order, todo = run_order(state, to_run)
while order:
ready_to_run: list[str] = []
new_order: list[str] = []
for env in order: # collect next batch of ready to run
if todo[env] - completed:
new_order.append(env)
else:
ready_to_run.append(env)
order = new_order
yield ready_to_run
def run_order(state: State, to_run: list[str]) -> tuple[list[str], dict[str, set[str]]]:
to_run_set = set(to_run)
todo: dict[str, set[str]] = {}
for env in to_run:
run_env = cast(RunToxEnv, state.envs[env])
depends = set(cast(EnvList, run_env.conf["depends"]).envs)
todo[env] = to_run_set & depends
order = stable_topological_sort(todo)
return order, todo
tox-4.13.0/src/tox/session/cmd/run/parallel.py 0000664 0000000 0000000 00000005407 14564001166 0021223 0 ustar 00root root 0000000 0000000 """Run tox environments in parallel."""
from __future__ import annotations
import logging
from argparse import ArgumentParser, ArgumentTypeError
from typing import TYPE_CHECKING
from tox.plugin import impl
from tox.session.env_select import CliEnv, register_env_select_flags
from tox.util.cpu import auto_detect_cpus
from .common import env_run_create_flags, execute
if TYPE_CHECKING:
from tox.config.cli.parser import ToxParser
from tox.session.state import State
logger = logging.getLogger(__name__)
ENV_VAR_KEY = "TOX_PARALLEL_ENV"
OFF_VALUE = 0
DEFAULT_PARALLEL = "auto"
@impl
def tox_add_option(parser: ToxParser) -> None:
our = parser.add_command("run-parallel", ["p"], "run environments in parallel", run_parallel)
register_env_select_flags(our, default=CliEnv())
env_run_create_flags(our, mode="run-parallel")
parallel_flags(our, default_parallel=DEFAULT_PARALLEL)
def parse_num_processes(str_value: str) -> int | None:
if str_value == "all":
return None
if str_value == "auto":
return auto_detect_cpus()
try:
value = int(str_value)
except ValueError as exc:
msg = f"value must be a positive number, is {str_value!r}"
raise ArgumentTypeError(msg) from exc
if value < 0:
msg = f"value must be positive, is {value!r}"
raise ArgumentTypeError(msg)
return value
def parallel_flags(
our: ArgumentParser,
default_parallel: int | str,
no_args: bool = False, # noqa: FBT001, FBT002
) -> None:
our.add_argument(
"-p",
"--parallel",
dest="parallel",
help="run tox environments in parallel, the argument controls limit: all,"
" auto - cpu count, some positive number, zero is turn off",
action="store",
type=parse_num_processes, # type: ignore[arg-type] # nargs confuses it
default=default_parallel,
metavar="VAL",
**({"nargs": "?"} if no_args else {}), # type: ignore[arg-type] # type checker can't unroll it
)
our.add_argument(
"-o",
"--parallel-live",
action="store_true",
dest="parallel_live",
help="connect to stdout while running environments",
)
our.add_argument(
"--parallel-no-spinner",
action="store_true",
dest="parallel_no_spinner",
help="run tox environments in parallel, but don't show the spinner, implies --parallel",
)
def run_parallel(state: State) -> int:
"""Here we'll just start parallel sub-processes."""
option = state.conf.options
return execute(
state,
max_workers=None if option.parallel_no_spinner is True else option.parallel,
has_spinner=option.parallel_no_spinner is False and option.parallel_live is False,
live=option.parallel_live,
)
tox-4.13.0/src/tox/session/cmd/run/sequential.py 0000664 0000000 0000000 00000001315 14564001166 0021573 0 ustar 00root root 0000000 0000000 """Run tox environments in sequential order."""
from __future__ import annotations
from typing import TYPE_CHECKING
from tox.plugin import impl
from tox.session.env_select import CliEnv, register_env_select_flags
from .common import env_run_create_flags, execute
if TYPE_CHECKING:
from tox.config.cli.parser import ToxParser
from tox.session.state import State
@impl
def tox_add_option(parser: ToxParser) -> None:
our = parser.add_command("run", ["r"], "run environments", run_sequential)
register_env_select_flags(our, default=CliEnv())
env_run_create_flags(our, mode="run")
def run_sequential(state: State) -> int:
return execute(state, max_workers=1, has_spinner=False, live=True)
tox-4.13.0/src/tox/session/cmd/run/single.py 0000664 0000000 0000000 00000011024 14564001166 0020700 0 ustar 00root root 0000000 0000000 """Defines how to run a single tox environment."""
from __future__ import annotations
import logging
import time
from typing import TYPE_CHECKING, NamedTuple, cast
from tox.execute.api import Outcome, StdinSource
from tox.tox_env.errors import Fail, Skip
from tox.tox_env.python.virtual_env.package.pyproject import ToxBackendFailed
if TYPE_CHECKING:
from pathlib import Path
from tox.config.types import Command
from tox.tox_env.api import ToxEnv
from tox.tox_env.runner import RunToxEnv
LOGGER = logging.getLogger(__name__)
class ToxEnvRunResult(NamedTuple):
name: str
skipped: bool
code: int
outcomes: list[Outcome]
duration: float
ignore_outcome: bool = False
def run_one(tox_env: RunToxEnv, no_test: bool, suspend_display: bool) -> ToxEnvRunResult: # noqa: FBT001
start_one = time.monotonic()
name = tox_env.conf.name
with tox_env.display_context(suspend_display):
skipped, code, outcomes = _evaluate(tox_env, no_test)
duration = time.monotonic() - start_one
return ToxEnvRunResult(name, skipped, code, outcomes, duration, tox_env.conf["ignore_outcome"])
def _evaluate(tox_env: RunToxEnv, no_test: bool) -> tuple[bool, int, list[Outcome]]: # noqa: FBT001
skipped = False
code: int = 0
outcomes: list[Outcome] = []
try:
try:
tox_env.setup()
code, outcomes = run_commands(tox_env, no_test)
except Skip as exception:
LOGGER.warning("skipped because %s", exception)
code = 0
skipped = True
except ToxBackendFailed as exception:
LOGGER.error("%s", exception) # noqa: TRY400
raise SystemExit(exception.code) # noqa: B904, TRY200
except Fail as exception:
LOGGER.error("failed with %s", exception) # noqa: TRY400
code = 1
except Exception: # pragma: no cover
LOGGER.exception("internal error") # pragma: no cover
code = 2 # pragma: no cover
finally:
tox_env.teardown()
except SystemExit as exception: # setup command fails (interrupted or via invocation)
code = cast(int, exception.code)
return skipped, code, outcomes
def run_commands(tox_env: RunToxEnv, no_test: bool) -> tuple[int, list[Outcome]]: # noqa: FBT001
outcomes: list[Outcome] = []
if no_test:
exit_code = Outcome.OK
else:
from tox.plugin.manager import MANAGER # importing this here to avoid circular import # noqa: PLC0415
chdir: Path = tox_env.conf["change_dir"]
chdir.mkdir(exist_ok=True, parents=True)
ignore_errors: bool = tox_env.conf["ignore_errors"]
MANAGER.tox_before_run_commands(tox_env)
status_pre, status_main, status_post = -1, -1, -1
try:
try:
status_pre = run_command_set(tox_env, "commands_pre", chdir, ignore_errors, outcomes)
if status_pre == Outcome.OK or ignore_errors:
status_main = run_command_set(tox_env, "commands", chdir, ignore_errors, outcomes)
else:
status_main = Outcome.OK
finally:
status_post = run_command_set(tox_env, "commands_post", chdir, ignore_errors, outcomes)
finally:
exit_code = status_pre or status_main or status_post # first non-success
MANAGER.tox_after_run_commands(tox_env, exit_code, outcomes)
return exit_code, outcomes
def run_command_set(
tox_env: ToxEnv,
key: str,
cwd: Path,
ignore_errors: bool, # noqa: FBT001
outcomes: list[Outcome],
) -> int:
exit_code = Outcome.OK
command_set: list[Command] = tox_env.conf[key]
for at, cmd in enumerate(command_set):
current_outcome = tox_env.execute(
cmd.args,
cwd=cwd,
stdin=StdinSource.user_only(),
show=True,
run_id=f"{key}[{at}]",
)
outcomes.append(current_outcome)
try:
current_outcome.assert_success()
except SystemExit as exception:
if cmd.ignore_exit_code:
logging.warning("command failed but is marked ignore outcome so handling it as success")
continue
if ignore_errors:
if exit_code == Outcome.OK:
exit_code = cast(int, exception.code) # ignore errors continues ahead but saves the exit code
continue
return cast(int, exception.code)
return exit_code
__all__ = (
"ToxEnvRunResult",
"run_command_set",
"run_one",
)
tox-4.13.0/src/tox/session/cmd/show_config.py 0000664 0000000 0000000 00000007620 14564001166 0021127 0 ustar 00root root 0000000 0000000 """Show materialized configuration of tox environments."""
from __future__ import annotations
from textwrap import indent
from typing import TYPE_CHECKING, Iterable
from colorama import Fore
from tox.config.loader.stringify import stringify
from tox.plugin import impl
from tox.session.cmd.run.common import env_run_create_flags
from tox.session.env_select import CliEnv, register_env_select_flags
if TYPE_CHECKING:
from tox.config.cli.parser import ToxParser
from tox.config.sets import ConfigSet
from tox.session.state import State
from tox.tox_env.api import ToxEnv
@impl
def tox_add_option(parser: ToxParser) -> None:
our = parser.add_command("config", ["c"], "show tox configuration", show_config)
our.add_argument(
"-k",
nargs="+",
help="list just configuration keys specified",
dest="list_keys_only",
default=[],
metavar="key",
)
our.add_argument(
"--core",
action="store_true",
help="show core options (by default is hidden unless -e ALL is passed)",
dest="show_core",
)
register_env_select_flags(our, default=CliEnv())
env_run_create_flags(our, mode="config")
def show_config(state: State) -> int:
is_colored = state.conf.options.is_colored
keys: list[str] = state.conf.options.list_keys_only
is_first = True
def _print_env(tox_env: ToxEnv) -> None:
nonlocal is_first
if is_first:
is_first = False
else:
print() # noqa: T201
print_section_header(is_colored, f"[testenv:{tox_env.conf.name}]")
if not keys:
print_key_value(is_colored, "type", type(tox_env).__name__)
print_conf(is_colored, tox_env.conf, keys)
show_everything = state.conf.options.env.is_all
done: set[str] = set()
for name in state.envs.iter(package=True): # now go through selected ones
done.add(name)
_print_env(state.envs[name])
# environments may define core configuration flags, so we must exhaust first the environments to tell the core part
if show_everything or state.conf.options.show_core:
print() # noqa: T201
print_section_header(is_colored, "[tox]")
print_conf(is_colored, state.conf.core, keys)
return 0
def _colored(is_colored: bool, color: int, msg: str) -> str: # noqa: FBT001
return f"{color}{msg}{Fore.RESET}" if is_colored else msg
def print_section_header(is_colored: bool, name: str) -> None: # noqa: FBT001
print(_colored(is_colored, Fore.YELLOW, name)) # noqa: T201
def print_comment(is_colored: bool, comment: str) -> None: # noqa: FBT001
print(_colored(is_colored, Fore.CYAN, comment)) # noqa: T201
def print_key_value(is_colored: bool, key: str, value: str, multi_line: bool = False) -> None: # noqa: FBT001, FBT002
print(_colored(is_colored, Fore.GREEN, key), end="") # noqa: T201
print(" =", end="") # noqa: T201
if multi_line:
print() # noqa: T201
value_str = indent(value, prefix=" ")
else:
print(" ", end="") # noqa: T201
value_str = value
print(value_str) # noqa: T201
def print_conf(is_colored: bool, conf: ConfigSet, keys: Iterable[str]) -> None: # noqa: FBT001
for key in keys if keys else conf:
if key not in conf:
continue
key = conf.primary_key(key) # noqa: PLW2901
try:
value = conf[key]
as_str, multi_line = stringify(value)
except Exception as exception: # because e.g. the interpreter cannot be found # noqa: BLE001
as_str, multi_line = _colored(is_colored, Fore.LIGHTRED_EX, f"# Exception: {exception!r}"), False
if multi_line and "\n" not in as_str:
multi_line = False
print_key_value(is_colored, key, as_str, multi_line=multi_line)
unused = conf.unused()
if unused and not keys:
print_comment(is_colored, f"# !!! unused: {', '.join(unused)}")
tox-4.13.0/src/tox/session/cmd/version_flag.py 0000664 0000000 0000000 00000003337 14564001166 0021301 0 ustar 00root root 0000000 0000000 """Display the version information about tox."""
from __future__ import annotations
import sys
from argparse import SUPPRESS, Action, ArgumentParser, Namespace
from pathlib import Path
from typing import Any, Sequence, cast
import tox
from tox.config.cli.parser import HelpFormatter, ToxParser
from tox.plugin import impl
from tox.plugin.manager import MANAGER
from tox.version import version
@impl
def tox_add_option(parser: ToxParser) -> None:
class _V(Action):
def __init__(self, option_strings: Sequence[str], dest: str = SUPPRESS) -> None:
help_msg = "show program's and plugins version number and exit"
super().__init__(option_strings=option_strings, dest=dest, nargs=0, help=help_msg, default=SUPPRESS)
def __call__(
self,
parser: ArgumentParser,
namespace: Namespace, # noqa: ARG002
values: str | Sequence[Any] | None, # noqa: ARG002
option_string: str | None = None, # noqa: ARG002
) -> None:
formatter = cast(HelpFormatter, parser._get_formatter()) # noqa: SLF001
formatter.add_raw_text(get_version_info())
parser._print_message(formatter.format_help(), sys.stdout) # noqa: SLF001
parser.exit()
parser.add_argument("--version", action=_V)
def get_version_info() -> str:
out = [f"{version} from {Path(tox.__file__).absolute()}"]
plugin_info = MANAGER.manager.list_plugin_distinfo()
if plugin_info:
out.append("registered plugins:")
for module, egg_info in plugin_info:
source = getattr(module, "__file__", repr(module))
out.append(f" {egg_info.project_name}-{egg_info.version} at {source}")
return "\n".join(out)
tox-4.13.0/src/tox/session/env_select.py 0000664 0000000 0000000 00000052122 14564001166 0020203 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import logging
import re
from collections import Counter
from dataclasses import dataclass
from difflib import get_close_matches
from itertools import chain
from typing import TYPE_CHECKING, Dict, Iterable, Iterator, List, cast
from tox.config.loader.str_convert import StrConvert
from tox.config.types import EnvList
from tox.report import HandledError
from tox.tox_env.api import ToxEnvCreateArgs
from tox.tox_env.errors import Skip
from tox.tox_env.package import PackageToxEnv
from tox.tox_env.register import REGISTER
from tox.tox_env.runner import RunToxEnv
if TYPE_CHECKING:
from argparse import ArgumentParser
from tox.session.state import State
LOGGER = logging.getLogger(__name__)
class CliEnv: # noqa: PLW1641
"""A `CliEnv` is the user's selection of tox test environments, usually supplied via the ``-e`` command-line option
or in a TOML file (typically ``env_list`` in ``tox.ini``). It may be treated as a sequence if it's not a "default"
or "all" selection.
It is in one of three forms:
- A list of specific environments, instantiated with a string that is a comma-separated list of the environment
names. (These may have spaces on either side of the commas which are removed.) As a sequence this will be a
sequence of those names.
- "ALL" which is all environments defined by the tox configuration. This is instantiated with ``ALL`` either
alone or as any element of a comma-separated list; any other environment names are ignored. `is_all()` will be
true and as a sequence it will be empty. This prints in string representation as ``ALL``.
- The default environments as chosen by tox configuration. This is instantiated with `None` as the parameter,
`is_default_list()` will be true, and as a sequence this will be empty. This prints in string representation
as ````.
"""
def __init__(self, value: None | list[str] | str = None) -> None:
if isinstance(value, str):
value = StrConvert().to(value, of_type=List[str], factory=None)
self._names: list[str] | None = value
def __iter__(self) -> Iterator[str]:
if not self.is_all and self._names is not None: # pragma: no branch
yield from self._names
def __bool__(self) -> bool:
"""A `CliEnv` is `True` if it's not the default set of environments."""
return bool(self._names)
def __str__(self) -> str:
return "ALL" if self.is_all else ("" if self.is_default_list else ",".join(self))
def __repr__(self) -> str:
return f"{self.__class__.__name__}({'' if self.is_default_list else repr(str(self))})"
def __eq__(self, other: object) -> bool:
return type(self) == type(other) and self._names == other._names # type: ignore[attr-defined]
def __ne__(self, other: object) -> bool:
return not (self == other)
@property
def is_all(self) -> bool:
return self._names is not None and "ALL" in self._names
@property
def is_default_list(self) -> bool:
return not (self._names or [])
def register_env_select_flags(
parser: ArgumentParser,
default: CliEnv | None,
multiple: bool = True, # noqa: FBT001, FBT002
group_only: bool = False, # noqa: FBT001, FBT002
) -> ArgumentParser:
"""
Register environment selection flags.
:param parser: the parser to register to
:param default: the default value for env selection
:param multiple: allow selecting multiple environments
:param group_only:
:return:
"""
if multiple:
group = parser.add_argument_group("select target environment(s)")
add_to: ArgumentParser = group.add_mutually_exclusive_group(required=False) # type: ignore[assignment]
else:
add_to = parser
if not group_only:
if multiple:
help_msg = "enumerate (ALL -> all environments, not set -> use from config)"
else:
help_msg = "environment to run"
add_to.add_argument("-e", dest="env", help=help_msg, default=default, type=CliEnv)
if multiple:
help_msg = "labels to evaluate"
add_to.add_argument("-m", dest="labels", metavar="label", help=help_msg, default=[], type=str, nargs="+")
help_msg = (
"factors to evaluate (passing multiple factors means 'AND', passing this option multiple times means 'OR')"
)
add_to.add_argument(
"-f",
dest="factors",
metavar="factor",
help=help_msg,
default=[],
type=str,
nargs="+",
action="append",
)
help_msg = "exclude all environments selected that match this regular expression"
add_to.add_argument("--skip-env", dest="skip_env", metavar="re", help=help_msg, default="", type=str)
return add_to
@dataclass
class _ToxEnvInfo:
"""tox environment information."""
env: PackageToxEnv | RunToxEnv #: the tox environment
is_active: bool #: a flag indicating if the environment is marked as active in the current run
package_skip: tuple[str, Skip] | None = None #: if set the creation of the packaging environment failed
_DYNAMIC_ENV_FACTORS = re.compile(r"(pypy|py|cython|)((\d(\.\d+(\.\d+)?)?)|\d+)?")
_PY_PRE_RELEASE_FACTOR = re.compile(r"alpha|beta|rc\.\d+")
class EnvSelector:
def __init__(self, state: State) -> None:
# needs core to load the default tox environment list
# to load the package environments of a run environments we need the run environment builder
# to load labels we need core + the run environment
self.on_empty_fallback_py = True
self._warned_about: set[str] = set() #: shared set of skipped environments that were already warned about
self._state = state
self._defined_envs_: None | dict[str, _ToxEnvInfo] = None
self._pkg_env_counter: Counter[str] = Counter()
from tox.plugin.manager import MANAGER # noqa: PLC0415
self._manager = MANAGER
self._log_handler = self._state._options.log_handler # noqa: SLF001
self._journal = self._state._journal # noqa: SLF001
self._provision: None | tuple[bool, str] = None
self._state.conf.core.add_config("labels", Dict[str, EnvList], {}, "core labels")
tox_env_filter_regex = getattr(state.conf.options, "skip_env", "").strip()
self._filter_re = re.compile(tox_env_filter_regex) if tox_env_filter_regex else None
@property
def _cli_envs(self) -> CliEnv | None:
return getattr(self._state.conf.options, "env", None)
def _collect_names(self) -> Iterator[tuple[Iterable[str], bool]]:
""":return: sources of tox environments defined with name and if is marked as target to run"""
if self._provision is not None: # pragma: no branch
yield (self._provision[1],), False
env_list, everything_active = self._state.conf.core["env_list"], False
if self._cli_envs is None or self._cli_envs.is_default_list:
yield env_list, True
elif self._cli_envs.is_all:
everything_active = True
else:
self._ensure_envs_valid()
yield self._cli_envs, True
yield self._state.conf, everything_active
label_envs = dict.fromkeys(chain.from_iterable(self._state.conf.core["labels"].values()))
if label_envs:
yield label_envs.keys(), False
def _ensure_envs_valid(self) -> None:
valid_factors = set(chain.from_iterable(env.split("-") for env in self._state.conf))
valid_factors.add(".pkg") # packaging factor
invalid_envs: dict[str, str | None] = {}
for env in self._cli_envs or []:
if env.startswith(".pkg_external"): # external package
continue
factors: dict[str, str | None] = dict.fromkeys(env.split("-"))
found_factors: set[str] = set()
for factor in factors:
if (
_DYNAMIC_ENV_FACTORS.fullmatch(factor)
or _PY_PRE_RELEASE_FACTOR.fullmatch(factor)
or factor in valid_factors
):
found_factors.add(factor)
else:
closest = get_close_matches(factor, valid_factors, n=1)
factors[factor] = closest[0] if closest else None
if set(factors) - found_factors:
invalid_envs[env] = (
None
if any(i is None for i in factors.values())
else "-".join(cast(Iterable[str], factors.values()))
)
if invalid_envs:
msg = "provided environments not found in configuration file:\n"
first = True
for env, suggestion in invalid_envs.items():
if not first:
msg += "\n"
first = False
msg += env
if suggestion:
msg += f" - did you mean {suggestion}?"
raise HandledError(msg)
def _env_name_to_active(self) -> dict[str, bool]:
env_name_to_active_map = {}
for a_collection, is_active in self._collect_names():
for name in a_collection:
if name not in env_name_to_active_map:
env_name_to_active_map[name] = is_active
# for factor/label selection update the active flag
if (
not (getattr(self._state.conf.options, "labels", []) or getattr(self._state.conf.options, "factors", []))
# if no active environment is defined fallback to py
and self.on_empty_fallback_py
and not any(env_name_to_active_map.values())
):
env_name_to_active_map["py"] = True
return env_name_to_active_map
@property
def _defined_envs(self) -> dict[str, _ToxEnvInfo]: # noqa: C901, PLR0912
# The problem of classifying run/package environments:
# There can be two type of tox environments: run or package. Given a tox environment name there's no easy way to
# find out which it is. Intuitively a run environment is any environment that's not used for packaging by
# another run environment. To find out what are the packaging environments for a run environment you have to
# first construct it. This implies a two phase solution: construct all environments and query their packaging
# environments. The run environments are the ones not marked as of packaging type. This requires being able
# to change tox environments type, if it was earlier discovered as a run environment and is marked as packaging
# we need to redefine it, e.g. when it shows up in config as [testenv:.package] and afterwards by a run env is
# marked as package_env.
if self._defined_envs_ is None: # noqa: PLR1702
self._defined_envs_ = {}
failed: dict[str, Exception] = {}
env_name_to_active = self._env_name_to_active()
for name, is_active in env_name_to_active.items():
if name in self._pkg_env_counter: # already marked as packaging, nothing to do here
continue
with self._log_handler.with_context(name):
run_env = self._build_run_env(name)
if run_env is None:
continue
self._defined_envs_[name] = _ToxEnvInfo(run_env, is_active)
pkg_name_type = run_env.get_package_env_types()
if pkg_name_type is not None:
# build package env and assign it, then register the run environment which can trigger generation
# of additional run environments
start_package_env_use_counter = self._pkg_env_counter.copy()
try:
run_env.package_env = self._build_pkg_env(pkg_name_type, name, env_name_to_active)
except Exception as exception: # noqa: BLE001
# if it's not a run environment, wait to see if ends up being a packaging one -> rollback
failed[name] = exception
for key in self._pkg_env_counter - start_package_env_use_counter:
del self._defined_envs_[key]
self._state.conf.clear_env(key)
self._pkg_env_counter = start_package_env_use_counter
del self._defined_envs_[name]
self._state.conf.clear_env(name)
else:
try:
for env in run_env.package_envs:
# check if any packaging envs are already run and remove them
other_env_info = self._defined_envs_.get(env.name)
if other_env_info is not None and isinstance(other_env_info.env, RunToxEnv):
del self._defined_envs_[env.name] # pragma: no cover
for _pkg_env in other_env_info.env.package_envs: # pragma: no cover
self._pkg_env_counter[_pkg_env.name] -= 1 # pragma: no cover
except Exception: # noqa: BLE001
assert self._defined_envs_[name].package_skip is not None # noqa: S101
failed_to_create = failed.keys() - self._defined_envs_.keys()
if failed_to_create:
raise failed[next(iter(failed_to_create))]
for name, count in self._pkg_env_counter.items():
if not count:
self._defined_envs_.pop(name) # pragma: no cover
# reorder to as defined rather as found
order = chain(env_name_to_active, (i for i in self._defined_envs_ if i not in env_name_to_active))
self._defined_envs_ = {name: self._defined_envs_[name] for name in order if name in self._defined_envs_}
self._finalize_config()
self._mark_active()
return self._defined_envs_
def _finalize_config(self) -> None:
assert self._defined_envs_ is not None # noqa: S101
for tox_env in self._defined_envs_.values():
tox_env.env.conf.mark_finalized()
self._state.conf.core.mark_finalized()
def _build_run_env(self, name: str) -> RunToxEnv | None:
if self._provision is not None and self._provision[0] is False and name == self._provision[1]:
# ignore provision env unless this is a provision run
return None
if self._provision is not None and self._provision[0] and name != self._provision[1]:
# ignore other envs when this is a provision run
return None
env_conf = self._state.conf.get_env(name, package=False)
desc = "the tox execute used to evaluate this environment"
env_conf.add_config(keys="runner", desc=desc, of_type=str, default=self._state.conf.options.default_runner)
runner = REGISTER.runner(cast(str, env_conf["runner"]))
journal = self._journal.get_env_journal(name)
args = ToxEnvCreateArgs(env_conf, self._state.conf.core, self._state.conf.options, journal, self._log_handler)
run_env = runner(args)
self._manager.tox_add_env_config(env_conf, self._state)
return run_env
def _build_pkg_env(self, name_type: tuple[str, str], run_env_name: str, active: dict[str, bool]) -> PackageToxEnv:
name, core_type = name_type
with self._log_handler.with_context(name):
if run_env_name == name:
msg = f"{run_env_name} cannot self-package"
raise HandledError(msg)
missing_active = self._cli_envs is not None and self._cli_envs.is_all
try:
package_tox_env = self._get_package_env(core_type, name, active.get(name, missing_active))
self._pkg_env_counter[name] += 1
run_env: RunToxEnv = self._defined_envs_[run_env_name].env # type: ignore[index,assignment]
child_package_envs = package_tox_env.register_run_env(run_env)
try:
name_type = next(child_package_envs)
while True:
child_pkg_env = self._build_pkg_env(name_type, run_env_name, active)
self._pkg_env_counter[name_type[0]] += 1
name_type = child_package_envs.send(child_pkg_env)
except StopIteration:
pass
except Skip as exception:
assert self._defined_envs_ is not None # noqa: S101
self._defined_envs_[run_env_name].package_skip = (name_type[0], exception)
return package_tox_env
def _get_package_env(self, packager: str, name: str, is_active: bool) -> PackageToxEnv: # noqa: FBT001
assert self._defined_envs_ is not None # noqa: S101
if name in self._defined_envs_:
env = self._defined_envs_[name].env
if isinstance(env, PackageToxEnv):
if env.id() != packager: # pragma: no branch # same env name is used by different packaging
msg = f"{name} is already defined as a {env.id()}, cannot be {packager} too" # pragma: no cover
raise HandledError(msg) # pragma: no cover
return env
self._state.conf.clear_env(name)
package_type = REGISTER.package(packager)
pkg_conf = self._state.conf.get_env(name, package=True)
journal = self._journal.get_env_journal(name)
args = ToxEnvCreateArgs(pkg_conf, self._state.conf.core, self._state.conf.options, journal, self._log_handler)
pkg_env: PackageToxEnv = package_type(args)
self._defined_envs_[name] = _ToxEnvInfo(pkg_env, is_active)
self._manager.tox_add_env_config(pkg_conf, self._state)
return pkg_env
def _parse_factors(self) -> tuple[set[str], ...]:
# factors is a list of lists, from the combination of nargs="+" and action="append"
# also parse hyphenated factors into lists of factors
# so that `-f foo-bar` and `-f foo bar` are treated equivalently
raw_factors = getattr(self._state.conf.options, "factors", [])
return tuple({f for factor in factor_list for f in factor.split("-")} for factor_list in raw_factors)
def _mark_active(self) -> None: # noqa: C901
labels = set(getattr(self._state.conf.options, "labels", []))
factors = self._parse_factors()
assert self._defined_envs_ is not None # noqa: S101
if labels or factors:
for env_info in self._defined_envs_.values():
env_info.is_active = False # if any was selected reset
# ignore labels when provisioning will occur
if labels and (self._provision is None or not self._provision[0]):
for label in labels:
for env_name in self._state.conf.core["labels"].get(label, []):
self._defined_envs_[env_name].is_active = True
for env_info in self._defined_envs_.values():
if labels.intersection(env_info.env.conf["labels"]):
env_info.is_active = True
if factors: # if matches mark it active
for name, env_info in self._defined_envs_.items():
for factor_set in factors:
if factor_set.issubset(set(name.split("-"))):
env_info.is_active = True
break
def __getitem__(self, item: str) -> RunToxEnv | PackageToxEnv:
"""
:param item: the name of the environment
:return: the tox environment
"""
return self._defined_envs[item].env
def iter(
self,
*,
only_active: bool = True,
package: bool = False,
) -> Iterator[str]:
"""
Get tox environments.
:param only_active: active environments are marked to be executed in the current target
:param package: return package environments
:return: an iteration of tox environments
"""
for name, env_info in self._defined_envs.items():
if only_active and not env_info.is_active:
continue
if not package and not isinstance(env_info.env, RunToxEnv):
continue
if self._filter_re is not None and self._filter_re.match(name):
if name not in self._warned_about:
self._warned_about.add(name)
LOGGER.warning("skip environment %s, matches filter %r", name, self._filter_re.pattern)
continue
yield name
def ensure_only_run_env_is_active(self) -> None:
envs, active = self._defined_envs, self._env_name_to_active()
invalid = [n for n, a in active.items() if a and isinstance(envs[n].env, PackageToxEnv)]
if invalid:
msg = f"cannot run packaging environment(s) {','.join(invalid)}"
raise HandledError(msg)
def _mark_provision(self, on: bool, provision_tox_env: str) -> None: # noqa: FBT001
self._provision = on, provision_tox_env
__all__ = [
"CliEnv",
"EnvSelector",
"register_env_select_flags",
]
tox-4.13.0/src/tox/session/state.py 0000664 0000000 0000000 00000002474 14564001166 0017201 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING, Sequence
from tox.config.main import Config
from tox.journal import Journal
from tox.plugin import impl
from .env_select import EnvSelector
if TYPE_CHECKING:
from tox.config.cli.parse import Options
from tox.config.cli.parser import ToxParser
class State:
"""Runtime state holder."""
def __init__(self, options: Options, args: Sequence[str]) -> None:
self.conf = Config.make(options.parsed, options.pos_args, options.source)
self._options = options
self.args = args
self._journal: Journal = Journal(getattr(options.parsed, "result_json", None) is not None)
self._selector: EnvSelector | None = None
@property
def envs(self) -> EnvSelector:
""":return: provides access to the tox environments"""
if self._selector is None:
self._selector = EnvSelector(self)
return self._selector
@impl
def tox_add_option(parser: ToxParser) -> None:
from tox.tox_env.register import REGISTER # noqa: PLC0415
parser.add_argument(
"--runner",
dest="default_runner",
help="the tox run engine to use when not explicitly stated in tox env configuration",
default=REGISTER.default_env_runner,
choices=list(REGISTER.env_runners),
)
tox-4.13.0/src/tox/tox_env/ 0000775 0000000 0000000 00000000000 14564001166 0015477 5 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/tox_env/__init__.py 0000664 0000000 0000000 00000000154 14564001166 0017610 0 ustar 00root root 0000000 0000000 """Package handling the creation and management of tox environments."""
from __future__ import annotations
tox-4.13.0/src/tox/tox_env/api.py 0000664 0000000 0000000 00000047664 14564001166 0016643 0 ustar 00root root 0000000 0000000 """Defines the abstract base traits of a tox environment."""
from __future__ import annotations
import fnmatch
import logging
import os
import re
import string
import sys
from abc import ABC, abstractmethod
from contextlib import contextmanager
from io import BytesIO
from pathlib import Path
from typing import TYPE_CHECKING, Any, Iterator, List, NamedTuple, Sequence, Set, cast
from tox.execute.request import ExecuteRequest
from tox.tox_env.errors import Fail, Recreate, Skip
from tox.tox_env.info import Info
from tox.util.path import ensure_empty_dir
if TYPE_CHECKING:
from tox.config.cli.parser import Parsed
from tox.config.main import Config
from tox.config.set_env import SetEnv
from tox.config.sets import CoreConfigSet, EnvConfigSet
from tox.execute.api import Execute, ExecuteStatus, Outcome, StdinSource
from tox.journal import EnvJournal
from tox.report import OutErr, ToxHandler
from tox.tox_env.installer import Installer
LOGGER = logging.getLogger(__name__)
class ToxEnvCreateArgs(NamedTuple):
"""Arguments to pass on when creating a tox environment."""
conf: EnvConfigSet
core: CoreConfigSet
options: Parsed
journal: EnvJournal
log_handler: ToxHandler
class ToxEnv(ABC):
"""A tox environment."""
def __init__(self, create_args: ToxEnvCreateArgs) -> None:
"""
Create a new tox environment.
:param create_args: tox env create args
"""
self.journal: EnvJournal = create_args.journal #: handler to the tox reporting system
self.conf: EnvConfigSet = create_args.conf #: the config set to use for this environment
self.core: CoreConfigSet = create_args.core #: the core tox config set
self.options: Parsed = create_args.options #: CLI options
self.log_handler: ToxHandler = create_args.log_handler #: handler to the tox reporting system
#: encode the run state of various methods (setup/clean/etc)
self._run_state = {"setup": False, "clean": False, "teardown": False}
self._paths_private: list[Path] = [] #: a property holding the PATH environment variables
self._hidden_outcomes: list[Outcome] | None = []
self._env_vars: dict[str, str] | None = None
self._env_vars_pass_env: list[str] = []
self._suspended_out_err: OutErr | None = None
self._execute_statuses: dict[int, ExecuteStatus] = {}
self._interrupted = False
self._log_id = 0
self.register_config()
@property
def cache(self) -> Info:
return Info(self.env_dir)
@staticmethod
@abstractmethod
def id() -> str:
raise NotImplementedError
@property
@abstractmethod
def executor(self) -> Execute:
raise NotImplementedError
@property
@abstractmethod
def installer(self) -> Installer[Any]:
raise NotImplementedError
def _install(self, arguments: Any, section: str, of_type: str) -> None:
from tox.plugin.manager import MANAGER # noqa: PLC0415
MANAGER.tox_on_install(self, arguments, section, of_type)
self.installer.install(arguments, section, of_type)
def __repr__(self) -> str:
return f"{self.__class__.__name__}(name={self.conf['env_name']})"
def register_config(self) -> None:
self.conf.add_constant(
keys=["env_name", "envname"],
desc="the name of the tox environment",
value=self.conf.name,
)
self.conf.add_config(
keys=["labels"],
of_type=Set[str],
default=set(),
desc="labels attached to the tox environment",
)
self.conf.add_config(
keys=["env_dir", "envdir"],
of_type=Path,
default=lambda conf, name: cast(Path, conf.core["work_dir"]) / self.name, # noqa: ARG005
desc="directory assigned to the tox environment",
)
self.conf.add_config(
keys=["env_tmp_dir", "envtmpdir"],
of_type=Path,
default=lambda conf, name: cast(Path, conf.core["work_dir"]) / self.name / "tmp", # noqa: ARG005
desc="a folder that is always reset at the start of the run",
)
self.conf.add_config(
keys=["env_log_dir", "envlogdir"],
of_type=Path,
default=lambda conf, name: cast(Path, conf.core["work_dir"]) / self.name / "log", # noqa: ARG005
desc="a folder for logging where tox will put logs of tool invocation",
)
self.executor.register_conf(self)
self.conf.default_set_env_loader = self._default_set_env
self.conf.add_config(
keys=["platform"],
of_type=str,
default="",
desc="run on platforms that match this regular expression (empty means any platform)",
)
def pass_env_post_process(values: list[str]) -> list[str]:
values.extend(self._default_pass_env())
result = sorted(dict.fromkeys(values).keys())
invalid_chars = set(string.whitespace)
invalid = [v for v in result if any(c in invalid_chars for c in v)]
if invalid:
invalid_repr = ", ".join(repr(i) for i in invalid)
msg = (
f"pass_env values cannot contain whitespace, use comma to have multiple values in a single line,"
f" invalid values found {invalid_repr}"
)
raise Fail(msg)
return result
self.conf.add_config(
keys=["pass_env", "passenv"],
of_type=List[str],
default=[],
desc="environment variables to pass on to the tox environment",
post_process=pass_env_post_process,
)
self.conf.add_config(
"parallel_show_output",
of_type=bool,
default=False,
desc="if set to True the content of the output will always be shown when running in parallel mode",
)
self.conf.add_config(
"recreate",
of_type=bool,
default=self._recreate_default,
desc="always recreate virtual environment if this option is true, otherwise leave it up to tox",
)
self.conf.add_config(
"allowlist_externals",
of_type=List[str],
default=[],
desc="external command glob to allow calling",
)
assert self.installer is not None # noqa: S101 # trigger installer creation to allow config registration
def _recreate_default(self, conf: Config, value: str | None) -> bool: # noqa: ARG002
return cast(bool, self.options.recreate)
@property
def env_dir(self) -> Path:
""":return: the tox environments environment folder"""
return cast(Path, self.conf["env_dir"])
@property
def env_tmp_dir(self) -> Path:
""":return: the tox environments temp folder"""
return cast(Path, self.conf["env_tmp_dir"])
@property
def env_log_dir(self) -> Path:
""":return: the tox environments log folder"""
return cast(Path, self.conf["env_log_dir"])
@property
def name(self) -> str:
return cast(str, self.conf["env_name"])
def _default_set_env(self) -> dict[str, str]: # noqa: PLR6301
return {}
def _default_pass_env(self) -> list[str]: # noqa: PLR6301
env = [
"https_proxy", # HTTP proxy configuration
"http_proxy", # HTTP proxy configuration
"no_proxy", # HTTP proxy configuration
"LANG", # localization
"LANGUAGE", # localization
"CURL_CA_BUNDLE", # curl certificates
"SSL_CERT_FILE", # https certificates
"CC", # C compiler command
"CFLAGS", # C compiler flags
"CCSHARED", # compiler flags used to build a shared library
"CXX", # C++ compiler command
"CPPFLAGS", # C++ compiler flags
"LD_LIBRARY_PATH", # location of libs
"LDFLAGS", # linker flags
"HOME", # needed for `os.path.expanduser()` on non-Windows systems
"FORCE_COLOR", # force color output
"NO_COLOR", # disable color output
]
if sys.stdout.isatty(): # if we're on a interactive shell pass on the TERM
env.append("TERM")
if sys.platform == "win32": # pragma: win32 cover
env.extend(
[
"TEMP", # temporary file location
"TMP", # temporary file location
"USERPROFILE", # needed for `os.path.expanduser()`
"PATHEXT", # needed for discovering executables
"MSYSTEM", # controls paths printed format
],
)
else: # pragma: win32 no cover
env.append("TMPDIR") # temporary file location
return env
def setup(self) -> None:
"""Setup the tox environment."""
if self._run_state["setup"] is False: # pragma: no branch
self._platform_check()
recreate = cast(bool, self.conf["recreate"])
if recreate:
self._clean(transitive=True)
try:
self._setup_env()
self._setup_with_env()
except Recreate as exception: # once we might try over
if not recreate: # pragma: no cover
logging.warning("recreate env because %s", exception.args[0])
self._clean(transitive=False)
self._setup_env()
self._setup_with_env()
else:
self._done_with_setup()
finally:
self._run_state["setup"] = True
def teardown(self) -> None:
if not self._run_state["teardown"]:
try:
self._teardown()
finally:
from tox.plugin.manager import MANAGER # noqa: PLC0415
MANAGER.tox_env_teardown(self)
self._run_state["teardown"] = True
def _teardown(self) -> None: # noqa: B027 # empty abstract base class
pass
def _platform_check(self) -> None:
"""Skip env when platform does not match."""
platform_str: str = self.conf["platform"]
if platform_str:
match = re.fullmatch(platform_str, self.runs_on_platform)
if match is None:
msg = f"platform {self.runs_on_platform} does not match {platform_str}"
raise Skip(msg)
@property
@abstractmethod
def runs_on_platform(self) -> str:
raise NotImplementedError
def _setup_env(self) -> None:
"""
1. env dir exists
2. contains a runner with the same type.
"""
conf = {"name": self.conf.name, "type": type(self).__name__}
with self.cache.compare(conf, ToxEnv.__name__) as (eq, old):
if eq is False and old is not None: # pragma: no branch # recreate if already created and not equals
msg = f"env type changed from {old} to {conf}"
raise Recreate(msg)
self._handle_env_tmp_dir()
self._handle_core_tmp_dir()
def _setup_with_env(self) -> None: # noqa: B027 # empty abstract base class
pass
def _done_with_setup(self) -> None: # noqa: B027 # empty abstract base class
"""Called when setup is done."""
def _handle_env_tmp_dir(self) -> None:
"""Ensure exists and empty."""
env_tmp_dir = self.env_tmp_dir
if env_tmp_dir.exists() and next(env_tmp_dir.iterdir(), None) is not None:
LOGGER.debug("clear env temp folder %s", env_tmp_dir)
ensure_empty_dir(env_tmp_dir)
env_tmp_dir.mkdir(parents=True, exist_ok=True)
def _handle_core_tmp_dir(self) -> None:
self.core["temp_dir"].mkdir(parents=True, exist_ok=True)
def _clean(self, transitive: bool = False) -> None: # noqa: ARG002, FBT001, FBT002
if self._run_state["clean"]: # pragma: no branch
return # pragma: no cover
env_dir = self.env_dir
if env_dir.exists():
LOGGER.warning("remove tox env folder %s", env_dir)
ensure_empty_dir(env_dir, except_filename="file.lock")
self._log_id = 0 # we deleted logs, so start over counter
self.cache.reset()
self._run_state.update({"setup": False, "clean": True})
@property
def environment_variables(self) -> dict[str, str]:
pass_env: list[str] = self.conf["pass_env"]
set_env: SetEnv = self.conf["set_env"]
if self._env_vars_pass_env == pass_env and not set_env.changed and self._env_vars is not None:
return self._env_vars
result = self._load_pass_env(pass_env)
# load/paths_env might trigger a load of the environment variables, set result here, returns current state
self._env_vars, self._env_vars_pass_env, set_env.changed = result, pass_env.copy(), False
# set PATH here in case setting and environment variable requires access to the environment variable PATH
result["PATH"] = self._make_path()
for key in set_env:
result[key] = set_env.load(key)
result["TOX_ENV_NAME"] = self.name
result["TOX_WORK_DIR"] = str(self.core["work_dir"])
result["TOX_ENV_DIR"] = str(self.conf["env_dir"])
return result
@staticmethod
def _load_pass_env(pass_env: list[str]) -> dict[str, str]:
patterns = [re.compile(fnmatch.translate(e), re.IGNORECASE) for e in pass_env]
result: dict[str, str] = {e: v for e, v in os.environ.items() if any(p.match(e) for p in patterns)}
return result
@property
def _paths(self) -> list[Path]:
return self._paths_private
@_paths.setter
def _paths(self, value: list[Path]) -> None:
self._paths_private = value
# also update the environment variable with the new value
if self._env_vars is not None: # pragma: no branch
# remove duplicates and prepend the tox env paths
result = self._make_path()
self._env_vars["PATH"] = result
@property
def _allow_externals(self) -> list[str]:
result: list[str] = [f"{i}{os.sep}*" for i in self._paths]
result.extend(i.strip() for i in self.conf["allowlist_externals"])
return result
def _make_path(self) -> str:
values = dict.fromkeys(str(i) for i in self._paths)
values.update(dict.fromkeys(os.environ.get("PATH", "").split(os.pathsep)))
return os.pathsep.join(values)
def execute( # noqa: PLR0913
self,
cmd: Sequence[Path | str],
stdin: StdinSource,
show: bool | None = None, # noqa: FBT001
cwd: Path | None = None,
run_id: str = "",
executor: Execute | None = None,
) -> Outcome:
with self.execute_async(cmd, stdin, show, cwd, run_id, executor) as status:
while status.wait() is None:
pass # pragma: no cover
if status.outcome is None: # pragma: no cover # this should not happen
raise RuntimeError # pragma: no cover
return status.outcome
def interrupt(self) -> None:
"""Interrupt the execution of a tox environment."""
logging.warning("interrupt tox environment: %s", self.conf.name)
self._interrupted = True
for status in list(self._execute_statuses.values()):
status.interrupt()
@contextmanager
def execute_async( # noqa: PLR0913
self,
cmd: Sequence[Path | str],
stdin: StdinSource,
show: bool | None = None, # noqa: FBT001
cwd: Path | None = None,
run_id: str = "",
executor: Execute | None = None,
) -> Iterator[ExecuteStatus]:
if self._interrupted:
raise SystemExit(-2) # pragma: no cover
if cwd is None:
cwd = self.core["tox_root"]
if show is None:
show = self.options.verbosity > 3 # noqa: PLR2004
request = ExecuteRequest(cmd, cwd, self.environment_variables, stdin, run_id, allow=self._allow_externals)
if request.cwd == _CWD:
repr_cwd = ""
else:
try:
repr_cwd = f" {_CWD.relative_to(cwd)}"
except ValueError:
repr_cwd = f" {cwd}"
LOGGER.warning("%s%s> %s", run_id, repr_cwd, request.shell_cmd)
out_err = self.log_handler.stdout, self.log_handler.stderr
if executor is None:
executor = self.executor
with self._execute_call(executor, out_err, request, show) as execute_status:
execute_id = id(execute_status)
try:
self._execute_statuses[execute_id] = execute_status
yield execute_status
finally:
self._execute_statuses.pop(execute_id)
if show and self._hidden_outcomes is not None and execute_status.outcome is not None:
# if it gets canceled before even starting
self._hidden_outcomes.append(execute_status.outcome)
if self.journal and execute_status.outcome is not None:
self.journal.add_execute(execute_status.outcome, run_id)
self._log_execute(request, execute_status)
def _log_execute(self, request: ExecuteRequest, status: ExecuteStatus) -> None:
if self._log_id == 0: # start with fresh slate on new run
ensure_empty_dir(self.env_log_dir)
self._log_id += 1
self._write_execute_log(self.name, self.env_log_dir / f"{self._log_id}-{request.run_id}.log", request, status)
@staticmethod
def _write_execute_log(env_name: str, log_file: Path, request: ExecuteRequest, status: ExecuteStatus) -> None:
with log_file.open("wt", encoding="utf-8") as file:
file.write(f"name: {env_name}\n")
file.write(f"run_id: {request.run_id}\n")
for env_key, env_value in request.env.items():
file.write(f"env {env_key}: {env_value}\n")
for meta_key, meta_value in status.metadata.items():
file.write(f"metadata {meta_key}: {meta_value}\n")
file.write(f"cwd: {request.cwd}\n")
allow = ["*"] if request.allow is None else request.allow
file.write(f"allow: {':'.join(allow)}\n")
file.write(f"cmd: {request.shell_cmd}\n")
file.write(f"exit_code: {status.exit_code}\n")
with log_file.open("ab") as file_b:
if status.out:
file_b.write(status.out)
if status.err: # pragma: no branch
file_b.write(os.linesep.encode())
file_b.write(b"standard error:")
file_b.write(os.linesep.encode())
file_b.write(status.err)
@contextmanager
def _execute_call(
self,
executor: Execute,
out_err: OutErr,
request: ExecuteRequest,
show: bool, # noqa: FBT001
) -> Iterator[ExecuteStatus]:
with executor.call(
request=request,
env=self,
show=show,
out_err=out_err,
) as execute_status:
yield execute_status
@contextmanager
def display_context(self, suspend: bool) -> Iterator[None]: # noqa: FBT001
with self._log_context(), self.log_handler.suspend_out_err(suspend, self._suspended_out_err) as out_err:
if suspend: # only set if suspended
self._suspended_out_err = out_err
yield
def close_and_read_out_err(self) -> tuple[bytes, bytes] | None:
if self._suspended_out_err is None: # pragma: no branch
return None # pragma: no cover
(out, err), self._suspended_out_err = self._suspended_out_err, None
out_b, err_b = cast(BytesIO, out.buffer).getvalue(), cast(BytesIO, err.buffer).getvalue()
out.close()
err.close()
return out_b, err_b
@contextmanager
def _log_context(self) -> Iterator[None]:
with self.log_handler.with_context(self.conf.name):
yield
@property
def _has_display_suspended(self) -> bool:
return self._suspended_out_err is not None
_CWD = Path.cwd()
tox-4.13.0/src/tox/tox_env/errors.py 0000664 0000000 0000000 00000000450 14564001166 0017364 0 ustar 00root root 0000000 0000000 """Defines tox error types."""
from __future__ import annotations
class Recreate(Exception): # noqa: N818
"""Recreate the tox environment."""
class Skip(Exception): # noqa: N818
"""Skip this tox environment."""
class Fail(Exception): # noqa: N818
"""Failed creating env."""
tox-4.13.0/src/tox/tox_env/info.py 0000664 0000000 0000000 00000004176 14564001166 0017014 0 ustar 00root root 0000000 0000000 """
Declare and handle the tox env info file (a file at the root of every tox environment that contains information about
the status of the tox environment - python version of the environment, installed packages, etc.).
"""
from __future__ import annotations
import json
from contextlib import contextmanager
from typing import TYPE_CHECKING, Any, Iterator
if TYPE_CHECKING:
from pathlib import Path
class Info:
"""Stores metadata about the tox environment."""
def __init__(self, path: Path) -> None:
self._path = path / ".tox-info.json"
try:
value = json.loads(self._path.read_text())
except (ValueError, OSError):
value = {}
self._content = value
def __repr__(self) -> str:
return f"{self.__class__.__name__}(path={self._path})"
@contextmanager
def compare(
self,
value: Any,
section: str,
sub_section: str | None = None,
) -> Iterator[tuple[bool, Any | None]]:
"""
Compare new information with the existing one and update if differs.
:param value: the value stored
:param section: the primary key of the information
:param sub_section: the secondary key of the information
:return: a tuple where the first value is if it differs and the second is the old value
"""
old = self._content.get(section)
if sub_section is not None and old is not None:
old = old.get(sub_section)
if old == value:
yield True, old
else:
yield False, old
# if no exception thrown update
if sub_section is None:
self._content[section] = value
elif self._content.get(section) is None:
self._content[section] = {sub_section: value}
else:
self._content[section][sub_section] = value
self._write()
def reset(self) -> None:
self._content = {}
def _write(self) -> None:
self._path.parent.mkdir(parents=True, exist_ok=True)
self._path.write_text(json.dumps(self._content, indent=2))
__all__ = ("Info",)
tox-4.13.0/src/tox/tox_env/installer.py 0000664 0000000 0000000 00000001437 14564001166 0020053 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING, Any, Generic, TypeVar
if TYPE_CHECKING:
from tox.tox_env.api import ToxEnv
T = TypeVar("T", bound="ToxEnv")
class Installer(ABC, Generic[T]):
def __init__(self, tox_env: T) -> None:
self._env = tox_env
self._register_config()
@abstractmethod
def _register_config(self) -> None:
"""Register configurations for the installer."""
raise NotImplementedError
@abstractmethod
def installed(self) -> Any:
""":returns: a list of packages installed (JSON dump-able)"""
raise NotImplementedError
@abstractmethod
def install(self, arguments: Any, section: str, of_type: str) -> None:
raise NotImplementedError
tox-4.13.0/src/tox/tox_env/package.py 0000664 0000000 0000000 00000007076 14564001166 0017456 0 ustar 00root root 0000000 0000000 """A tox environment that can build packages."""
from __future__ import annotations
from abc import ABC, abstractmethod
from pathlib import Path
from threading import RLock
from types import MethodType
from typing import TYPE_CHECKING, Any, Callable, Generator, Iterator, cast
from filelock import FileLock
from .api import ToxEnv, ToxEnvCreateArgs
if TYPE_CHECKING:
from tox.config.main import Config
from tox.config.sets import EnvConfigSet
from .runner import RunToxEnv
class Package:
"""package."""
class PathPackage(Package):
def __init__(self, path: Path) -> None:
super().__init__()
self.path = path
def __str__(self) -> str:
return str(self.path)
locked = False
def _lock_method(thread_lock: RLock, file_lock: FileLock | None, meth: Callable[..., Any]) -> Callable[..., Any]:
def _func(*args: Any, **kwargs: Any) -> Any:
with thread_lock:
file_locks = False
if file_lock is not None and file_lock.is_locked is False: # file_lock is to lock from other tox processes
file_lock.acquire()
file_locks = True
try:
return meth(*args, **kwargs)
finally:
if file_locks:
cast(FileLock, file_lock).release()
return _func
class PackageToxEnv(ToxEnv, ABC):
def __init__(self, create_args: ToxEnvCreateArgs) -> None:
self._thread_lock = RLock()
self._file_lock: FileLock | None = None
super().__init__(create_args)
self._envs: set[str] = set()
def __getattribute__(self, name: str) -> Any:
# the packaging class might be used by multiple environments in parallel, hold a lock for operations on it
obj = object.__getattribute__(self, name)
if isinstance(obj, MethodType):
obj = _lock_method(self._thread_lock, self._file_lock, obj)
return obj
def register_config(self) -> None:
super().register_config()
file_lock_path: Path = self.conf["env_dir"] / "file.lock"
self._file_lock = FileLock(file_lock_path)
file_lock_path.parent.mkdir(parents=True, exist_ok=True)
self.core.add_config(
keys=["package_root", "setupdir"],
of_type=Path,
default=cast(Path, self.core["tox_root"]),
desc="indicates where the packaging root file exists (historically setup.py file or pyproject.toml now)",
)
self.conf.add_config(
keys=["package_root", "setupdir"],
of_type=Path,
default=cast(Path, self.core["package_root"]),
desc="indicates where the packaging root file exists (historically setup.py file or pyproject.toml now)",
)
def _recreate_default(self, conf: Config, value: str | None) -> bool:
return self.options.no_recreate_pkg is False and super()._recreate_default(conf, value)
@abstractmethod
def perform_packaging(self, for_env: EnvConfigSet) -> list[Package]:
raise NotImplementedError
def register_run_env(self, run_env: RunToxEnv) -> Generator[tuple[str, str], PackageToxEnv, None]: # noqa: ARG002, PLR6301
yield from () # empty generator by default
def mark_active_run_env(self, run_env: RunToxEnv) -> None:
self._envs.add(run_env.conf.name)
def teardown_env(self, conf: EnvConfigSet) -> None:
self._envs.remove(conf.name)
if len(self._envs) == 0:
self._teardown()
@abstractmethod
def child_pkg_envs(self, run_conf: EnvConfigSet) -> Iterator[PackageToxEnv]:
raise NotImplementedError
tox-4.13.0/src/tox/tox_env/python/ 0000775 0000000 0000000 00000000000 14564001166 0017020 5 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/tox_env/python/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0021117 0 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/tox_env/python/api.py 0000664 0000000 0000000 00000025430 14564001166 0020147 0 ustar 00root root 0000000 0000000 """Declare the abstract base class for tox environments that handle the Python language."""
from __future__ import annotations
import logging
import re
import sys
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING, Any, List, NamedTuple, cast
from virtualenv.discovery.py_spec import PythonSpec
from tox.tox_env.api import ToxEnv, ToxEnvCreateArgs
from tox.tox_env.errors import Fail, Recreate, Skip
if TYPE_CHECKING:
from pathlib import Path
from tox.config.main import Config
class VersionInfo(NamedTuple):
major: int
minor: int
micro: int
releaselevel: str
serial: int
class PythonInfo(NamedTuple):
implementation: str
version_info: VersionInfo
version: str
is_64: bool
platform: str
extra: dict[str, Any]
@property
def version_no_dot(self) -> str:
return f"{self.version_info.major}{self.version_info.minor}"
@property
def impl_lower(self) -> str:
return self.implementation.lower()
@property
def version_dot(self) -> str:
return f"{self.version_info.major}.{self.version_info.minor}"
PY_FACTORS_RE = re.compile(
r"""
^(?!py$) # don't match 'py' as it doesn't provide any info
(?Ppy|pypy|cpython|jython|rustpython|ironpython) # the interpreter; most users will simply use 'py'
(?P[2-9]\.?[0-9]?[0-9]?)?$ # the version; one of: MAJORMINOR, MAJOR.MINOR
""",
re.VERBOSE,
)
class Python(ToxEnv, ABC):
def __init__(self, create_args: ToxEnvCreateArgs) -> None:
self._base_python: PythonInfo | None = None
self._base_python_searched: bool = False
super().__init__(create_args)
def register_config(self) -> None:
super().register_config()
def validate_base_python(value: list[str]) -> list[str]:
return self._validate_base_python(self.name, value, self.core["ignore_base_python_conflict"])
self.conf.add_config(
keys=["base_python", "basepython"],
of_type=List[str],
default=self.default_base_python,
desc="environment identifier for python, first one found wins",
post_process=validate_base_python,
)
self.core.add_config(
keys=["ignore_base_python_conflict", "ignore_basepython_conflict"],
of_type=bool,
default=False,
desc="do not raise error if the environment name conflicts with base python",
)
self.conf.add_constant(
keys=["env_site_packages_dir", "envsitepackagesdir"],
desc="the python environments site package",
value=self.env_site_package_dir,
)
self.conf.add_constant(
keys=["env_bin_dir", "envbindir"],
desc="the python environments binary folder",
value=self.env_bin_dir,
)
self.conf.add_constant(
["env_python", "envpython"],
desc="python executable from within the tox environment",
value=self.env_python,
)
self.conf.add_constant("py_dot_ver", ".", value=self.py_dot_ver)
self.conf.add_constant("py_impl", "python implementation", value=self.py_impl)
def _default_set_env(self) -> dict[str, str]:
env = super()._default_set_env()
hash_seed: int | None = getattr(self.options, "hash_seed", None)
if hash_seed is not None:
env["PYTHONHASHSEED"] = str(hash_seed)
return env
def py_dot_ver(self) -> str:
return self.base_python.version_dot
def py_impl(self) -> str:
return self.base_python.impl_lower
def _default_pass_env(self) -> list[str]:
env = super()._default_pass_env()
if sys.platform == "win32": # pragma: win32 cover
env.extend(
[
"APPDATA", # Needed for PIP platformsdirs.windows
"PROGRAMDATA", # needed for discovering the VS compiler
"PROGRAMFILES(x86)", # needed for discovering the VS compiler
"PROGRAMFILES", # needed for discovering the VS compiler
"SYSTEMDRIVE",
"SYSTEMROOT", # needed for python's crypto module
"COMSPEC", # needed for distutils cygwin compiler
"PROCESSOR_ARCHITECTURE", # platform.machine()
"NUMBER_OF_PROCESSORS", # multiprocessing.cpu_count()
],
)
binary_extension_build = ["PKG_CONFIG", "PKG_CONFIG_PATH", "PKG_CONFIG_SYSROOT_DIR"]
env.extend(binary_extension_build) # used by binary extensions during installation
env.extend(["REQUESTS_CA_BUNDLE"])
return env
def default_base_python(self, conf: Config, env_name: str | None) -> list[str]: # noqa: ARG002
base_python = None if env_name is None else self.extract_base_python(env_name)
return [sys.executable if base_python is None else base_python]
@classmethod
def extract_base_python(cls, env_name: str) -> str | None:
candidates: list[str] = []
for factor in env_name.split("-"):
match = PY_FACTORS_RE.match(factor)
if match:
candidates.append(factor)
if candidates:
if len(candidates) > 1:
msg = f"conflicting factors {', '.join(candidates)} in {env_name}"
raise ValueError(msg)
return next(iter(candidates))
return None
@classmethod
def _validate_base_python(
cls,
env_name: str,
base_pythons: list[str],
ignore_base_python_conflict: bool, # noqa: FBT001
) -> list[str]:
env_base_python = cls.extract_base_python(env_name)
if env_base_python is not None:
spec_name = PythonSpec.from_string_spec(env_base_python)
for base_python in base_pythons:
spec_base = PythonSpec.from_string_spec(base_python)
if any(
getattr(spec_base, key) != getattr(spec_name, key)
for key in ("implementation", "major", "minor", "micro", "architecture")
if getattr(spec_name, key) is not None
):
msg = f"env name {env_name} conflicting with base python {base_python}"
if ignore_base_python_conflict:
# ignore the base python settings and return the thing that looks like a Python version
return [env_base_python]
raise Fail(msg)
return base_pythons
@abstractmethod
def env_site_package_dir(self) -> Path:
"""
If we have the python we just need to look at the last path under prefix.
E.g., Debian derivatives change the site-packages to dist-packages, so we need to fix it for site-packages.
"""
raise NotImplementedError
@abstractmethod
def env_python(self) -> Path:
"""The python executable within the tox environment."""
raise NotImplementedError
@abstractmethod
def env_bin_dir(self) -> Path:
"""The binary folder within the tox environment."""
raise NotImplementedError
def _setup_env(self) -> None:
"""Setup a virtual python environment."""
super()._setup_env()
self.ensure_python_env()
self._paths = self.prepend_env_var_path() # now that the environment exist we can add them to the path
def ensure_python_env(self) -> None:
conf = self.python_cache()
with self.cache.compare(conf, Python.__name__) as (eq, old):
if old is None: # does not exist -> create
self.create_python_env()
elif eq is False: # pragma: no branch # exists but changed -> recreate
raise Recreate(self._diff_msg(conf, old))
@staticmethod
def _diff_msg(conf: dict[str, Any], old: dict[str, Any]) -> str:
result: list[str] = []
added = [f"{k}={v!r}" for k, v in conf.items() if k not in old]
if added: # pragma: no branch
result.append(f"added {' | '.join(added)}")
removed = [f"{k}={v!r}" for k, v in old.items() if k not in conf]
if removed:
result.append(f"removed {' | '.join(removed)}")
changed = [f"{k}={old[k]!r}->{v!r}" for k, v in conf.items() if k in old and v != old[k]]
if changed:
result.append(f"changed {' | '.join(changed)}")
return f'python {", ".join(result)}'
@abstractmethod
def prepend_env_var_path(self) -> list[Path]:
raise NotImplementedError
def _done_with_setup(self) -> None:
"""Called when setup is done."""
super()._done_with_setup()
if self.journal or self.options.list_dependencies:
outcome = self.installer.installed()
if self.journal:
self.journal["installed_packages"] = outcome
if self.options.list_dependencies:
logging.warning(",".join(outcome))
def python_cache(self) -> dict[str, Any]:
return {
"version_info": list(self.base_python.version_info),
}
@property
def base_python(self) -> PythonInfo:
"""Resolve base python."""
base_pythons: list[str] = self.conf["base_python"]
if self._base_python_searched is False:
self._base_python_searched = True
self._base_python = self._get_python(base_pythons)
if self._base_python is not None and self.journal:
value = self._get_env_journal_python()
self.journal["python"] = value
if self._base_python is None:
if self.core["skip_missing_interpreters"]:
msg = f"could not find python interpreter with spec(s): {', '.join(base_pythons)}"
raise Skip(msg)
raise NoInterpreter(base_pythons)
return cast(PythonInfo, self._base_python)
def _get_env_journal_python(self) -> dict[str, Any]:
return {
"implementation": self.base_python.implementation,
"version_info": tuple(self.base_python.version_info),
"version": self.base_python.version,
"is_64": self.base_python.is_64,
"sysplatform": self.base_python.platform,
"extra_version_info": None,
}
@abstractmethod
def _get_python(self, base_python: list[str]) -> PythonInfo | None:
raise NotImplementedError
@abstractmethod
def create_python_env(self) -> None:
raise NotImplementedError
class NoInterpreter(Fail):
"""could not find interpreter."""
def __init__(self, base_pythons: list[str]) -> None:
self.base_pythons = base_pythons
def __str__(self) -> str:
return f"could not find python interpreter matching any of the specs {', '.join(self.base_pythons)}"
tox-4.13.0/src/tox/tox_env/python/package.py 0000664 0000000 0000000 00000011540 14564001166 0020766 0 ustar 00root root 0000000 0000000 """A tox build environment that handles Python packages."""
from __future__ import annotations
from abc import ABC, abstractmethod
from typing import TYPE_CHECKING, Any, Generator, Iterator, List, Sequence, cast
from packaging.requirements import Requirement
from tox.tox_env.errors import Skip
from tox.tox_env.package import Package, PackageToxEnv, PathPackage
from .api import NoInterpreter, Python
if TYPE_CHECKING:
from pathlib import Path
from tox.config.main import Config
from tox.config.sets import EnvConfigSet
from tox.tox_env.api import ToxEnvCreateArgs
from tox.tox_env.runner import RunToxEnv
from .pip.req_file import PythonDeps
class PythonPackage(Package):
"""python package."""
class PythonPathPackageWithDeps(PathPackage):
def __init__(self, path: Path, deps: Sequence[Any]) -> None:
super().__init__(path=path)
self.deps: Sequence[Package] = deps
class WheelPackage(PythonPathPackageWithDeps):
"""wheel package."""
class SdistPackage(PythonPathPackageWithDeps):
"""sdist package."""
class EditableLegacyPackage(PythonPathPackageWithDeps):
"""legacy editable package."""
class EditablePackage(PythonPathPackageWithDeps):
"""PEP-660 editable package."""
class PythonPackageToxEnv(Python, PackageToxEnv, ABC):
def __init__(self, create_args: ToxEnvCreateArgs) -> None:
self._wheel_build_envs: dict[str, PythonPackageToxEnv] = {}
super().__init__(create_args)
def _setup_env(self) -> None:
"""Setup the tox environment."""
super()._setup_env()
self._install(self.requires(), PythonPackageToxEnv.__name__, "requires")
self._install(self.conf["deps"], PythonPackageToxEnv.__name__, "deps")
@abstractmethod
def requires(self) -> tuple[Requirement, ...] | PythonDeps:
raise NotImplementedError
def register_run_env(self, run_env: RunToxEnv) -> Generator[tuple[str, str], PackageToxEnv, None]:
yield from super().register_run_env(run_env)
if run_env.conf["package"] != "skip" and "deps" not in self.conf:
self.conf.add_config(
keys="deps",
of_type=List[Requirement],
default=[],
desc="Name of the python dependencies as specified by PEP-440",
)
if (
not isinstance(run_env, Python)
or run_env.conf["package"] not in {"wheel", "editable"}
or "wheel_build_env" in run_env.conf
):
return
def default_wheel_tag(conf: Config, env_name: str | None) -> str: # noqa: ARG001
# https://www.python.org/dev/peps/pep-0427/#file-name-convention
# when building wheels we need to ensure that the built package is compatible with the target env
# compatibility is documented within https://www.python.org/dev/peps/pep-0427/#file-name-convention
# a wheel tag example: {distribution}-{version}(-{build tag})?-{python tag}-{abi tag}-{platform tag}.whl
# python only code are often compatible at major level (unless universal wheel in which case both 2/3)
# c-extension codes are trickier, but as of today both poetry/setuptools uses pypa/wheels logic
# https://github.com/pypa/wheel/blob/master/src/wheel/bdist_wheel.py#L234-L280
try:
run_py = cast(Python, run_env).base_python
except NoInterpreter:
run_py = None
if run_py is None:
base = ",".join(run_env.conf["base_python"])
msg = f"could not resolve base python with {base}"
raise Skip(msg)
default_pkg_py = self.base_python
if (
default_pkg_py.version_no_dot == run_py.version_no_dot
and default_pkg_py.impl_lower == run_py.impl_lower
):
return self.conf.name
return f"{self.conf.name}-{run_py.impl_lower}{run_py.version_no_dot}"
run_env.conf.add_config(
keys=["wheel_build_env"],
of_type=str,
default=default_wheel_tag,
desc="wheel tag to use for building applications",
)
pkg_env = run_env.conf["wheel_build_env"]
result = yield pkg_env, run_env.conf["package_tox_env_type"]
self._wheel_build_envs[pkg_env] = cast(PythonPackageToxEnv, result)
def child_pkg_envs(self, run_conf: EnvConfigSet) -> Iterator[PackageToxEnv]:
if run_conf["package"] == "wheel":
env = self._wheel_build_envs.get(run_conf["wheel_build_env"])
if env is not None and env.name != self.name:
yield env
def _teardown(self) -> None:
for env in self._wheel_build_envs.values():
if env is not self:
with env.display_context(self._has_display_suspended):
env.teardown()
super()._teardown()
tox-4.13.0/src/tox/tox_env/python/pip/ 0000775 0000000 0000000 00000000000 14564001166 0017610 5 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/tox_env/python/pip/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0021707 0 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/tox_env/python/pip/pip_install.py 0000664 0000000 0000000 00000024507 14564001166 0022510 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import logging
from collections import defaultdict
from pathlib import Path
from typing import TYPE_CHECKING, Any, Callable, Sequence
from packaging.requirements import Requirement
from tox.config.types import Command
from tox.execute.request import StdinSource
from tox.tox_env.errors import Fail, Recreate
from tox.tox_env.installer import Installer
from tox.tox_env.python.api import Python
from tox.tox_env.python.package import EditableLegacyPackage, EditablePackage, SdistPackage, WheelPackage
from tox.tox_env.python.pip.req_file import PythonDeps
if TYPE_CHECKING:
from tox.config.main import Config
from tox.tox_env.package import PathPackage
class Pip(Installer[Python]):
"""Pip is a python installer that can install packages as defined by PEP-508 and PEP-517."""
def __init__(self, tox_env: Python, with_list_deps: bool = True) -> None: # noqa: FBT001, FBT002
self._with_list_deps = with_list_deps
super().__init__(tox_env)
def _register_config(self) -> None:
self._env.conf.add_config(
keys=["pip_pre"],
of_type=bool,
default=False,
desc="install the latest available pre-release (alpha/beta/rc) of dependencies without a specified version",
)
self._env.conf.add_config(
keys=["install_command"],
of_type=Command,
default=self.default_install_command,
post_process=self.post_process_install_command,
desc="command used to install packages",
)
self._env.conf.add_config(
keys=["constrain_package_deps"],
of_type=bool,
default=False,
desc="If true, apply constraints during install_package_deps.",
)
self._env.conf.add_config(
keys=["use_frozen_constraints"],
of_type=bool,
default=False,
desc="Use the exact versions of installed deps as constraints, otherwise use the listed deps.",
)
if self._with_list_deps: # pragma: no branch
self._env.conf.add_config(
keys=["list_dependencies_command"],
of_type=Command,
default=Command(["python", "-m", "pip", "freeze", "--all"]),
desc="command used to list installed packages",
)
def default_install_command(self, conf: Config, env_name: str | None) -> Command: # noqa: ARG002
isolated_flag = "-E" if self._env.base_python.version_info.major == 2 else "-I" # noqa: PLR2004
cmd = Command(["python", isolated_flag, "-m", "pip", "install", "{opts}", "{packages}"])
return self.post_process_install_command(cmd)
def post_process_install_command(self, cmd: Command) -> Command:
install_command = cmd.args
pip_pre: bool = self._env.conf["pip_pre"]
try:
opts_at = install_command.index("{opts}")
except ValueError:
if pip_pre:
install_command.append("--pre")
else:
if pip_pre:
install_command[opts_at] = "--pre"
else:
install_command.pop(opts_at)
return cmd
def installed(self) -> list[str]:
cmd: Command = self._env.conf["list_dependencies_command"]
result = self._env.execute(cmd=cmd.args, stdin=StdinSource.OFF, run_id="freeze", show=False)
result.assert_success()
return result.out.splitlines()
def install(self, arguments: Any, section: str, of_type: str) -> None:
if isinstance(arguments, PythonDeps):
self._install_requirement_file(arguments, section, of_type)
elif isinstance(arguments, Sequence):
self._install_list_of_deps(arguments, section, of_type)
else:
logging.warning("pip cannot install %r", arguments)
raise SystemExit(1)
def constraints_file(self) -> Path:
return Path(self._env.env_dir) / "constraints.txt"
@property
def constrain_package_deps(self) -> bool:
return bool(self._env.conf["constrain_package_deps"])
@property
def use_frozen_constraints(self) -> bool:
return bool(self._env.conf["use_frozen_constraints"])
def _install_requirement_file(self, arguments: PythonDeps, section: str, of_type: str) -> None:
try:
new_options, new_reqs = arguments.unroll()
except ValueError as exception:
msg = f"{exception} for tox env py within deps"
raise Fail(msg) from exception
new_requirements: list[str] = []
new_constraints: list[str] = []
for req in new_reqs:
(new_constraints if req.startswith("-c ") else new_requirements).append(req)
constraint_options = {
"constrain_package_deps": self.constrain_package_deps,
"use_frozen_constraints": self.use_frozen_constraints,
}
new = {
"options": new_options,
"requirements": new_requirements,
"constraints": new_constraints,
"constraint_options": constraint_options,
}
# if option or constraint change in any way recreate, if the requirements change only if some are removed
with self._env.cache.compare(new, section, of_type) as (eq, old):
if not eq: # pragma: no branch
if old is not None:
self._recreate_if_diff("install flag(s)", new_options, old["options"], lambda i: i)
self._recreate_if_diff("constraint(s)", new_constraints, old["constraints"], lambda i: i[3:])
missing_requirement = set(old["requirements"]) - set(new_requirements)
if missing_requirement:
msg = f"requirements removed: {' '.join(missing_requirement)}"
raise Recreate(msg)
old_constraint_options = old.get("constraint_options")
if old_constraint_options != constraint_options:
msg = f"constraint options changed: old={old_constraint_options} new={constraint_options}"
raise Recreate(msg)
args = arguments.as_root_args
if args: # pragma: no branch
self._execute_installer(args, of_type)
if self.constrain_package_deps and not self.use_frozen_constraints:
combined_constraints = new_requirements + [c.lstrip("-c ") for c in new_constraints]
self.constraints_file().write_text("\n".join(combined_constraints))
@staticmethod
def _recreate_if_diff(of_type: str, new_opts: list[str], old_opts: list[str], fmt: Callable[[str], str]) -> None:
if old_opts == new_opts:
return
removed_opts = set(old_opts) - set(new_opts)
removed = f" removed {', '.join(sorted(fmt(i) for i in removed_opts))}" if removed_opts else ""
added_opts = set(new_opts) - set(old_opts)
added = f" added {', '.join(sorted(fmt(i) for i in added_opts))}" if added_opts else ""
msg = f"changed {of_type}{removed}{added}"
raise Recreate(msg)
def _install_list_of_deps( # noqa: C901
self,
arguments: Sequence[
Requirement | WheelPackage | SdistPackage | EditableLegacyPackage | EditablePackage | PathPackage
],
section: str,
of_type: str,
) -> None:
groups: dict[str, list[str]] = defaultdict(list)
for arg in arguments:
if isinstance(arg, Requirement):
groups["req"].append(str(arg))
elif isinstance(arg, (WheelPackage, SdistPackage, EditablePackage)):
groups["req"].extend(str(i) for i in arg.deps)
groups["pkg"].append(str(arg.path))
elif isinstance(arg, EditableLegacyPackage):
groups["req"].extend(str(i) for i in arg.deps)
groups["dev_pkg"].append(str(arg.path))
else:
logging.warning("pip cannot install %r", arg)
raise SystemExit(1)
req_of_type = f"{of_type}_deps" if groups["pkg"] or groups["dev_pkg"] else of_type
for value in groups.values():
value.sort()
with self._env.cache.compare(groups["req"], section, req_of_type) as (eq, old):
if not eq: # pragma: no branch
miss = sorted(set(old or []) - set(groups["req"]))
if miss: # no way yet to know what to uninstall here (transitive dependencies?)
msg = f"dependencies removed: {', '.join(str(i) for i in miss)}"
raise Recreate(msg) # pragma: no branch
new_deps = sorted(set(groups["req"]) - set(old or []))
if new_deps: # pragma: no branch
self._execute_installer(new_deps, req_of_type)
install_args = ["--force-reinstall", "--no-deps"]
if groups["pkg"]:
self._execute_installer(install_args + groups["pkg"], of_type)
if groups["dev_pkg"]:
for entry in groups["dev_pkg"]:
install_args.extend(("-e", str(entry)))
self._execute_installer(install_args, of_type)
def _execute_installer(self, deps: Sequence[Any], of_type: str) -> None:
if of_type == "package_deps" and self.constrain_package_deps:
constraints_file = self.constraints_file()
if constraints_file.exists():
deps = [*deps, f"-c{constraints_file}"]
cmd = self.build_install_cmd(deps)
outcome = self._env.execute(cmd, stdin=StdinSource.OFF, run_id=f"install_{of_type}")
outcome.assert_success()
if of_type == "deps" and self.constrain_package_deps and self.use_frozen_constraints:
# freeze installed deps for use as constraints
self.constraints_file().write_text("\n".join(self.installed()))
def build_install_cmd(self, args: Sequence[str]) -> list[str]:
try:
cmd: Command = self._env.conf["install_command"]
except ValueError as exc:
msg = f"unable to determine pip install command: {exc!s}"
raise Fail(msg) from exc
install_command = cmd.args
try:
opts_at = install_command.index("{packages}")
except ValueError:
opts_at = len(install_command)
return install_command[:opts_at] + list(args) + install_command[opts_at + 1 :]
__all__ = ("Pip",)
tox-4.13.0/src/tox/tox_env/python/pip/req/ 0000775 0000000 0000000 00000000000 14564001166 0020377 5 ustar 00root root 0000000 0000000 tox-4.13.0/src/tox/tox_env/python/pip/req/__init__.py 0000664 0000000 0000000 00000000423 14564001166 0022507 0 ustar 00root root 0000000 0000000 """
Specification is defined within pip itself and documented under:
- https://pip.pypa.io/en/stable/reference/pip_install/#requirements-file-format
- https://github.com/pypa/pip/blob/master/src/pip/_internal/req/constructors.py#L291.
"""
from __future__ import annotations
tox-4.13.0/src/tox/tox_env/python/pip/req/args.py 0000664 0000000 0000000 00000010342 14564001166 0021705 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import bisect
import re
from argparse import Action, ArgumentParser, ArgumentTypeError, Namespace
from typing import IO, Any, NoReturn, Sequence
from tox.tox_env.python.pip.req.util import handle_binary_option
class _OurArgumentParser(ArgumentParser):
def print_usage(self, file: IO[str] | None = None) -> None:
""" """
def exit(self, status: int = 0, message: str | None = None) -> NoReturn: # noqa: ARG002, PLR6301
message = "" if message is None else message
msg = message.lstrip(": ").rstrip()
if msg.startswith("error: "):
msg = msg[len("error: ") :]
raise ValueError(msg)
def build_parser() -> ArgumentParser:
parser = _OurArgumentParser(add_help=False, prog="", allow_abbrev=False)
_global_options(parser)
_req_options(parser)
return parser
def _global_options(parser: ArgumentParser) -> None:
parser.add_argument("-i", "--index-url", "--pypi-url", dest="index_url", default=None)
parser.add_argument("--extra-index-url", action=AddUniqueAction)
parser.add_argument("--no-index", action="store_true", default=False)
parser.add_argument("-c", "--constraint", action=AddUniqueAction, dest="constraints")
parser.add_argument("-r", "--requirement", action=AddUniqueAction, dest="requirements")
parser.add_argument("-e", "--editable", action=AddUniqueAction, dest="editables")
parser.add_argument("-f", "--find-links", action=AddUniqueAction)
parser.add_argument("--no-binary", action=BinaryAction, nargs="+")
parser.add_argument("--only-binary", action=BinaryAction, nargs="+")
parser.add_argument("--prefer-binary", action="store_true", default=False)
parser.add_argument("--require-hashes", action="store_true", default=False)
parser.add_argument("--pre", action="store_true", default=False)
parser.add_argument("--trusted-host", action=AddSortedUniqueAction)
parser.add_argument(
"--use-feature",
choices=["2020-resolver", "fast-deps"],
action=AddSortedUniqueAction,
dest="features_enabled",
)
def _req_options(parser: ArgumentParser) -> None:
parser.add_argument("--install-option", action=AddSortedUniqueAction)
parser.add_argument("--global-option", action=AddSortedUniqueAction)
parser.add_argument("--hash", action=AddSortedUniqueAction, type=_validate_hash)
_HASH = re.compile(r"sha(256:[a-f0-9]{64}|384:[a-f0-9]{96}|512:[a-f0-9]{128})")
def _validate_hash(value: str) -> str:
if not _HASH.fullmatch(value):
raise ArgumentTypeError(value)
return value
class AddSortedUniqueAction(Action):
def __call__(
self,
parser: ArgumentParser, # noqa: ARG002
namespace: Namespace,
values: str | Sequence[Any] | None,
option_string: str | None = None, # noqa: ARG002
) -> None:
if getattr(namespace, self.dest, None) is None:
setattr(namespace, self.dest, [])
current = getattr(namespace, self.dest)
if values not in current:
bisect.insort(current, values)
class AddUniqueAction(Action):
def __call__(
self,
parser: ArgumentParser, # noqa: ARG002
namespace: Namespace,
values: str | Sequence[Any] | None,
option_string: str | None = None, # noqa: ARG002
) -> None:
if getattr(namespace, self.dest, None) is None:
setattr(namespace, self.dest, [])
current = getattr(namespace, self.dest)
if values not in current:
current.append(values)
class BinaryAction(Action):
def __call__(
self,
parser: ArgumentParser, # noqa: ARG002
namespace: Namespace,
values: str | Sequence[Any] | None,
option_string: str | None = None, # noqa: ARG002
) -> None:
if getattr(namespace, "no_binary", None) is None:
namespace.no_binary = set()
if getattr(namespace, "only_binary", None) is None:
namespace.only_binary = set()
args = (
(namespace.no_binary, namespace.only_binary)
if self.dest == "no_binary"
else (namespace.only_binary, namespace.no_binary)
)
assert values is not None # noqa: S101
handle_binary_option(values[0], *args)
tox-4.13.0/src/tox/tox_env/python/pip/req/file.py 0000664 0000000 0000000 00000046433 14564001166 0021702 0 ustar 00root root 0000000 0000000 """Adapted from the pip code base."""
from __future__ import annotations
import os
import re
import shlex
import sys
import urllib.parse
from argparse import ArgumentParser, Namespace
from pathlib import Path
from typing import IO, Any, Iterator, List, Tuple, cast
from urllib.request import urlopen
import chardet
from packaging.requirements import InvalidRequirement, Requirement
from .args import build_parser
from .util import VCS, get_url_scheme, is_url, url_to_path
# Matches environment variable-style values in '${MY_VARIABLE_1}' with the variable name consisting of only uppercase
# letters, digits or the '_' (underscore). This follows the POSIX standard defined in IEEE Std 1003.1, 2013 Edition.
_ENV_VAR_RE = re.compile(r"(?P\${(?P[A-Z0-9_]+)})")
_SCHEME_RE = re.compile(r"^(http|https|file):", re.IGNORECASE)
_COMMENT_RE = re.compile(r"(^|\s+)#.*$")
# https://www.python.org/dev/peps/pep-0508/#extras
_EXTRA_PATH = re.compile(r"(.*)\[([-._,\sa-zA-Z0-9]*)]")
_EXTRA_ELEMENT = re.compile(r"[a-zA-Z0-9]*[-._a-zA-Z0-9]")
ReqFileLines = Iterator[Tuple[int, str]]
DEFAULT_INDEX_URL = "https://pypi.org/simple"
class ParsedRequirement:
def __init__(self, req: str, options: dict[str, Any], from_file: str, lineno: int) -> None: # noqa: PLR0912
req = req.encode("utf-8").decode("utf-8")
try:
self._requirement: Requirement | Path | str = Requirement(req)
except InvalidRequirement:
if is_url(req) or any(req.startswith(f"{v}+") and is_url(req[len(v) + 1 :]) for v in VCS):
self._requirement = req
else:
root = Path(from_file).parent
extras: list[str] = []
match = _EXTRA_PATH.fullmatch(Path(req).name)
if match:
for extra in match.group(2).split(","):
extra = extra.strip() # noqa: PLW2901
if not extra:
continue
if not _EXTRA_ELEMENT.fullmatch(extra):
extras = []
path = root / req
break
extras.append(extra)
else:
path = root / Path(req).parent / match.group(1)
else:
path = root / req
extra_part = f"[{','.join(sorted(extras))}]" if extras else ""
try:
rel_path = str(path.resolve().relative_to(root))
# prefix paths in cwd to not convert them to requirement
if rel_path != "." and os.sep not in rel_path:
rel_path = f".{os.sep}{rel_path}"
except ValueError:
rel_path = str(path.resolve())
self._requirement = f"{rel_path}{extra_part}"
self._options = options
self._from_file = from_file
self._lineno = lineno
@property
def requirement(self) -> Requirement | Path | str:
return self._requirement
@property
def from_file(self) -> str:
return self._from_file
@property
def lineno(self) -> int:
return self._lineno
@property
def options(self) -> dict[str, Any]:
return self._options
def __repr__(self) -> str:
base = f"{self.__class__.__name__}(requirement={self._requirement}, "
if self._options:
base += f"options={self._options!r}, "
return f"{base.rstrip(', ')})"
def __str__(self) -> str:
result = []
if self.options.get("is_constraint"):
result.append("-c")
if self.options.get("is_editable"):
result.append("-e")
result.append(str(self.requirement))
for hash_value in self.options.get("hash", []):
result.extend(("--hash", hash_value))
return " ".join(result)
def as_args(self) -> Iterator[str]:
if self.options.get("is_editable"):
yield "-e"
yield str(self._requirement)
class ParsedLine:
def __init__( # noqa: PLR0913
self,
filename: str,
lineno: int,
args: str,
opts: Namespace,
constraint: bool, # noqa: FBT001
) -> None:
self.filename = filename
self.lineno = lineno
self.opts = opts
self.constraint = constraint
if args:
self.is_requirement = True
self.is_editable = False
self.requirement = args
elif opts.editables:
self.is_requirement = True
self.is_editable = True
# We don't support multiple -e on one line
self.requirement = opts.editables[0]
else:
self.is_requirement = False
class RequirementsFile:
def __init__(self, path: Path, constraint: bool) -> None: # noqa: FBT001
self._path = path
self._is_constraint: bool = constraint
self._opt = Namespace()
self._requirements: list[ParsedRequirement] | None = None
self._as_root_args: list[str] | None = None
self._parser_private: ArgumentParser | None = None
@property
def _req_parser(self) -> RequirementsFile:
return self
def __str__(self) -> str:
return f"{'-c' if self.is_constraint else '-r'} {self.path}"
@property
def path(self) -> Path:
return self._path
@property
def is_constraint(self) -> bool:
return self._is_constraint
@property
def options(self) -> Namespace:
self._ensure_requirements_parsed()
return self._opt
@property
def requirements(self) -> list[ParsedRequirement]:
self._ensure_requirements_parsed()
return cast(List[ParsedRequirement], self._requirements)
@property
def _parser(self) -> ArgumentParser:
if self._parser_private is None:
self._parser_private = build_parser()
self._extend_parser(self._parser_private)
return self._parser_private
def _extend_parser(self, parser: ArgumentParser) -> None: ...
def _ensure_requirements_parsed(self) -> None:
if self._requirements is None:
self._requirements = self._parse_requirements(opt=self._opt, recurse=True)
def _parse_requirements(self, opt: Namespace, recurse: bool) -> list[ParsedRequirement]: # noqa: FBT001
result, found = [], set()
for parsed_line in self._parse_and_recurse(str(self._path), self.is_constraint, recurse):
if parsed_line.is_requirement:
parsed_req = self._handle_requirement_line(parsed_line)
key = str(parsed_req)
if key not in found:
found.add(key)
result.append(parsed_req)
else:
self._merge_option_line(opt, parsed_line.opts, parsed_line.filename)
result.sort(key=self._key_func)
return result
def _key_func(self, line: ParsedRequirement) -> tuple[int, tuple[int, str, str]]: # noqa: PLR6301
of_type = {Requirement: 0, Path: 1, str: 2}[type(line.requirement)]
between = of_type, str(line.requirement).lower(), str(line.options)
if "is_constraint" in line.options:
return 2, between
if "is_editable" in line.options:
return 1, between
return 0, between
def _parse_and_recurse(
self,
filename: str,
constraint: bool, # noqa: FBT001
recurse: bool, # noqa: FBT001
) -> Iterator[ParsedLine]:
for line in self._parse_file(filename, constraint):
if not line.is_requirement and (line.opts.requirements or line.opts.constraints):
if line.opts.requirements: # parse a nested requirements file
nested_constraint, req_path = False, line.opts.requirements[0]
else:
nested_constraint, req_path = True, line.opts.constraints[0]
if _SCHEME_RE.search(filename): # original file is over http
req_path = urllib.parse.urljoin(filename, req_path) # do a url join so relative paths work
elif not _SCHEME_RE.search(req_path): # original file and nested file are paths
req_path = str(Path(filename).parent / req_path) # do a join so relative paths work
if recurse:
yield from self._req_parser._parse_and_recurse(req_path, nested_constraint, recurse) # noqa: SLF001
else:
line.filename = req_path
yield line
else:
yield line
def _parse_file(self, url: str, constraint: bool) -> Iterator[ParsedLine]: # noqa: FBT001
content = self._get_file_content(url)
for line_number, line in self._pre_process(content):
args_str, opts = self._parse_line(line)
yield ParsedLine(url, line_number, args_str, opts, constraint)
def _get_file_content(self, url: str) -> str:
"""
Gets the content of a file; it may be a filename, file: URL, or http: URL. Returns (location, content).
Content is unicode. Respects # -*- coding: declarations on the retrieved files.
:param url: File path or url.
"""
scheme = get_url_scheme(url)
if scheme in {"http", "https"}:
with urlopen(url) as response: # noqa: S310
return self._read_decode(response)
elif scheme == "file":
url = url_to_path(url)
try:
with Path(url).open("rb") as file_handler:
text = self._read_decode(file_handler)
except OSError as exc:
msg = f"Could not open requirements file {url}: {exc}"
raise ValueError(msg) from exc
return text
@staticmethod
def _read_decode(file_handler: IO[bytes]) -> str:
raw = file_handler.read()
if not raw:
return ""
codec = chardet.detect(raw)["encoding"]
return raw.decode(codec)
def _pre_process(self, content: str) -> ReqFileLines:
"""
Split, filter, and join lines, and return a line iterator.
:param content: the content of the requirements file
"""
lines_enum: ReqFileLines = enumerate(content.splitlines(), start=1)
lines_enum = self._join_lines(lines_enum)
lines_enum = self._ignore_comments(lines_enum)
return self._expand_env_variables(lines_enum)
def _parse_line(self, line: str) -> tuple[str, Namespace]:
args_str, options_str = self._break_args_options(line)
args = shlex.split(options_str, posix=sys.platform != "win32")
opts = self._parser.parse_args(args)
return args_str, opts
@staticmethod
def _handle_requirement_line(line: ParsedLine) -> ParsedRequirement:
# For editable requirements, we don't support per-requirement options, so just return the parsed requirement.
# get the options that apply to requirements
req_options: dict[str, Any] = {}
if line.is_editable:
req_options["is_editable"] = line.is_editable
if line.constraint:
req_options["is_constraint"] = line.constraint
hash_values = getattr(line.opts, "hash", [])
if hash_values:
req_options["hash"] = hash_values
return ParsedRequirement(line.requirement, req_options, line.filename, line.lineno)
def _merge_option_line( # noqa: C901, PLR0912, PLR0915, PLR6301
self,
base_opt: Namespace,
opt: Namespace,
filename: str,
) -> None:
# percolate options upward
if opt.requirements:
if not hasattr(base_opt, "requirements"):
base_opt.requirements = []
if opt.requirements[0] not in base_opt.requirements:
base_opt.requirements.append(opt.requirements[0])
if opt.constraints:
if not hasattr(base_opt, "constraints"):
base_opt.constraints = []
if opt.constraints[0] not in base_opt.constraints:
base_opt.constraints.append(opt.constraints[0])
if opt.require_hashes:
base_opt.require_hashes = True
if opt.features_enabled:
if not hasattr(base_opt, "features_enabled"):
base_opt.features_enabled = []
for feature in opt.features_enabled:
if feature not in base_opt.features_enabled:
base_opt.features_enabled.append(feature)
base_opt.features_enabled.sort()
if opt.index_url:
if getattr(base_opt, "index_url", []):
base_opt.index_url[0] = opt.index_url
else:
base_opt.index_url = [opt.index_url]
if opt.no_index is True:
base_opt.index_url = []
if opt.extra_index_url:
if not getattr(base_opt, "index_url", []):
base_opt.index_url = [DEFAULT_INDEX_URL]
for url in opt.extra_index_url:
if url not in base_opt.index_url:
base_opt.index_url.extend(opt.extra_index_url)
if opt.find_links:
# relative to a requirements file.
if not hasattr(base_opt, "find_links"):
base_opt.find_links = []
value = opt.find_links[0]
req_dir = Path(filename).absolute().parent
relative_to_reqs_file = req_dir / value
if os.path.exists(str(relative_to_reqs_file)): # noqa: PTH110 # Path.exists fails on win32 <=3.7 with URI
value = str(relative_to_reqs_file) # pragma: no cover
if value not in base_opt.find_links:
base_opt.find_links.append(value)
if opt.pre:
base_opt.pre = True
if opt.prefer_binary:
base_opt.prefer_binary = True
for host in opt.trusted_host or []:
if not hasattr(base_opt, "trusted_hosts"):
base_opt.trusted_hosts = []
if host not in base_opt.trusted_hosts:
base_opt.trusted_hosts.append(host)
if opt.no_binary:
base_opt.no_binary = opt.no_binary
if opt.only_binary:
base_opt.only_binary = opt.only_binary
@staticmethod
def _break_args_options(line: str) -> tuple[str, str]:
"""
Break up the line into an args and options string. We only want to shlex (and then optparse) the options, not
the args. args can contain markers which are corrupted by shlex.
"""
tokens = line.split(" ")
args = []
options = tokens[:]
for token in tokens:
if token.startswith("-"): # both `-` and `--` accepted
break
args.append(token)
options.pop(0)
return " ".join(args).strip(), " ".join(options)
@staticmethod
def _join_lines(lines_enum: ReqFileLines) -> ReqFileLines:
"""
Joins a line ending in '\' with the previous line (except when following comments). The joined line takes on the
index of the first line.
"""
primary_line_number = None
new_line: list[str] = []
for line_number, line in lines_enum:
if not line.endswith("\\") or _COMMENT_RE.match(line):
if _COMMENT_RE.match(line):
line = f" {line}" # noqa: PLW2901 # this ensures comments are always matched later
if new_line:
new_line.append(line)
assert primary_line_number is not None # noqa: S101
yield primary_line_number, "".join(new_line)
new_line = []
else:
yield line_number, line
else:
if not new_line: # pragma: no branch
primary_line_number = line_number
new_line.append(line.strip("\\"))
# last line contains \
if new_line:
assert primary_line_number is not None # noqa: S101
yield primary_line_number, "".join(new_line)
@staticmethod
def _ignore_comments(lines_enum: ReqFileLines) -> ReqFileLines:
"""Strips comments and filter empty lines."""
for line_number, line in lines_enum:
processed_line = _COMMENT_RE.sub("", line).strip()
if processed_line:
yield line_number, processed_line
@staticmethod
def _expand_env_variables(lines_enum: ReqFileLines) -> ReqFileLines:
"""
Replace all environment variables that can be retrieved via `os.getenv`.
The only allowed format for environment variables defined in the requirement file is `${MY_VARIABLE_1}` to
ensure two things:
1. Strings that contain a `$` aren't accidentally (partially) expanded.
2. Ensure consistency across platforms for requirement files.
These points are the result of a discussion on the `github pull request #3514
`_. Valid characters in variable names follow the `POSIX standard
because {}".format(
value_error("invalid literal for int() with base 10: 'should-be-number'"),
)
second = "env var TOX_QUIET='1.00' cannot be transformed to because {}".format(
value_error("invalid literal for int() with base 10: '1.00'"),
)
capsys.readouterr()
assert caplog.messages[0] == first
assert caplog.messages[1] == second
assert len(caplog.messages) == 2, caplog.text
tox-4.13.0/tests/config/cli/test_cli_ini.py 0000664 0000000 0000000 00000016376 14564001166 0020626 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import logging
import sys
import textwrap
from pathlib import Path
from typing import TYPE_CHECKING, Any, Callable
from unittest.mock import ANY
import pytest
from tox.config.cli.ini import IniConfig
from tox.config.cli.parse import get_options
from tox.config.cli.parser import Parsed
from tox.config.loader.api import Override
from tox.config.main import Config
from tox.config.source import discover_source
from tox.session.env_select import CliEnv
from tox.util.ci import is_ci
if TYPE_CHECKING:
from pytest_mock import MockerFixture
from tox.pytest import CaptureFixture, LogCaptureFixture, MonkeyPatch
from tox.session.state import State
@pytest.fixture()
def default_options() -> dict[str, Any]:
return {
"colored": "no",
"command": "r",
"default_runner": "virtualenv",
"develop": False,
"discover": [],
"env": CliEnv(),
"hash_seed": ANY,
"install_pkg": None,
"no_test": False,
"override": [],
"package_only": False,
"quiet": 0,
"recreate": False,
"no_recreate_provision": False,
"no_provision": False,
"no_recreate_pkg": False,
"result_json": None,
"skip_missing_interpreters": "config",
"skip_pkg_install": False,
"verbose": 2,
"work_dir": None,
"root_dir": None,
"config_file": None,
"factors": [],
"labels": [],
"exit_and_dump_after": 0,
"skip_env": "",
"list_dependencies": is_ci(),
}
@pytest.mark.parametrize("content", ["[tox]", ""])
def test_ini_empty( # noqa: PLR0913
tmp_path: Path,
core_handlers: dict[str, Callable[[State], int]],
default_options: dict[str, Any],
mocker: MockerFixture,
monkeypatch: MonkeyPatch,
content: str,
) -> None:
to = tmp_path / "tox.ini"
monkeypatch.setenv("TOX_USER_CONFIG_FILE", str(to))
to.write_text(content)
mocker.patch("tox.config.cli.parse.discover_source", return_value=mocker.MagicMock(path=Path()))
options = get_options("r")
assert vars(options.parsed) == default_options
assert options.parsed.verbosity == 2
assert options.cmd_handlers == core_handlers
to.unlink()
missing_options = get_options("r")
missing_options.parsed.hash_seed = ANY
assert vars(missing_options.parsed) == vars(options.parsed)
def test_bad_cli_ini(
tmp_path: Path,
monkeypatch: MonkeyPatch,
caplog: LogCaptureFixture,
default_options: dict[str, Any],
mocker: MockerFixture,
) -> None:
mocker.patch("tox.config.cli.parse.discover_source", return_value=mocker.MagicMock(path=Path()))
caplog.set_level(logging.WARNING)
monkeypatch.setenv("TOX_USER_CONFIG_FILE", str(tmp_path))
options = get_options("r")
msg = (
"PermissionError(13, 'Permission denied')"
if sys.platform == "win32"
else "IsADirectoryError(21, 'Is a directory')"
)
assert caplog.messages == [f"failed to read config file {tmp_path} because {msg}"]
assert vars(options.parsed) == default_options
def test_bad_option_cli_ini(
tmp_path: Path,
monkeypatch: MonkeyPatch,
caplog: LogCaptureFixture,
value_error: Callable[[str], str],
default_options: dict[str, Any],
) -> None:
caplog.set_level(logging.WARNING)
to = tmp_path / "tox.ini"
to.write_text(
textwrap.dedent(
"""
[tox]
verbose = what
""",
),
)
monkeypatch.setenv("TOX_USER_CONFIG_FILE", str(to))
parsed, _, __, ___, ____ = get_options("r")
assert caplog.messages == [
"{} key verbose as type failed with {}".format(
to,
value_error("invalid literal for int() with base 10: 'what'"),
),
]
assert vars(parsed) == default_options
def test_cli_ini_with_interpolated(tmp_path: Path, monkeypatch: MonkeyPatch) -> None:
to = tmp_path / "tox.ini"
to.write_text("[tox]\na = %(b)s")
monkeypatch.setenv("TOX_USER_CONFIG_FILE", str(to))
conf = IniConfig()
assert conf.get("a", str)
@pytest.mark.parametrize(
("conf_arg", "filename", "content"),
[
pytest.param("", "tox.ini", "[tox]", id="ini-dir"),
pytest.param("tox.ini", "tox.ini", "[tox]", id="ini"),
pytest.param("", "setup.cfg", "[tox:tox]", id="cfg-dir"),
pytest.param("setup.cfg", "setup.cfg", "[tox:tox]", id="cfg"),
pytest.param("", "pyproject.toml", '[tool.tox]\nlegacy_tox_ini = """\n[tox]\n"""\n', id="toml-dir"),
pytest.param("pyproject.toml", "pyproject.toml", '[tool.tox]\nlegacy_tox_ini = """\n[tox]\n"""\n', id="toml"),
],
)
def test_conf_arg(tmp_path: Path, conf_arg: str, filename: str, content: str) -> None:
dest = tmp_path / "c"
dest.mkdir()
if filename:
cfg = dest / filename
cfg.write_bytes(content.encode(encoding="utf-8"))
config_file = dest / conf_arg
source = discover_source(config_file, None)
Config.make(
Parsed(work_dir=dest, override=[], config_file=config_file, root_dir=None),
pos_args=[],
source=source,
)
@pytest.fixture()
def exhaustive_ini(tmp_path: Path, monkeypatch: MonkeyPatch) -> Path:
to = tmp_path / "tox.ini"
to.write_text(
textwrap.dedent(
"""
[tox]
colored = yes
verbose = 5
quiet = 1
command = run-parallel
env = py37, py36
default_runner = virtualenv
recreate = true
no_test = true
parallel = 3
parallel_live = True
override =
a=b
c=d
""",
),
)
monkeypatch.setenv("TOX_USER_CONFIG_FILE", str(to))
return to
@pytest.mark.usefixtures("exhaustive_ini")
def test_ini_exhaustive_parallel_values(core_handlers: dict[str, Callable[[State], int]]) -> None:
options = get_options("p")
assert vars(options.parsed) == {
"colored": "yes",
"command": "p",
"default_runner": "virtualenv",
"develop": False,
"discover": [],
"env": CliEnv(["py37", "py36"]),
"hash_seed": ANY,
"install_pkg": None,
"no_test": True,
"override": [Override("a=b"), Override("c=d")],
"package_only": False,
"no_recreate_pkg": False,
"parallel": 3,
"parallel_live": True,
"parallel_no_spinner": False,
"quiet": 1,
"no_provision": False,
"recreate": True,
"no_recreate_provision": False,
"result_json": None,
"skip_missing_interpreters": "config",
"skip_pkg_install": False,
"verbose": 5,
"work_dir": None,
"root_dir": None,
"config_file": None,
"factors": [],
"labels": [],
"exit_and_dump_after": 0,
"skip_env": "",
"list_dependencies": is_ci(),
}
assert options.parsed.verbosity == 4
assert options.cmd_handlers == core_handlers
def test_ini_help(exhaustive_ini: Path, capfd: CaptureFixture) -> None:
with pytest.raises(SystemExit) as context:
get_options("-h")
assert context.value.code == 0
out, err = capfd.readouterr()
assert not err
res = out.splitlines()[-1]
msg = f"config file {str(exhaustive_ini)!r} active (changed via env var TOX_USER_CONFIG_FILE)"
assert res == msg
tox-4.13.0/tests/config/cli/test_parse.py 0000664 0000000 0000000 00000002123 14564001166 0020313 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import logging
from typing import TYPE_CHECKING
import pytest
from tox.config.cli.parse import get_options
if TYPE_CHECKING:
from tox.pytest import CaptureFixture
def test_help_does_not_default_cmd(capsys: CaptureFixture) -> None:
with pytest.raises(SystemExit):
get_options("-h")
out, err = capsys.readouterr()
assert not err
assert "--verbose" in out
assert "subcommands:" in out
def test_verbosity_guess_miss_match(capsys: CaptureFixture) -> None:
result = get_options("-rv")
assert result.parsed.verbosity == 3
assert logging.getLogger().level == logging.INFO
for name in ("distlib.util", "filelock"):
logger = logging.getLogger(name)
assert logger.disabled
logging.error("E")
logging.warning("W")
logging.info("I")
logging.debug("D")
out, _err = capsys.readouterr()
assert out == "ROOT: E\nROOT: W\nROOT: I\n"
@pytest.mark.parametrize("arg", ["-av", "-va"])
def test_verbosity(arg: str) -> None:
result = get_options(arg)
assert result.parsed.verbosity == 3
tox-4.13.0/tests/config/cli/test_parser.py 0000664 0000000 0000000 00000006256 14564001166 0020510 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from argparse import Action
from typing import TYPE_CHECKING
import pytest
from tox.config.cli.parser import Parsed, ToxParser
if TYPE_CHECKING:
from pytest_mock import MockerFixture
from tox.pytest import CaptureFixture, MonkeyPatch
def test_parser_const_with_default_none(monkeypatch: MonkeyPatch) -> None:
monkeypatch.setenv("TOX_ALPHA", "2")
parser = ToxParser.base()
parser.add_argument(
"-a",
dest="alpha",
action="store_const",
const=1,
default=None,
help="sum the integers (default: find the max)",
)
parser.fix_defaults()
result = parser.parse_args([])
assert result.alpha == 2
@pytest.mark.parametrize("is_atty", [True, False])
@pytest.mark.parametrize("no_color", [None, "0", "1", "", "\t", " ", "false", "true"])
@pytest.mark.parametrize("force_color", [None, "0", "1"])
@pytest.mark.parametrize("tox_color", [None, "bad", "no", "yes"])
@pytest.mark.parametrize("term", [None, "xterm", "dumb"])
def test_parser_color( # noqa: PLR0913
monkeypatch: MonkeyPatch,
mocker: MockerFixture,
no_color: str | None,
force_color: str | None,
tox_color: str | None,
is_atty: bool,
term: str | None,
) -> None:
for key, value in {
"NO_COLOR": no_color,
"TOX_COLORED": tox_color,
"FORCE_COLOR": force_color,
"TERM": term,
}.items():
if value is None:
monkeypatch.delenv(key, raising=False)
else:
monkeypatch.setenv(key, value)
stdout_mock = mocker.patch("tox.config.cli.parser.sys.stdout")
stdout_mock.isatty.return_value = is_atty
if tox_color in {"yes", "no"}:
expected = tox_color == "yes"
elif bool(no_color):
expected = False
elif force_color == "1":
expected = True
elif term == "dumb":
expected = False
else:
expected = is_atty
is_colored = ToxParser.base().parse_args([], Parsed()).is_colored
assert is_colored is expected
def test_parser_unsupported_type() -> None:
parser = ToxParser.base()
parser.add_argument("--magic", action="store", default=None)
with pytest.raises(TypeError) as context:
parser.fix_defaults()
action = context.value.args[0]
assert isinstance(action, Action)
assert action.dest == "magic"
def test_sub_sub_command() -> None:
parser = ToxParser.base()
with pytest.raises(RuntimeError, match="no sub-command group allowed"):
parser.add_command(
"c",
[],
"help",
lambda s: 0, # noqa: ARG005
) # pragma: no cover - the lambda will never be run
def test_parse_known_args_not_set(mocker: MockerFixture) -> None:
mocker.patch.object(sys, "argv", ["a", "--help"])
parser = ToxParser.base()
_, unknown = parser.parse_known_args(None)
assert unknown == ["--help"]
def test_parser_hint(capsys: CaptureFixture) -> None:
parser = ToxParser.base()
with pytest.raises(SystemExit):
parser.parse_args("foo")
_out, err = capsys.readouterr()
assert err.endswith("hint: if you tried to pass arguments to a command use -- to separate them from tox ones\n")
tox-4.13.0/tests/config/conftest.py 0000664 0000000 0000000 00000000444 14564001166 0017224 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
import pytest
if TYPE_CHECKING:
from tests.conftest import ToxIniCreator
from tox.config.main import Config
@pytest.fixture()
def empty_config(tox_ini_conf: ToxIniCreator) -> Config:
return tox_ini_conf("")
tox-4.13.0/tests/config/loader/ 0000775 0000000 0000000 00000000000 14564001166 0016271 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/config/loader/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0020370 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/config/loader/ini/ 0000775 0000000 0000000 00000000000 14564001166 0017050 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/config/loader/ini/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0021147 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/config/loader/ini/conftest.py 0000664 0000000 0000000 00000001202 14564001166 0021242 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from configparser import ConfigParser
from typing import TYPE_CHECKING, Callable
import pytest
if TYPE_CHECKING:
from pathlib import Path
@pytest.fixture()
def mk_ini_conf(tmp_path: Path) -> Callable[[str], ConfigParser]:
def _func(raw: str) -> ConfigParser:
filename = tmp_path / "demo.ini"
filename.write_bytes(raw.encode("utf-8")) # win32: avoid CR normalization - what you pass is what you get
parser = ConfigParser(interpolation=None)
with filename.open() as file_handler:
parser.read_file(file_handler)
return parser
return _func
tox-4.13.0/tests/config/loader/ini/replace/ 0000775 0000000 0000000 00000000000 14564001166 0020463 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/config/loader/ini/replace/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0022562 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/config/loader/ini/replace/conftest.py 0000664 0000000 0000000 00000002157 14564001166 0022667 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
import pytest
from tox.config.cli.parser import Parsed
from tox.config.loader.api import ConfigLoadArgs
from tox.config.main import Config
from tox.config.source.tox_ini import ToxIni
if TYPE_CHECKING:
from pathlib import Path
from typing import Protocol
class ReplaceOne(Protocol):
def __call__(self, conf: str, pos_args: list[str] | None = None) -> str: ...
@pytest.fixture()
def replace_one(tmp_path: Path) -> ReplaceOne:
def example(conf: str, pos_args: list[str] | None = None) -> str:
tox_ini_file = tmp_path / "tox.ini"
tox_ini_file.write_text(f"[testenv:py]\nenv={conf}\n")
tox_ini = ToxIni(tox_ini_file)
config = Config(
tox_ini,
options=Parsed(override=[]),
root=tmp_path,
pos_args=pos_args,
work_dir=tmp_path,
)
loader = config.get_env("py").loaders[0]
args = ConfigLoadArgs(chain=[], name="a", env_name="a")
return loader.load(key="env", of_type=str, conf=config, factory=None, args=args)
return example
tox-4.13.0/tests/config/loader/ini/replace/test_replace.py 0000664 0000000 0000000 00000006740 14564001166 0023516 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
import pytest
from tox.config.loader.ini.replace import MatchExpression, find_replace_expr
from tox.report import HandledError
if TYPE_CHECKING:
from tests.config.loader.ini.replace.conftest import ReplaceOne
@pytest.mark.parametrize(
("value", "exp_output"),
[
("[]", [MatchExpression([["posargs"]])]),
("123[]", ["123", MatchExpression([["posargs"]])]),
("[]123", [MatchExpression([["posargs"]]), "123"]),
(r"\[\] []", ["[] ", MatchExpression([["posargs"]])]),
(r"[\] []", ["[] ", MatchExpression([["posargs"]])]),
(r"\[] []", ["[] ", MatchExpression([["posargs"]])]),
("{foo}", [MatchExpression([["foo"]])]),
(r"\{foo} {bar}", ["{foo} ", MatchExpression([["bar"]])]),
("{foo} {bar}", [MatchExpression([["foo"]]), " ", MatchExpression([["bar"]])]),
(r"{foo\} {bar}", ["{foo} ", MatchExpression([["bar"]])]),
(r"{foo:{bar}}", [MatchExpression([["foo"], [MatchExpression([["bar"]])]])]),
(r"{foo\::{bar}}", [MatchExpression([["foo:"], [MatchExpression([["bar"]])]])]),
(r"{foo:B:c:D:e}", [MatchExpression([["foo"], ["B"], ["c"], ["D"], ["e"]])]),
(r"{\{}", [MatchExpression([["{"]])]),
(r"{\}}", [MatchExpression([["}"]])]),
(
r"p{foo:b{a{r}:t}:{ba}z}s",
[
"p",
MatchExpression(
[
["foo"],
[
"b",
MatchExpression(
[
["a", MatchExpression([["r"]])],
["t"],
],
),
],
[
MatchExpression(
[["ba"]],
),
"z",
],
],
),
"s",
],
),
("\\", ["\\"]),
(r"\d", ["\\d"]),
(r"C:\WINDOWS\foo\bar", [r"C:\WINDOWS\foo\bar"]),
],
)
def test_match_expr(value: str, exp_output: list[str | MatchExpression]) -> None:
assert find_replace_expr(value) == exp_output
@pytest.mark.parametrize(
("value", "exp_exception"),
[
("py-{foo,bar}", None),
("py37-{base,i18n},b", None),
("py37-{i18n,base},b", None),
("{toxinidir,}", None),
("{env}", r"MatchError\('No variable name was supplied in {env} substitution'\)"),
],
)
def test_dont_replace(replace_one: ReplaceOne, value: str, exp_exception: str | None) -> None:
"""Test that invalid expressions are not replaced."""
if exp_exception:
with pytest.raises(HandledError, match=exp_exception):
replace_one(value)
else:
assert replace_one(value) == value
@pytest.mark.parametrize(
("match_expression", "exp_repr"),
[
(MatchExpression([["posargs"]]), "MatchExpression(expr=[['posargs']], term_pos=None)"),
(MatchExpression([["posargs"]], 1), "MatchExpression(expr=[['posargs']], term_pos=1)"),
(MatchExpression("foo", -42), "MatchExpression(expr='foo', term_pos=-42)"),
],
)
def test_match_expression_repr(match_expression: MatchExpression, exp_repr: str) -> None:
print(match_expression) # noqa: T201
assert repr(match_expression) == exp_repr
tox-4.13.0/tests/config/loader/ini/replace/test_replace_env_var.py 0000664 0000000 0000000 00000016036 14564001166 0025235 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import threading
from typing import TYPE_CHECKING, Generator
import pytest
if TYPE_CHECKING:
from tests.config.loader.ini.replace.conftest import ReplaceOne
from tox.pytest import LogCaptureFixture, MonkeyPatch
def test_replace_env_set(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""If we have a factor that is not specified within the core env-list then that's also an environment"""
monkeypatch.setenv("MAGIC", "something good")
result = replace_one("{env:MAGIC}")
assert result == "something good"
def test_replace_env_set_double_bs(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""Double backslash should remain but not affect surrounding replacements."""
monkeypatch.setenv("MAGIC", "something good")
result = replace_one(r"{env:MAGIC}\\{env:MAGIC}")
assert result == r"something good\\something good"
def test_replace_env_set_triple_bs(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""Triple backslash should retain two slashes with the third escaping subsequent replacement."""
monkeypatch.setenv("MAGIC", "something good")
result = replace_one(r"{env:MAGIC}\\\{env:MAGIC}")
assert result == r"something good\\{env:MAGIC}"
def test_replace_env_set_quad_bs(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""Quad backslash should remain but not affect surrounding replacements."""
monkeypatch.setenv("MAGIC", "something good")
result = replace_one(r"\\{env:MAGIC}\\\\{env:MAGIC}" + "\\")
assert result == r"\\something good\\\\something good" + "\\"
def test_replace_env_when_value_is_backslash(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""When the replacement value is backslash, it shouldn't affect the next replacement."""
monkeypatch.setenv("MAGIC", "tragic")
monkeypatch.setenv("BS", "\\")
result = replace_one(r"{env:BS}{env:MAGIC}")
assert result == r"\tragic"
def test_replace_env_when_value_is_stuff_then_backslash(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""When the replacement value is a string containing backslash, it shouldn't affect the next replacement."""
monkeypatch.setenv("MAGIC", "tragic")
monkeypatch.setenv("BS", "stuff\\")
result = replace_one(r"{env:BS}{env:MAGIC}")
assert result == r"stuff\tragic"
def test_replace_env_missing(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""If we have a factor that is not specified within the core env-list then that's also an environment"""
monkeypatch.delenv("MAGIC", raising=False)
result = replace_one("{env:MAGIC}")
assert not result
def test_replace_env_missing_default(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""If we have a factor that is not specified within the core env-list then that's also an environment"""
monkeypatch.delenv("MAGIC", raising=False)
result = replace_one("{env:MAGIC:def}")
assert result == "def"
def test_replace_env_missing_default_from_env(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""If we have a factor that is not specified within the core env-list then that's also an environment"""
monkeypatch.delenv("MAGIC", raising=False)
monkeypatch.setenv("MAGIC_DEFAULT", "yes")
result = replace_one("{env:MAGIC:{env:MAGIC_DEFAULT}}")
assert result == "yes"
def test_replace_env_var_multiple(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""Multiple env substitutions on a single line."""
monkeypatch.setenv("MAGIC", "MAGIC")
monkeypatch.setenv("TRAGIC", "TRAGIC")
result = replace_one("{env:MAGIC} {env:TRAGIC} {env:MAGIC}")
assert result == "MAGIC TRAGIC MAGIC"
def test_replace_env_var_multiple_default(replace_one: ReplaceOne) -> None:
"""Multiple env substitutions on a single line with default values."""
result = replace_one("{env:MAGIC:foo} {env:TRAGIC:bar} {env:MAGIC:baz}")
assert result == "foo bar baz"
def test_replace_env_var_circular(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""Replacement values will not infinitely loop"""
monkeypatch.setenv("MAGIC", "{env:MAGIC}")
result = replace_one("{env:MAGIC}")
assert result == "{env:MAGIC}"
@pytest.fixture()
def reset_env_var_after_delay(monkeypatch: MonkeyPatch) -> Generator[threading.Thread, None, None]:
timeout = 2
def avoid_infinite_loop() -> None: # pragma: no cover
monkeypatch.setenv("TRAGIC", f"envvar forcibly reset after {timeout} sec")
timer = threading.Timer(2, avoid_infinite_loop)
timer.start()
yield timer
timer.cancel()
timer.join()
@pytest.mark.usefixtures("reset_env_var_after_delay")
def test_replace_env_var_circular_flip_flop(
replace_one: ReplaceOne,
monkeypatch: MonkeyPatch,
caplog: LogCaptureFixture,
) -> None:
"""Replacement values will not infinitely loop back and forth"""
monkeypatch.setenv("TRAGIC", "{env:MAGIC}")
monkeypatch.setenv("MAGIC", "{env:TRAGIC}")
result = replace_one("{env:MAGIC}")
assert result == "{env:MAGIC}"
assert "circular chain between set env MAGIC, TRAGIC" in caplog.messages
@pytest.mark.usefixtures("reset_env_var_after_delay")
def test_replace_env_var_circular_flip_flop_5(
replace_one: ReplaceOne,
monkeypatch: MonkeyPatch,
caplog: LogCaptureFixture,
) -> None:
"""Replacement values will not infinitely loop back and forth (longer chain)"""
monkeypatch.setenv("MAGIC", "{env:TRAGIC}")
monkeypatch.setenv("TRAGIC", "{env:RABBIT}")
monkeypatch.setenv("RABBIT", "{env:HAT}")
monkeypatch.setenv("HAT", "{env:TRICK}")
monkeypatch.setenv("TRICK", "{env:MAGIC}")
result = replace_one("{env:MAGIC}")
assert result == "{env:MAGIC}"
assert "circular chain between set env MAGIC, TRAGIC, RABBIT, HAT, TRICK" in caplog.messages
@pytest.mark.parametrize("fallback", [True, False])
def test_replace_env_var_chase(replace_one: ReplaceOne, monkeypatch: MonkeyPatch, fallback: bool) -> None:
"""Resolve variable to be replaced and default value via indirection."""
monkeypatch.setenv("WALK", "THIS")
def_val = "or that one"
monkeypatch.setenv("DEF", def_val)
if fallback:
monkeypatch.delenv("THIS", raising=False)
exp_result = def_val
else:
this_val = "path"
monkeypatch.setenv("THIS", this_val)
exp_result = this_val
result = replace_one("{env:{env:WALK}:{env:DEF}}")
assert result == exp_result
def test_replace_env_default_with_colon(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""If we have a factor that is not specified within the core env-list then that's also an environment"""
monkeypatch.delenv("MAGIC", raising=False)
result = replace_one("{env:MAGIC:https://some.url.org}")
assert result == "https://some.url.org"
def test_replace_env_default_deep(replace_one: ReplaceOne, monkeypatch: MonkeyPatch) -> None:
"""Get the value through a long tree of nested defaults."""
monkeypatch.delenv("M", raising=False)
assert replace_one("{env:M:{env:M:{env:M:{env:M:{env:M:foo}}}}}") == "foo"
tox-4.13.0/tests/config/loader/ini/replace/test_replace_os_pathsep.py 0000664 0000000 0000000 00000000446 14564001166 0025740 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from tests.config.loader.ini.replace.conftest import ReplaceOne
def test_replace_os_pathsep(replace_one: ReplaceOne) -> None:
result = replace_one("{:}")
assert result == os.pathsep
tox-4.13.0/tests/config/loader/ini/replace/test_replace_os_sep.py 0000664 0000000 0000000 00000002054 14564001166 0025060 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
from typing import TYPE_CHECKING
import pytest
if TYPE_CHECKING:
from tests.config.loader.ini.replace.conftest import ReplaceOne
from tox.pytest import MonkeyPatch
def test_replace_os_sep(replace_one: ReplaceOne) -> None:
result = replace_one("{/}")
assert result == os.sep
@pytest.mark.parametrize("sep", ["/", "\\"])
def test_replace_os_sep_before_curly(monkeypatch: MonkeyPatch, replace_one: ReplaceOne, sep: str) -> None:
"""Explicit test case for issue #2732 (windows only)."""
monkeypatch.setattr(os, "sep", sep)
monkeypatch.delenv("_", raising=False)
result = replace_one("{/}{env:_:foo}")
assert result == os.sep + "foo"
@pytest.mark.parametrize("sep", ["/", "\\"])
def test_replace_os_sep_sub_exp_regression(monkeypatch: MonkeyPatch, replace_one: ReplaceOne, sep: str) -> None:
monkeypatch.setattr(os, "sep", sep)
monkeypatch.delenv("_", raising=False)
result = replace_one("{env:_:{posargs}{/}.{posargs}}", ["foo"])
assert result == f"foo{os.sep}.foo"
tox-4.13.0/tests/config/loader/ini/replace/test_replace_posargs.py 0000664 0000000 0000000 00000005061 14564001166 0025247 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from typing import TYPE_CHECKING
import pytest
if TYPE_CHECKING:
from tests.config.loader.ini.replace.conftest import ReplaceOne
@pytest.mark.parametrize("syntax", ["{posargs}", "[]"])
def test_replace_pos_args_none_sys_argv(syntax: str, replace_one: ReplaceOne) -> None:
result = replace_one(syntax, None)
assert not result
@pytest.mark.parametrize("syntax", ["{posargs}", "[]"])
def test_replace_pos_args_empty_sys_argv(syntax: str, replace_one: ReplaceOne) -> None:
result = replace_one(syntax, [])
assert not result
@pytest.mark.parametrize("syntax", ["{posargs}", "[]"])
def test_replace_pos_args_extra_sys_argv(syntax: str, replace_one: ReplaceOne) -> None:
result = replace_one(syntax, [sys.executable, "magic"])
assert result == f"{sys.executable} magic"
@pytest.mark.parametrize("syntax", ["{posargs}", "[]"])
def test_replace_pos_args(syntax: str, replace_one: ReplaceOne) -> None:
result = replace_one(syntax, ["ok", "what", " yes "])
quote = '"' if sys.platform == "win32" else "'"
assert result == f"ok what {quote} yes {quote}"
@pytest.mark.parametrize(
("value", "result"),
[
("magic", "magic"),
("magic:colon", "magic:colon"),
("magic\n b c", "magic\nb c"), # an unescaped newline keeps the newline
("magi\\\n c d", "magic d"), # an escaped newline merges the lines
("\\{a\\}", "{a}"), # escaped curly braces
],
)
def test_replace_pos_args_default(replace_one: ReplaceOne, value: str, result: str) -> None:
outcome = replace_one(f"{{posargs:{value}}}", None)
assert result == outcome
@pytest.mark.parametrize(
"value",
[
"\\{posargs}",
"{posargs\\}",
"\\{posargs\\}",
"{\\{posargs}",
"{\\{posargs}{}",
"\\[]",
"[\\]",
"\\[\\]",
],
)
def test_replace_pos_args_escaped(replace_one: ReplaceOne, value: str) -> None:
result = replace_one(value, None)
outcome = value.replace("\\", "")
assert result == outcome
@pytest.mark.parametrize(
("value", "result"),
[
("[]-{posargs}", "foo-foo"),
("{posargs}-[]", "foo-foo"),
],
)
def test_replace_mixed_brackets_and_braces(replace_one: ReplaceOne, value: str, result: str) -> None:
outcome = replace_one(value, ["foo"])
assert result == outcome
def test_half_escaped_braces(replace_one: ReplaceOne) -> None:
"""See https://github.com/tox-dev/tox/issues/1956"""
outcome = replace_one(r"\{posargs} {posargs}", ["foo"])
assert outcome == "{posargs} foo"
tox-4.13.0/tests/config/loader/ini/replace/test_replace_tox_env.py 0000664 0000000 0000000 00000020166 14564001166 0025256 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from pathlib import Path
from typing import TYPE_CHECKING, Callable
import pytest
from tox.config.loader.ini.replace import MAX_REPLACE_DEPTH
from tox.config.sets import ConfigSet
from tox.report import HandledError
if TYPE_CHECKING:
from tests.config.loader.ini.replace.conftest import ReplaceOne
from tests.conftest import ToxIniCreator
from tox.pytest import LogCaptureFixture
EnvConfigCreator = Callable[[str], ConfigSet]
@pytest.fixture()
def example(tox_ini_conf: ToxIniCreator) -> EnvConfigCreator:
def func(conf: str) -> ConfigSet:
config = tox_ini_conf(f"""[tox]\nenv_list = a\n[testenv]\n{conf}\n""")
return config.get_env("a")
return func
def test_replace_within_tox_env(example: EnvConfigCreator) -> None:
env_config = example("r = 1\no = {r}")
env_config.add_config(keys="r", of_type=str, default="r", desc="r")
env_config.add_config(keys="o", of_type=str, default="o", desc="o")
result = env_config["o"]
assert result == "1"
def test_replace_within_tox_env_chain(example: EnvConfigCreator) -> None:
env_config = example("r = 1\no = {r}/2\np = {r} {o}")
env_config.add_config(keys="r", of_type=str, default="r", desc="r")
env_config.add_config(keys="o", of_type=str, default="o", desc="o")
env_config.add_config(keys="p", of_type=str, default="p", desc="p")
result = env_config["p"]
assert result == "1 1/2"
def test_replace_within_section_chain(tox_ini_conf: ToxIniCreator) -> None:
config = tox_ini_conf("[vars]\na = 1\nb = {[vars]a}/2\nc = {[vars]a}/3\n[testenv:a]\nd = {[vars]b} {[vars]c}")
env_config = config.get_env("a")
env_config.add_config(keys="d", of_type=str, default="d", desc="d")
result = env_config["d"]
assert result == "1/2 1/3"
@pytest.mark.parametrize("depth", [5, 99, 100, 101, 150, 256])
def test_replace_within_section_chain_deep(caplog: LogCaptureFixture, tox_ini_conf: ToxIniCreator, depth: int) -> None:
config = tox_ini_conf(
"\n".join(
[
"[vars]",
"a0 = 1",
*(f"a{ix} = {{[vars]a{ix - 1}}}" for ix in range(1, depth + 1)),
"[testenv:a]",
"b = {[vars]a%s}" % depth,
],
),
)
env_config = config.get_env("a")
env_config.add_config(keys="b", of_type=str, default="b", desc="b")
result = env_config["b"]
if depth > MAX_REPLACE_DEPTH:
exp_stopped_at = "{[vars]a%s}" % (depth - MAX_REPLACE_DEPTH - 1)
assert result == exp_stopped_at
assert f"Could not expand {exp_stopped_at} after recursing {MAX_REPLACE_DEPTH + 1} frames" in caplog.messages
else:
assert result == "1"
def test_replace_within_tox_env_missing_raises(example: EnvConfigCreator) -> None:
env_config = example("o = {p}")
env_config.add_config(keys="o", of_type=str, default="o", desc="o")
assert env_config["o"] == "{p}"
def test_replace_within_tox_env_missing_default(example: EnvConfigCreator) -> None:
env_config = example("o = {p:one}")
env_config.add_config(keys="o", of_type=str, default="o", desc="o")
result = env_config["o"]
assert result == "one"
def test_replace_within_tox_env_missing_default_env_only(example: EnvConfigCreator) -> None:
env_config = example("o = {[testenv:a]p:one}")
env_config.add_config(keys="o", of_type=str, default="o", desc="o")
result = env_config["o"]
assert result == "one"
def test_replace_within_tox_env_missing_no_default(example: EnvConfigCreator) -> None:
env_config = example("o = {[testenv:b]p}")
env_config.add_config(keys="o", of_type=str, default="o", desc="o")
assert env_config["o"] == "{[testenv:b]p}"
def test_replace_within_tox_env_from_base(example: EnvConfigCreator) -> None:
env_config = example("p = one\n[testenv:a]\no = {[testenv]p}")
env_config.add_config(keys="p", of_type=str, default="p", desc="p")
env_config.add_config(keys="o", of_type=str, default="o", desc="o")
result = env_config["o"]
assert result == "one"
def test_replace_ref_bad_type(tox_ini_conf: ToxIniCreator) -> None:
config = tox_ini_conf("[testenv:a]\nx = {[testenv:b]v}\n[testenv:b]\nv=1")
class BadType:
def __init__(self, value: str) -> None:
if value != "magic":
raise ValueError(value)
conf_b = config.get_env("b")
conf_b.add_config(keys="v", of_type=BadType, default=BadType("magic"), desc="p")
conf_a = config.get_env("a")
conf_a.add_config(keys="x", of_type=str, default="o", desc="o")
with pytest.raises(HandledError, match=r"replace failed in a.x with ValueError.*'1'.*"):
assert conf_a["x"]
@pytest.mark.parametrize(
("start", "end"),
[
("0", "0"),
("0}", "0}"),
("{0", "{0"),
("{0}", "{0}"),
("{}{0}", "{}{0}"),
("{0}{}", "{0}{}"),
("\\{0}", "{0}"),
("{0\\}", "{0}"),
("\\{0\\}", "{0}"),
("f\\{0\\}", "f{0}"),
("\\{0\\}f", "{0}f"),
("\\{\\{0", "{{0"),
("0\\}\\}", "0}}"),
("\\{\\{0\\}\\}", "{{0}}"),
],
)
def test_do_not_replace(replace_one: ReplaceOne, start: str, end: str) -> None:
"""If we have a factor that is not specified within the core env-list then that's also an environment"""
value = replace_one(start)
assert value == end
def test_replace_from_tox_section_non_registered(tox_ini_conf: ToxIniCreator) -> None:
conf_a = tox_ini_conf("[tox]\na=1\n[testenv:a]\nx = {[tox]a}").get_env("a")
conf_a.add_config(keys="x", of_type=str, default="o", desc="o")
assert conf_a["x"] == "1"
def test_replace_from_tox_section_missing_section(tox_ini_conf: ToxIniCreator) -> None:
conf_a = tox_ini_conf("[testenv:a]\nx = {[magic]a}").get_env("a")
conf_a.add_config(keys="x", of_type=str, default="o", desc="o")
assert conf_a["x"] == "{[magic]a}"
def test_replace_from_tox_section_key_with_dash(tox_ini_conf: ToxIniCreator) -> None:
conf_a = tox_ini_conf("[testenv:a]\nx = {[magic]a-b}\n[magic]\na-b=1").get_env("a")
conf_a.add_config(keys="x", of_type=str, default="o", desc="o")
assert conf_a["x"] == "1"
def test_replace_circular(tox_ini_conf: ToxIniCreator) -> None:
conf_a = tox_ini_conf("[testenv:a]\nx = {y}\ny = {x}").get_env("a")
conf_a.add_config(keys="x", of_type=str, default="o", desc="o")
conf_a.add_config(keys="y", of_type=str, default="n", desc="n")
with pytest.raises(HandledError) as exc:
assert conf_a["x"]
assert "circular chain detected testenv:a.x, testenv:a.y" in str(exc.value)
def test_replace_from_tox_section_missing_value(tox_ini_conf: ToxIniCreator) -> None:
conf_a = tox_ini_conf("[testenv:e]\nx = {[m]a}\n[m]").get_env("e")
conf_a.add_config(keys="x", of_type=str, default="o", desc="d")
assert conf_a["x"] == "{[m]a}"
def test_replace_from_section_bad_type(tox_ini_conf: ToxIniCreator) -> None:
conf_a = tox_ini_conf("[testenv:e]\nx = {[m]a}\n[m]\na=w\n").get_env("e")
conf_a.add_config(keys="x", of_type=int, default=1, desc="d")
with pytest.raises(ValueError, match="invalid literal.*w.*"):
assert conf_a["x"]
def test_replace_from_tox_section_registered(tox_ini_conf: ToxIniCreator, tmp_path: Path) -> None:
conf_a = tox_ini_conf("[testenv:a]\nx = {[tox]tox_root}").get_env("a")
conf_a.add_config(keys="x", of_type=Path, default=Path.cwd() / "magic", desc="d")
assert conf_a["x"] == (tmp_path / "c")
def test_replace_from_tox_other_tox_section_same_name(tox_ini_conf: ToxIniCreator) -> None:
conf_a = tox_ini_conf("[testenv:a]\nx={[testenv:b]c}\nc=d\n[testenv:b]}").get_env("a")
conf_a.add_config(keys="x", of_type=str, default="", desc="d")
assert conf_a["x"] == "{[testenv:b]c}"
@pytest.mark.parametrize(
("env_name", "exp"),
[
("testenv:foobar", "1"),
("testenv:foo-bar", "1"),
("foo-bar", "1"),
("foobar", "1"),
],
)
def test_replace_valid_section_names(tox_ini_conf: ToxIniCreator, env_name: str, exp: str) -> None:
conf_a = tox_ini_conf(f"[{env_name}]\na={exp}\n[testenv:a]\nx = {{[{env_name}]a}}").get_env("a")
conf_a.add_config(keys="x", of_type=str, default="o", desc="o")
assert conf_a["x"] == exp
tox-4.13.0/tests/config/loader/ini/replace/test_replace_tty.py 0000664 0000000 0000000 00000001271 14564001166 0024410 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from typing import TYPE_CHECKING
import pytest
if TYPE_CHECKING:
from pytest_mock import MockFixture
from tests.config.loader.ini.replace.conftest import ReplaceOne
@pytest.mark.parametrize("is_atty", [True, False])
def test_replace_env_set(replace_one: ReplaceOne, mocker: MockFixture, is_atty: bool) -> None:
mocker.patch.object(sys.stdout, "isatty", return_value=is_atty)
result = replace_one("1 {tty} 2")
assert result == "1 2"
result = replace_one("1 {tty:a} 2")
assert result == f"1 {'a' if is_atty else ''} 2"
result = replace_one("1 {tty:a:b} 2")
assert result == f"1 {'a' if is_atty else 'b'} 2"
tox-4.13.0/tests/config/loader/ini/test_factor.py 0000664 0000000 0000000 00000014545 14564001166 0021750 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from textwrap import dedent
from typing import TYPE_CHECKING, Callable, List
import pytest
from tox.config.loader.ini import IniLoader
from tox.config.loader.ini.factor import filter_for_env, find_envs
from tox.config.source.ini_section import IniSection
if TYPE_CHECKING:
from configparser import ConfigParser
from tests.conftest import ToxIniCreator
from tox.config.main import Config
def test_factor_env_discover_empty() -> None:
result = list(find_envs("\n\n"))
assert result == []
@pytest.fixture(scope="session")
def complex_example() -> str:
return dedent(
"""
default
lines
py: py only
!py: not py
{py,!pi}-{a,b}{,-dev},c: complex
py, d: space
extra: extra
more-default
no:space
trailingcolon:
tab:\ttab
""",
)
def test_factor_env_discover(complex_example: str) -> None:
result = list(find_envs(complex_example))
assert result == [
"py",
"py-a",
"py-a-dev",
"py-b",
"py-b-dev",
"pi-a",
"pi-a-dev",
"pi-b",
"pi-b-dev",
"c",
"d",
"extra",
"trailingcolon",
"tab",
]
@pytest.mark.parametrize(
"env",
[
"py",
"py-a",
"py-a-dev",
"py-b",
"py-b-dev",
"pi-a",
"pi-a-dev",
"pi-b",
"pi-b-dev",
"c",
"extra",
"trailingcolon",
"tab",
],
)
def test_factor_env_filter(env: str, complex_example: str) -> None:
result = filter_for_env(complex_example, name=env)
assert "default" in result
assert "lines" in result
assert "more-default" in result
assert "no:space" in result
if "py" in env:
assert "py only" in result
assert "not py" not in result
else:
assert "py only" not in result
assert "not py" in result
if env == "extra":
assert "extra" in result
else:
assert "extra" not in result
if env in {"py-a", "py-a-dev", "py-b", "py-b-dev", "c"}:
assert "complex" in result
else:
assert "complex" not in result
def test_factor_env_list(tox_ini_conf: ToxIniCreator) -> None:
config = tox_ini_conf("[tox]\nenv_list = {py27,py36}-django{ 15, 16 }{,-dev}, docs, flake")
result = list(config)
assert result == [
"py27-django15",
"py27-django15-dev",
"py27-django16",
"py27-django16-dev",
"py36-django15",
"py36-django15-dev",
"py36-django16",
"py36-django16-dev",
"docs",
"flake",
]
def test_simple_env_list(tox_ini_conf: ToxIniCreator) -> None:
config = tox_ini_conf("[tox]\nenv_list = docs, flake8")
assert list(config) == ["docs", "flake8"]
def test_factor_config(tox_ini_conf: ToxIniCreator) -> None:
config = tox_ini_conf(
"""
[tox]
env_list = {py36,py37}-{django15,django16}
[testenv]
deps-x =
pytest
django15: Django>=1.5,<1.6
django16: Django>=1.6,<1.7
py36: unittest2
!py37,!django16: negation-or
!py37-!django16: negation-and
""",
)
assert list(config) == ["py36-django15", "py36-django16", "py37-django15", "py37-django16"]
for env in config.core["env_list"]:
env_config = config.get_env(env)
env_config.add_config(keys="deps-x", of_type=List[str], default=[], desc="deps")
deps = env_config["deps-x"]
assert "pytest" in deps
if "py36" in env:
assert "unittest2" in deps
assert "negation-or" in deps
if "django15" in env:
assert "Django>=1.5,<1.6" in deps
assert "negation-or" in deps
if "django16" in env:
assert "Django>=1.6,<1.7" in deps
if env_config.name == "py36-django15":
assert "negation-and" in deps
def test_factor_config_do_not_replace_unescaped_comma(tox_ini_conf: ToxIniCreator) -> None:
config = tox_ini_conf("[tox]\nenv_list = py37-{base,i18n},b")
assert list(config) == ["py37-base", "py37-i18n", "b"]
def test_factor_config_no_env_list_creates_env(tox_ini_conf: ToxIniCreator) -> None:
"""If we have a factor that is not specified within the core env-list then that's also an environment"""
config = tox_ini_conf(
"""
[tox]
env_list = py37-{django15,django16}
[testenv]
deps =
pytest
django15: Django>=1.5,<1.6
django16: Django>=1.6,<1.7
py36: unittest2
""",
)
assert list(config) == ["py37-django15", "py37-django16", "py36"]
@pytest.mark.parametrize(
("env", "result"),
[
("py35", "python -m coverage html -d cov"),
("py36", "python -m coverage html -d cov\n--show-contexts"),
],
)
def test_ini_loader_raw_with_factors(
mk_ini_conf: Callable[[str], ConfigParser],
env: str,
result: str,
empty_config: Config,
) -> None:
commands = "python -m coverage html -d cov \n !py35: --show-contexts"
loader = IniLoader(
section=IniSection(None, "testenv"),
parser=mk_ini_conf(f"[tox]\nenvlist=py35,py36\n[testenv]\ncommands={commands}"),
overrides=[],
core_section=IniSection(None, "tox"),
)
outcome = loader.load_raw(key="commands", conf=empty_config, env_name=env)
assert outcome == result
def test_generative_section_name(tox_ini_conf: ToxIniCreator) -> None:
config = tox_ini_conf(
"""
[testenv:{py311,py310}-{black,lint}]
deps-x =
black: black
lint: flake8
""",
)
assert list(config) == ["py311-black", "py311-lint", "py310-black", "py310-lint"]
env_config = config.get_env("py311-black")
env_config.add_config(keys="deps-x", of_type=List[str], default=[], desc="deps")
deps = env_config["deps-x"]
assert deps == ["black"]
env_config = config.get_env("py311-lint")
env_config.add_config(keys="deps-x", of_type=List[str], default=[], desc="deps")
deps = env_config["deps-x"]
assert deps == ["flake8"]
def test_multiple_factor_match(tox_ini_conf: ToxIniCreator) -> None:
config = tox_ini_conf("[testenv]\nconf = a{,-b}: x")
env_config = config.get_env("a-b")
env_config.add_config(keys="conf", of_type=str, default="", desc="conf")
deps = env_config["conf"]
assert deps == "x"
tox-4.13.0/tests/config/loader/ini/test_ini_loader.py 0000664 0000000 0000000 00000005416 14564001166 0022574 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING, Callable
import pytest
from tox.config.loader.api import ConfigLoadArgs, Override
from tox.config.loader.ini import IniLoader
from tox.config.source.ini_section import IniSection
if TYPE_CHECKING:
from configparser import ConfigParser
def test_ini_loader_keys(mk_ini_conf: Callable[[str], ConfigParser]) -> None:
core = IniSection(None, "tox")
loader = IniLoader(core, mk_ini_conf("\n[tox]\n\na=b\nc=d\n\n"), [], core_section=core)
assert loader.found_keys() == {"a", "c"}
def test_ini_loader_repr(mk_ini_conf: Callable[[str], ConfigParser]) -> None:
core = IniSection(None, "tox")
loader = IniLoader(core, mk_ini_conf("\n[tox]\n\na=b\nc=d\n\n"), [Override("tox.a=1")], core_section=core)
assert repr(loader) == "IniLoader(section=tox, overrides={'a': Override('tox.a=1')})"
def test_ini_loader_has_section(mk_ini_conf: Callable[[str], ConfigParser]) -> None:
core = IniSection(None, "tox")
loader = IniLoader(core, mk_ini_conf("[magic]\n[tox]\n\na=b\nc=d\n\n"), [], core_section=core)
assert loader.get_section("magic") is not None
def test_ini_loader_has_no_section(mk_ini_conf: Callable[[str], ConfigParser]) -> None:
core = IniSection(None, "tox")
loader = IniLoader(core, mk_ini_conf("[tox]\n\na=b\nc=d\n\n"), [], core_section=core)
assert loader.get_section("magic") is None
def test_ini_loader_raw(mk_ini_conf: Callable[[str], ConfigParser]) -> None:
core = IniSection(None, "tox")
args = ConfigLoadArgs([], "name", None)
loader = IniLoader(core, mk_ini_conf("[tox]\na=b"), [], core_section=core)
result = loader.load(key="a", of_type=str, conf=None, factory=None, args=args)
assert result == "b"
@pytest.mark.parametrize("sep", ["\n", "\r\n"])
def test_ini_loader_raw_strip_escaped_newline(mk_ini_conf: Callable[[str], ConfigParser], sep: str) -> None:
core = IniSection(None, "tox")
args = ConfigLoadArgs([], "name", None)
loader = IniLoader(core, mk_ini_conf(f"[tox]{sep}a=b\\{sep} c"), [], core_section=core)
result = loader.load(key="a", of_type=str, conf=None, factory=None, args=args)
assert result == "bc"
@pytest.mark.parametrize(
("case", "result"),
[
("# a", ""),
("#", ""),
("a # w", "a"),
("a\t# w", "a"),
("a# w", "a"),
("a\\# w", "a# w"),
("#a\n b # w\n w", "b\nw"),
],
)
def test_ini_loader_strip_comments(mk_ini_conf: Callable[[str], ConfigParser], case: str, result: str) -> None:
core = IniSection(None, "tox")
args = ConfigLoadArgs([], "name", None)
loader = IniLoader(core, mk_ini_conf(f"[tox]\na={case}"), [], core_section=core)
outcome = loader.load(key="a", of_type=str, conf=None, factory=None, args=args)
assert outcome == result
tox-4.13.0/tests/config/loader/test_loader.py 0000664 0000000 0000000 00000003123 14564001166 0021147 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
import pytest
from tox.config.cli.parse import get_options
from tox.config.loader.api import Override
if TYPE_CHECKING:
from tox.pytest import CaptureFixture
@pytest.mark.parametrize("flag", ["-x", "--override"])
def test_override_incorrect(flag: str, capsys: CaptureFixture) -> None:
with pytest.raises(SystemExit):
get_options(flag, "magic")
out, err = capsys.readouterr()
assert not out
assert "override magic has no = sign in it" in err
@pytest.mark.parametrize("flag", ["-x", "--override"])
def test_override_add(flag: str) -> None:
parsed, _, __, ___, ____ = get_options(flag, "magic=true")
assert len(parsed.override) == 1
value = parsed.override[0]
assert value.key == "magic"
assert value.value == "true"
assert not value.namespace
assert value.append is False
@pytest.mark.parametrize("flag", ["-x", "--override"])
def test_override_append(flag: str) -> None:
parsed, _, __, ___, ____ = get_options(flag, "magic+=true")
assert len(parsed.override) == 1
value = parsed.override[0]
assert value.key == "magic"
assert value.value == "true"
assert not value.namespace
assert value.append is True
def test_override_equals() -> None:
assert Override("a=b") == Override("a=b")
def test_override_not_equals() -> None:
assert Override("a=b") != Override("c=d")
def test_override_not_equals_different_type() -> None:
assert Override("a=b") != 1
def test_override_repr() -> None:
assert repr(Override("b.a=c")) == "Override('b.a=c')"
tox-4.13.0/tests/config/loader/test_memory_loader.py 0000664 0000000 0000000 00000005723 14564001166 0022547 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
from pathlib import Path
from typing import Any, Dict, List, Optional, Set
import pytest
from tox.config.loader.api import ConfigLoadArgs, Override
from tox.config.loader.memory import MemoryLoader
from tox.config.types import Command, EnvList
def test_memory_loader_repr() -> None:
loader = MemoryLoader(a=1)
assert repr(loader) == "MemoryLoader"
def test_memory_loader_override() -> None:
loader = MemoryLoader(a=1)
loader.overrides["a"] = Override("a=2")
args = ConfigLoadArgs([], "name", None)
loaded = loader.load("a", of_type=int, conf=None, factory=None, args=args)
assert loaded == 2
@pytest.mark.parametrize(
("value", "of_type", "outcome"),
[
(True, bool, True),
(1, int, 1),
("magic", str, "magic"),
({"1"}, Set[str], {"1"}),
([1], List[int], [1]),
({1: 2}, Dict[int, int], {1: 2}),
(Path.cwd(), Path, Path.cwd()),
(Command(["a"]), Command, Command(["a"])),
(EnvList("a,b"), EnvList, EnvList("a,b")),
(1, Optional[int], 1),
("1", Optional[str], "1"),
(0, bool, False),
(1, bool, True),
("1", int, 1),
(1, str, "1"),
({1}, Set[str], {"1"}),
({"1"}, List[int], [1]),
({"1": "2"}, Dict[int, int], {1: 2}),
(os.getcwd(), Path, Path.cwd()), # noqa: PTH109
("pip list", Command, Command(["pip", "list"])),
("a\nb", EnvList, EnvList(["a", "b"])),
("1", Optional[int], 1),
],
)
def test_memory_loader(value: Any, of_type: type[Any], outcome: Any) -> None:
loader = MemoryLoader(a=value, kwargs={})
args = ConfigLoadArgs([], "name", None)
loaded = loader.load("a", of_type=of_type, conf=None, factory=None, args=args)
assert loaded == outcome
@pytest.mark.parametrize(
("value", "of_type", "exception", "msg"),
[
("m", int, ValueError, "invalid literal for int"),
({"m"}, Set[int], ValueError, "invalid literal for int"),
(["m"], List[int], ValueError, "invalid literal for int"),
({"m": 1}, Dict[int, int], ValueError, "invalid literal for int"),
({1: "m"}, Dict[int, int], ValueError, "invalid literal for int"),
(object, Path, TypeError, r"str(, bytes)? or (an )?os\.PathLike object"),
(1, Command, TypeError, "1"),
(1, EnvList, TypeError, "1"),
],
)
def test_memory_loader_fails_invalid(value: Any, of_type: type[Any], exception: Exception, msg: str) -> None:
loader = MemoryLoader(a=value, kwargs={})
args = ConfigLoadArgs([], "name", None)
with pytest.raises(exception, match=msg): # type: ignore[call-overload]
loader.load("a", of_type=of_type, conf=None, factory=None, args=args)
def test_memory_found_keys() -> None:
loader = MemoryLoader(a=1, c=2)
assert loader.found_keys() == {"a", "c"}
def test_memory_loader_contains() -> None:
loader = MemoryLoader(a=1)
assert "a" in loader
assert "b" not in loader
tox-4.13.0/tests/config/loader/test_section.py 0000664 0000000 0000000 00000002012 14564001166 0021341 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import Any
import pytest
from tox.config.loader.section import Section
@pytest.mark.parametrize(
("section", "outcome"),
[
(Section("a", "b"), "a:b"),
(Section(None, "a"), "a"),
],
)
def test_section_str(section: Section, outcome: str) -> None:
assert str(section) == outcome
@pytest.mark.parametrize(
("section", "outcome"),
[
(Section("a", "b"), "Section(prefix='a', name='b')"),
(Section(None, "a"), "Section(prefix=None, name='a')"),
],
)
def test_section_repr(section: Section, outcome: str) -> None:
assert repr(section) == outcome
def test_section_eq() -> None:
assert Section(None, "a") == Section(None, "a")
@pytest.mark.parametrize(
("section", "other"),
[
(Section("a", "b"), "a-b"),
(Section(None, "a"), Section("b", "a")),
(Section("a", "b"), Section("a", "c")),
],
)
def test_section_not_eq(section: Section, other: Any) -> None:
assert section != other
tox-4.13.0/tests/config/loader/test_str_convert.py 0000664 0000000 0000000 00000015301 14564001166 0022252 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from pathlib import Path
from textwrap import dedent
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, TypeVar, Union
import pytest
from tox.config.loader.str_convert import StrConvert
from tox.config.types import Command, EnvList
if TYPE_CHECKING:
from tox.pytest import MonkeyPatch, SubRequest, ToxProjectCreator
from typing import Literal
@pytest.mark.parametrize(
("raw", "value", "of_type"),
[
("true", True, bool),
("false", False, bool),
("True", True, bool),
("False", False, bool),
("TruE", True, bool),
("FalsE", False, bool),
("1", True, bool),
("0", False, bool),
("1", 1, int),
("0", 0, int),
("+1", 1, int),
("-1", -1, int),
("1.1", 1.1, float),
("0.1", 0.1, float),
("+1.1", 1.1, float),
("-1.1", -1.1, float),
("magic", "magic", str),
("1", {"1"}, Set[str]),
("1", [1], List[int]),
("1=2", {1: 2}, Dict[int, int]),
("a=1\n\nc=2", {"a": 1, "c": 2}, Dict[str, int]),
("a", Path("a"), Path),
("a", Command(["a"]), Command),
("a,b", EnvList(["a", "b"]), EnvList),
("", None, Optional[int]),
("1", 1, Optional[int]),
("", None, Optional[str]),
("1", "1", Optional[str]),
("", None, Optional[List[str]]),
("1,2", ["1", "2"], Optional[List[str]]),
("1", "1", Literal["1", "2"]),
],
)
def test_str_convert_ok(raw: str, value: Any, of_type: type[Any]) -> None:
result = StrConvert().to(raw, of_type, None)
assert result == value
@pytest.mark.parametrize(
("raw", "of_type", "exc_type", "msg"),
[
("a", TypeVar, TypeError, r"a cannot cast to .*typing.TypeVar.*"),
("3", Literal["1", "2"], ValueError, r"3 must be one of \('1', '2'\)"),
("3", Union[str, int], TypeError, r"3 cannot cast to typing.Union\[str, int\]"),
("", Command, ValueError, r"attempting to parse '' into a command failed"),
],
)
def test_str_convert_nok(raw: str, of_type: type[Any], msg: str, exc_type: type[Exception]) -> None:
with pytest.raises(exc_type, match=msg):
StrConvert().to(raw, of_type, None)
@pytest.mark.parametrize(
("value", "expected"),
[
("python ' ok", ["python", "' ok"]),
('python " ok', ["python", '" ok']),
],
)
def test_invalid_shell_expression(value: str, expected: list[str]) -> None:
result = StrConvert().to_command(value).args
assert result == expected
SIMPLE_ARGS = [
('foo "bar baz"', ["foo", "bar baz"]),
('foo "bar baz"ext', ["foo", "bar bazext"]),
('foo="bar baz"', ["foo=bar baz"]),
("foo 'bar baz'", ["foo", "bar baz"]),
("foo 'bar baz'ext", ["foo", "bar bazext"]),
("foo='bar baz'", ["foo=bar baz"]),
(r"foo=\"bar baz\"", ['foo="bar', 'baz"']),
(r'foo="bar baz\"', ['foo="bar baz\\"']),
("foo='bar baz' quuc", ["foo=bar baz", "quuc"]),
(r"foo='bar baz\' quuc", ["foo=bar baz\\", "quuc"]),
(r"foo=\"bar baz\' quuc", ['foo="bar', "baz'", "quuc"]),
(r"foo=\\\"bar baz\"", ['foo=\\"bar', 'baz"']),
(r'foo=\\"bar baz\"', [r'foo=\\"bar baz\"']),
]
NEWLINE_ARGS = [
('foo\n"bar\nbaz"', ["foo", "bar\nbaz"]),
]
INI_CONFIG_NEWLINE_ARGS = [
('foo\\\n "bar\\\n baz"', ["foobarbaz"]), # behavior change from tox 3
('foo\\\n "bar \\\n baz"', ["foobar baz"]), # behavior change from tox 3
('foo \\\n "bar\\\n baz"', ["foo", "barbaz"]),
('foo \\\n "bar \\\n baz"', ["foo", "bar baz"]),
('foo \\\n \\"bar \\\n baz"', ["foo", '"bar', 'baz"']),
("foo \\\n bar \\\n baz", ["foo", "bar", "baz"]),
]
WINDOWS_PATH_ARGS = [
(r"SPECIAL:\foo\bar --quuz='baz atan'", [r"SPECIAL:\foo\bar", "--quuz=baz atan"]),
(r"X:\\foo\\bar --quuz='baz atan'", [r"X:\foo\bar", "--quuz=baz atan"]),
("/foo/bar --quuz='baz atan'", ["/foo/bar", "--quuz=baz atan"]),
('cc --arg "C:\\\\Users\\""', ["cc", "--arg", 'C:\\Users"']),
('cc --arg "C:\\\\Users\\"', ["cc", "--arg", '"C:\\\\Users\\"']),
('cc --arg "C:\\\\Users"', ["cc", "--arg", "C:\\Users"]),
('cc --arg \\"C:\\\\Users"', ["cc", "--arg", '\\"C:\\\\Users"']),
('cc --arg "C:\\\\Users\\ "', ["cc", "--arg", "C:\\Users\\ "]),
('cc --arg "C:\\\\Users\\\\"', ["cc", "--arg", "C:\\Users\\"]),
('cc --arg "C:\\\\Users\\\\ "', ["cc", "--arg", "C:\\Users\\ "]),
(
r'cc --arg C:\\Users\\ --arg2 "SPECIAL:\Temp\f o o" --arg3="\\FOO\share\Path name" --arg4 SPECIAL:\Temp\ '[:-1],
[
"cc",
"--arg",
"C:\\Users\\",
"--arg2",
"SPECIAL:\\Temp\\f o o",
"--arg3=\\FOO\\share\\Path name",
"--arg4",
"SPECIAL:\\Temp\\",
],
),
]
WACKY_SLASH_ARGS = [
("\\\\\\", ["\\\\\\"]),
(" \\'\\'\\ '", [" \\'\\'\\ '"]),
("\\'\\'\\ ", ["'' "]),
("\\'\\ \\\\", ["' \\"]),
("\\'\\ ", ["' "]),
('''"\\'\\"''', ['"\\\'\\"']),
("'\\' \\\\", ["\\", "\\"]),
('"\\\\" \\\\', ["\\", "\\"]),
]
@pytest.fixture(params=["win32", "linux2"])
def sys_platform(request: SubRequest, monkeypatch: MonkeyPatch) -> str:
monkeypatch.setattr(sys, "platform", request.param)
return str(request.param)
@pytest.mark.parametrize(
("value", "expected"),
[
*SIMPLE_ARGS,
*NEWLINE_ARGS,
*WINDOWS_PATH_ARGS,
*WACKY_SLASH_ARGS,
],
)
def test_shlex_platform_specific(sys_platform: str, value: str, expected: list[str]) -> None:
if sys_platform != "win32" and value.startswith("SPECIAL:"):
# on non-windows platform, backslash is always an escape, not path separator
expected = [exp.replace("\\", "") for exp in expected]
result = StrConvert().to_command(value).args
assert result == expected
@pytest.mark.parametrize(
("value", "expected"),
[
*SIMPLE_ARGS,
*INI_CONFIG_NEWLINE_ARGS,
*WINDOWS_PATH_ARGS,
# *WACKY_SLASH_ARGS,
],
)
def test_shlex_platform_specific_ini(
tox_project: ToxProjectCreator,
sys_platform: str,
value: str,
expected: list[str],
) -> None:
if sys_platform != "win32" and value.startswith("SPECIAL:"):
# on non-windows platform, backslash is always an escape, not path separator
expected = [exp.replace("\\", "") for exp in expected]
project = tox_project(
{
"tox.ini": dedent(
"""
[testenv]
commands =
%s""",
)
% value,
},
)
outcome = project.run("c")
outcome.assert_success()
env_config = outcome.env_conf("py")
result = env_config["commands"]
assert result == [Command(args=expected)]
tox-4.13.0/tests/config/source/ 0000775 0000000 0000000 00000000000 14564001166 0016323 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/config/source/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0020422 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/config/source/test_discover.py 0000664 0000000 0000000 00000003202 14564001166 0021547 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from pathlib import Path
from tox.pytest import ToxProjectCreator
def out_no_src(path: Path) -> str:
return (
f"ROOT: No tox.ini or setup.cfg or pyproject.toml found, assuming empty tox.ini at {path}\n"
f"default environments:\npy -> [no description]\n"
)
def test_no_src_cwd(tox_project: ToxProjectCreator) -> None:
project = tox_project({})
outcome = project.run("l")
outcome.assert_success()
assert outcome.out == out_no_src(project.path)
assert outcome.state.conf.src_path == (project.path / "tox.ini")
def test_no_src_has_py_project_toml_above(tox_project: ToxProjectCreator, tmp_path: Path) -> None:
(tmp_path / "pyproject.toml").write_text("")
project = tox_project({})
outcome = project.run("l")
outcome.assert_success()
assert outcome.out == out_no_src(tmp_path)
assert outcome.state.conf.src_path == (tmp_path / "tox.ini")
def test_no_src_root_dir(tox_project: ToxProjectCreator, tmp_path: Path) -> None:
root = tmp_path / "root"
root.mkdir()
project = tox_project({})
outcome = project.run("l", "--root", str(root))
outcome.assert_success()
assert outcome.out == out_no_src(root)
assert outcome.state.conf.src_path == (root / "tox.ini")
def test_bad_src_content(tox_project: ToxProjectCreator, tmp_path: Path) -> None:
project = tox_project({})
outcome = project.run("l", "-c", str(tmp_path / "setup.cfg"))
outcome.assert_failed()
assert outcome.out == f"ROOT: HandledError| could not recognize config file {tmp_path / 'setup.cfg'}\n"
tox-4.13.0/tests/config/source/test_legacy_toml.py 0000664 0000000 0000000 00000000731 14564001166 0022234 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from tox.pytest import ToxProjectCreator
def test_conf_in_legacy_toml(tox_project: ToxProjectCreator) -> None:
project = tox_project({"pyproject.toml": '[tool.tox]\nlegacy_tox_ini="""[tox]\nenv_list=\n a\n b\n"""'})
outcome = project.run("l")
outcome.assert_success()
assert outcome.out == "default environments:\na -> [no description]\nb -> [no description]\n"
tox-4.13.0/tests/config/source/test_setup_cfg.py 0000664 0000000 0000000 00000001427 14564001166 0021717 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from tox.pytest import ToxProjectCreator
def test_conf_in_setup_cfg(tox_project: ToxProjectCreator) -> None:
project = tox_project({"setup.cfg": "[tox:tox]\nenv_list=\n a\n b"})
outcome = project.run("l")
outcome.assert_success()
assert outcome.out == "default environments:\na -> [no description]\nb -> [no description]\n"
def test_bad_conf_setup_cfg(tox_project: ToxProjectCreator) -> None:
project = tox_project({"setup.cfg": "[tox]\nenv_list=\n a\n b"})
filename = str(project.path / "setup.cfg")
outcome = project.run("l", "-c", filename)
outcome.assert_failed()
assert outcome.out == f"ROOT: HandledError| could not recognize config file {filename}\n"
tox-4.13.0/tests/config/source/test_source_ini.py 0000664 0000000 0000000 00000003354 14564001166 0022100 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
from tox.config.loader.section import Section
from tox.config.sets import ConfigSet
from tox.config.source.ini import IniSource
if TYPE_CHECKING:
from pathlib import Path
from tests.conftest import ToxIniCreator
def test_source_ini_with_interpolated(tmp_path: Path) -> None:
loader = IniSource(tmp_path, content="[tox]\na = %(c)s").get_loader(Section(None, "tox"), {})
assert loader is not None
loader.load_raw("a", None, None)
def test_source_ini_ignore_non_testenv_sections(tmp_path: Path) -> None:
loader = IniSource(tmp_path, content="[mypy-rest_framework.compat.*]")
res = list(loader.envs({"env_list": []})) # type: ignore[arg-type]
assert not res
def test_source_ini_ignore_invalid_factor_filters(tmp_path: Path) -> None:
loader = IniSource(tmp_path, content="[a]\nb= if c: d")
res = list(loader.envs({"env_list": []})) # type: ignore[arg-type]
assert not res
def test_source_ini_custom_non_testenv_sections(tox_ini_conf: ToxIniCreator) -> None:
"""Validate that a plugin can load section with custom prefix overlapping testenv name."""
class CustomConfigSet(ConfigSet):
def register_config(self) -> None:
self.add_config(
keys=["a"],
of_type=str,
default="",
desc="d",
)
config = tox_ini_conf("[testenv:foo]\n[custom:foo]\na = b")
known_envs = list(config._src.envs(config.core)) # noqa: SLF001
assert known_envs
custom_section = config.get_section_config(
section=Section("custom", "foo"),
base=[],
of_type=CustomConfigSet,
for_env=None,
)
assert custom_section["a"] == "b"
tox-4.13.0/tests/config/test_main.py 0000664 0000000 0000000 00000012750 14564001166 0017365 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
from pathlib import Path
from typing import TYPE_CHECKING, List
import pytest
from tox.config.loader.api import Override
from tox.config.loader.memory import MemoryLoader
from tox.config.sets import ConfigSet
if TYPE_CHECKING:
from tests.conftest import ToxIniCreator
from tox.config.main import Config
from tox.pytest import ToxProjectCreator
def test_empty_config_repr(empty_config: Config) -> None:
text = repr(empty_config)
assert str(empty_config.core["tox_root"]) in text
assert "config_source=ToxIni" in text
def test_empty_conf_tox_envs(empty_config: Config) -> None:
tox_env_keys = list(empty_config)
assert tox_env_keys == []
def test_empty_conf_get(empty_config: Config) -> None:
result = empty_config.get_env("magic")
assert isinstance(result, ConfigSet)
loaders = result["base"]
assert loaders == ["testenv"]
def test_config_some_envs(tox_ini_conf: ToxIniCreator) -> None:
example = """
[tox]
env_list = py38, py37
[testenv]
deps = 1
other: 2
[testenv:magic]
"""
config = tox_ini_conf(example)
tox_env_keys = list(config)
assert tox_env_keys == ["py38", "py37", "magic", "other"]
config_set = config.get_env("py38")
assert repr(config_set)
assert isinstance(config_set, ConfigSet)
assert list(config_set)
def test_config_overrides(tox_ini_conf: ToxIniCreator) -> None:
conf = tox_ini_conf("[testenv]", override=[Override("testenv.c=ok")]).get_env("py")
conf.add_config("c", of_type=str, default="d", desc="desc")
assert conf["c"] == "ok"
def test_config_override_wins_memory_loader(tox_ini_conf: ToxIniCreator) -> None:
main_conf = tox_ini_conf("[testenv]", override=[Override("testenv.c=ok")])
conf = main_conf.get_env("py", loaders=[MemoryLoader(c="something_else")])
conf.add_config("c", of_type=str, default="d", desc="desc")
assert conf["c"] == "ok"
def test_config_override_appends_to_list(tox_ini_conf: ToxIniCreator) -> None:
example = """
[testenv]
passenv = foo
"""
conf = tox_ini_conf(example, override=[Override("testenv.passenv+=bar")]).get_env("testenv")
conf.add_config("passenv", of_type=List[str], default=[], desc="desc")
assert conf["passenv"] == ["foo", "bar"]
def test_config_override_appends_to_empty_list(tox_ini_conf: ToxIniCreator) -> None:
conf = tox_ini_conf("[testenv]", override=[Override("testenv.passenv+=bar")]).get_env("testenv")
conf.add_config("passenv", of_type=List[str], default=[], desc="desc")
assert conf["passenv"] == ["bar"]
def test_config_override_appends_to_setenv(tox_ini_conf: ToxIniCreator) -> None:
example = """
[testenv]
setenv =
foo = bar
"""
conf = tox_ini_conf(example, override=[Override("testenv.setenv+=baz=quux")]).get_env("testenv")
assert conf["setenv"].load("foo") == "bar"
assert conf["setenv"].load("baz") == "quux"
def test_config_override_appends_to_empty_setenv(tox_ini_conf: ToxIniCreator) -> None:
conf = tox_ini_conf("[testenv]", override=[Override("testenv.setenv+=foo=bar")]).get_env("testenv")
assert conf["setenv"].load("foo") == "bar"
def test_config_override_cannot_append(tox_ini_conf: ToxIniCreator) -> None:
example = """
[testenv]
foo = 1
"""
conf = tox_ini_conf(example, override=[Override("testenv.foo+=2")]).get_env("testenv")
conf.add_config("foo", of_type=int, default=0, desc="desc")
with pytest.raises(ValueError, match="Only able to append to lists and dicts"):
conf["foo"]
def test_args_are_paths_when_disabled(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\npackage=skip\ncommands={posargs}\nargs_are_paths=False"
project = tox_project({"tox.ini": ini, "w": {"a.txt": "a"}})
args = "magic.py", str(project.path), f"..{os.sep}tox.ini", "..", f"..{os.sep}.."
result = project.run("c", "-e", "py", "-k", "commands", "--", *args, from_cwd=project.path / "w")
result.assert_success()
assert result.out == f"[testenv:py]\ncommands = magic.py {project.path} ..{os.sep}tox.ini .. ..{os.sep}..\n"
def test_args_are_paths_when_from_child_dir(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv]\npackage=skip\ncommands={posargs}", "w": {"a.txt": "a"}})
args = "magic.py", str(project.path), f"..{os.sep}tox.ini", "..", f"..{os.sep}.."
result = project.run("c", "-e", "py", "-k", "commands", "--", *args, from_cwd=project.path / "w")
result.assert_success()
assert result.out == f"[testenv:py]\ncommands = magic.py {project.path} tox.ini . ..\n"
def test_args_are_paths_when_with_change_dir(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv]\npackage=skip\ncommands={posargs}\nchange_dir=w", "w": {"a.txt": "a"}})
args = "magic.py", str(project.path), "tox.ini", f"w{os.sep}a.txt", "w", "."
result = project.run("c", "-e", "py", "-k", "commands", "--", *args)
result.assert_success()
assert result.out == f"[testenv:py]\ncommands = magic.py {project.path} ..{os.sep}tox.ini a.txt . ..\n"
def test_relative_config_paths_resolve(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[tox]"})
ini = str(Path(project.path.name) / "tox.ini")
result = project.run("c", "-c", ini, "-k", "change_dir", "env_dir", from_cwd=project.path.parent)
result.assert_success()
expected = f"[testenv:py]\nchange_dir = {project.path}\nenv_dir = {project.path / '.tox' / 'py'}\n"
assert result.out == expected
tox-4.13.0/tests/config/test_of_types.py 0000664 0000000 0000000 00000001221 14564001166 0020260 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from tox.config.of_type import ConfigConstantDefinition, ConfigDynamicDefinition
def test_config_constant_eq() -> None:
val_1 = ConfigConstantDefinition(("key",), "description", "value")
val_2 = ConfigConstantDefinition(("key",), "description", "value")
assert val_1 == val_2
def test_config_dynamic_eq() -> None:
def func(name: str) -> str:
return name # pragma: no cover
val_1 = ConfigDynamicDefinition(("key",), "description", str, "default", post_process=func)
val_2 = ConfigDynamicDefinition(("key",), "description", str, "default", post_process=func)
assert val_1 == val_2
tox-4.13.0/tests/config/test_set_env.py 0000664 0000000 0000000 00000013751 14564001166 0020106 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from pathlib import Path
from typing import TYPE_CHECKING, Any
from unittest.mock import ANY
import pytest
from tox.config.set_env import SetEnv
if TYPE_CHECKING:
from pytest_mock import MockerFixture
from tox.pytest import MonkeyPatch, ToxProjectCreator
from typing import Protocol
def test_set_env_explicit() -> None:
set_env = SetEnv("\nA=1\nB = 2\nC= 3\nD= 4", "py", "py", Path())
set_env.update({"E": "5 ", "F": "6"}, override=False)
keys = list(set_env)
assert keys == ["E", "F", "A", "B", "C", "D"]
values = [set_env.load(k) for k in keys]
assert values == ["5 ", "6", "1", "2", "3", "4"]
for key in keys:
assert key in set_env
assert "MISS" not in set_env
def test_set_env_merge() -> None:
a = SetEnv("\nA=1\nB = 2\nC= 3\nD= 4", "py", "py", Path())
b = SetEnv("\nA=2\nE = 5", "py", "py", Path())
a.update(b, override=False)
keys = list(a)
assert keys == ["E", "A", "B", "C", "D"]
values = [a.load(k) for k in keys]
assert values == ["5", "1", "2", "3", "4"]
a.update(b, override=True)
values = [a.load(k) for k in keys]
assert values == ["5", "2", "2", "3", "4"]
def test_set_env_bad_line() -> None:
with pytest.raises(ValueError, match="A"):
SetEnv("A", "py", "py", Path())
class EvalSetEnv(Protocol):
def __call__(
self,
tox_ini: str,
extra_files: dict[str, Any] | None = ...,
from_cwd: Path | None = ...,
) -> SetEnv: ...
@pytest.fixture()
def eval_set_env(tox_project: ToxProjectCreator) -> EvalSetEnv:
def func(tox_ini: str, extra_files: dict[str, Any] | None = None, from_cwd: Path | None = None) -> SetEnv:
prj = tox_project({"tox.ini": tox_ini, **(extra_files or {})})
result = prj.run("c", "-k", "set_env", "-e", "py", from_cwd=None if from_cwd is None else prj.path / from_cwd)
result.assert_success()
set_env: SetEnv = result.env_conf("py")["set_env"]
return set_env
return func
def test_set_env_default(eval_set_env: EvalSetEnv) -> None:
set_env = eval_set_env("")
keys = list(set_env)
assert keys == ["PYTHONHASHSEED", "PIP_DISABLE_PIP_VERSION_CHECK", "PYTHONIOENCODING"]
values = [set_env.load(k) for k in keys]
assert values == [ANY, "1", "utf-8"]
def test_set_env_self_key(eval_set_env: EvalSetEnv, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setenv("a", "1")
set_env = eval_set_env("[testenv]\npackage=skip\nset_env=a={env:a:2}")
assert set_env.load("a") == "1"
def test_set_env_other_env_set(eval_set_env: EvalSetEnv, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setenv("b", "1")
set_env = eval_set_env("[testenv]\npackage=skip\nset_env=a={env:b:2}")
assert set_env.load("a") == "1"
def test_set_env_other_env_default(eval_set_env: EvalSetEnv, monkeypatch: MonkeyPatch) -> None:
monkeypatch.delenv("b", raising=False)
set_env = eval_set_env("[testenv]\npackage=skip\nset_env=a={env:b:2}")
assert set_env.load("a") == "2"
def test_set_env_delayed_eval(eval_set_env: EvalSetEnv, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setenv("b", "c=1")
set_env = eval_set_env("[testenv]\npackage=skip\nset_env={env:b}")
assert set_env.load("c") == "1"
def test_set_env_tty_on(eval_set_env: EvalSetEnv, mocker: MockerFixture) -> None:
mocker.patch("sys.stdout.isatty", return_value=True)
set_env = eval_set_env("[testenv]\npackage=skip\nset_env={tty:A=1:B=1}")
assert set_env.load("A") == "1"
assert "B" not in set_env
def test_set_env_tty_off(eval_set_env: EvalSetEnv, mocker: MockerFixture) -> None:
mocker.patch("sys.stdout.isatty", return_value=False)
set_env = eval_set_env("[testenv]\npackage=skip\nset_env={tty:A=1:B=1}")
assert set_env.load("B") == "1"
assert "A" not in set_env
def test_set_env_circular_use_os_environ(tox_project: ToxProjectCreator) -> None:
prj = tox_project({"tox.ini": "[testenv]\npackage=skip\nset_env=a={env:b}\n b={env:a}"})
result = prj.run("c", "-e", "py")
result.assert_success()
assert "replace failed in py.set_env with MatchRecursionError" in result.out, result.out
assert "circular chain between set env a, b" in result.out, result.out
def test_set_env_invalid_lines(eval_set_env: EvalSetEnv) -> None:
with pytest.raises(ValueError, match="a"):
eval_set_env("[testenv]\npackage=skip\nset_env=a\n b")
def test_set_env_replacer(eval_set_env: EvalSetEnv, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setenv("MAGIC", "\nb=2\n")
set_env = eval_set_env("[testenv]\npackage=skip\nset_env=a=1\n {env:MAGIC}")
env = {k: set_env.load(k) for k in set_env}
assert env == {
"PIP_DISABLE_PIP_VERSION_CHECK": "1",
"a": "1",
"b": "2",
"PYTHONIOENCODING": "utf-8",
"PYTHONHASHSEED": ANY,
}
def test_set_env_honor_override(eval_set_env: EvalSetEnv) -> None:
set_env = eval_set_env("[testenv]\npackage=skip\nset_env=PIP_DISABLE_PIP_VERSION_CHECK=0")
assert set_env.load("PIP_DISABLE_PIP_VERSION_CHECK") == "0"
def test_set_env_environment_file(eval_set_env: EvalSetEnv) -> None:
env_file = """
A=1
B= 2
C = 1
# D = comment # noqa: E800
E = "1"
F =
"""
extra = {"A": {"a.txt": env_file}, "B": None, "C": None}
ini = "[testenv]\npackage=skip\nset_env=file|A{/}a.txt\nchange_dir=C"
set_env = eval_set_env(ini, extra_files=extra, from_cwd=Path("B"))
content = {k: set_env.load(k) for k in set_env}
assert content == {
"PIP_DISABLE_PIP_VERSION_CHECK": "1",
"PYTHONHASHSEED": ANY,
"A": "1",
"B": "2",
"C": "1",
"E": '"1"',
"F": "",
"PYTHONIOENCODING": "utf-8",
}
def test_set_env_environment_file_missing(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv]\npackage=skip\nset_env=file|magic.txt"})
result = project.run("r")
result.assert_failed()
assert f"py: failed with {project.path / 'magic.txt'} does not exist for set_env" in result.out
tox-4.13.0/tests/config/test_sets.py 0000664 0000000 0000000 00000016035 14564001166 0017417 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from collections import OrderedDict
from pathlib import Path
from typing import TYPE_CHECKING, Callable, Dict, Optional, Set, TypeVar
import pytest
from tox.config.cli.parser import Parsed
from tox.config.loader.memory import MemoryLoader
from tox.config.main import Config
from tox.config.sets import ConfigSet, EnvConfigSet
from tox.config.source.api import Section
if TYPE_CHECKING:
from pytest_mock import MockerFixture
from tests.conftest import ToxIniCreator
from tox.pytest import ToxProjectCreator
ConfBuilder = Callable[[str], ConfigSet]
@pytest.fixture(name="conf_builder")
def _conf_builder(tox_ini_conf: ToxIniCreator) -> ConfBuilder: # noqa: PT005
def _make(conf_str: str) -> ConfigSet:
return tox_ini_conf(f"[tox]\nenvlist=py39\n[testenv]\n{conf_str}").get_env("py39")
return _make
def test_config_str(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("deps-x = 1\n other: 2")
config_set.add_config(keys="deps-x", of_type=str, default="", desc="ok")
result = config_set["deps-x"]
assert result == "1"
def test_config_path(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("path = path")
config_set.add_config(keys="path", of_type=Path, default=Path(), desc="path")
path_materialize = config_set["path"]
assert path_materialize == Path("path")
def test_config_set(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("set = 1\n 2\n 3")
config_set.add_config(keys="set", of_type=Set[int], default=set(), desc="set")
set_materialize = config_set["set"]
assert set_materialize == {1, 2, 3}
def test_config_optional_none(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("")
config_set.add_config(
keys="optional_none",
of_type=Optional[int], # type: ignore[arg-type]
default=None,
desc="optional_none",
)
optional_none = config_set["optional_none"]
assert optional_none is None
def test_config_dict(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("dict = a=1\n b=2\n c=3")
config_set.add_config(keys="dict", of_type=Dict[str, int], default={}, desc="dict")
dict_val = config_set["dict"]
assert dict_val == OrderedDict([("a", 1), ("b", 2), ("c", 3)])
def test_config_bad_type(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("crazy = something-bad")
config_set.add_config(keys="crazy", of_type=TypeVar, default=TypeVar("V"), desc="crazy")
with pytest.raises(TypeError) as context:
assert config_set["crazy"]
assert str(context.value) == f"something-bad cannot cast to {TypeVar!r}"
def test_config_bad_dict(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("bad_dict = something")
config_set.add_config(keys="bad_dict", of_type=Dict[str, str], default={}, desc="bad_dict")
with pytest.raises(TypeError) as context:
assert config_set["bad_dict"]
assert str(context.value) == "dictionary lines must be of form key=value, found 'something'"
def test_config_bad_bool(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("bad_bool = whatever")
config_set.add_config(keys="bad_bool", of_type=bool, default=False, desc="bad_bool")
with pytest.raises(TypeError) as context:
assert config_set["bad_bool"]
error = "value 'whatever' cannot be transformed to bool, valid: , 0, 1, false, no, off, on, true, yes"
assert str(context.value) == error
def test_config_constant(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("")
config_set.add_constant(keys="a", value=1, desc="ok")
const = config_set["a"]
assert const == 1
def test_config_lazy_constant(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("")
config_set.add_constant(keys="b", value=lambda: 2, desc="ok")
lazy_const = config_set["b"]
assert lazy_const == 2
def test_config_constant_repr(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("")
defined = config_set.add_constant(keys="a", value=1, desc="ok")
assert repr(defined)
def test_config_dynamic_repr(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("path = path")
defined = config_set.add_config(keys="path", of_type=Path, default=Path(), desc="path")
assert repr(defined)
def test_config_redefine_constant_fail(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("path = path")
config_set.add_constant(keys="path", desc="desc", value="value")
with pytest.raises(ValueError, match="config path already defined"):
config_set.add_constant(keys="path", desc="desc2", value="value")
def test_config_redefine_dynamic_fail(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("path = path")
config_set.add_config(keys="path", of_type=str, default="default_1", desc="path")
with pytest.raises(ValueError, match="config path already defined"):
config_set.add_config(keys="path", of_type=str, default="default_2", desc="path")
def test_config_dynamic_not_equal(conf_builder: ConfBuilder) -> None:
config_set = conf_builder("")
path = config_set.add_config(keys="path", of_type=Path, default=Path(), desc="path")
paths = config_set.add_config(keys="paths", of_type=Path, default=Path(), desc="path")
assert path != paths
def test_define_custom_set(tox_project: ToxProjectCreator) -> None:
class MagicConfigSet(ConfigSet):
SECTION = Section(None, "magic")
def register_config(self) -> None:
self.add_config("a", of_type=int, default=0, desc="number")
self.add_config("b", of_type=str, default="", desc="string")
project = tox_project({"tox.ini": "[testenv]\npackage=skip\n[A]\na=1\n[magic]\nb = ok"})
result = project.run()
section = MagicConfigSet.SECTION
conf = result.state.conf.get_section_config(section, base=["A"], of_type=MagicConfigSet, for_env=None)
assert conf["a"] == 1
assert conf["b"] == "ok"
exp = "MagicConfigSet(loaders=[IniLoader(section=magic, overrides={}), IniLoader(section=A, overrides={})])"
assert repr(conf) == exp
assert isinstance(result.state.conf._options, Parsed) # noqa: SLF001
def test_do_not_allow_create_config_set(mocker: MockerFixture) -> None:
with pytest.raises(TypeError, match="Can't instantiate"):
ConfigSet(mocker.create_autospec(Config)) # type: ignore[abstract,call-arg]
def test_set_env_raises_on_non_str(mocker: MockerFixture) -> None:
env_set = EnvConfigSet(mocker.create_autospec(Config), Section("a", "b"), "b")
env_set.loaders.insert(0, MemoryLoader(set_env=1))
with pytest.raises(TypeError, match="1"):
assert env_set["set_env"]
@pytest.mark.parametrize("work_dir", ["a", ""])
def test_config_work_dir(tox_project: ToxProjectCreator, work_dir: str) -> None:
project = tox_project({"tox.ini": "[tox]\ntoxworkdir=b"})
result = project.run("c", *(["--workdir", str(project.path / work_dir)] if work_dir else []))
expected = project.path / work_dir if work_dir else Path("b")
assert expected == result.state.conf.core["work_dir"]
tox-4.13.0/tests/config/test_types.py 0000664 0000000 0000000 00000002322 14564001166 0017577 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from tox.config.types import Command, EnvList
def tests_command_repr() -> None:
cmd = Command(["python", "-m", "pip", "list"])
assert repr(cmd) == "Command(args=['python', '-m', 'pip', 'list'])"
assert cmd.ignore_exit_code is False
def tests_command_repr_ignore() -> None:
cmd = Command(["-", "python", "-m", "pip", "list"])
assert repr(cmd) == "Command(args=['-', 'python', '-m', 'pip', 'list'])"
assert cmd.ignore_exit_code is True
def tests_command_eq() -> None:
cmd_1 = Command(["python", "-m", "pip", "list"])
cmd_2 = Command(["python", "-m", "pip", "list"])
assert cmd_1 == cmd_2
def tests_command_ne() -> None:
cmd_1 = Command(["python", "-m", "pip", "list"])
cmd_2 = Command(["-", "python", "-m", "pip", "list"])
assert cmd_1 != cmd_2
def tests_env_list_repr() -> None:
env = EnvList(["py39", "py38"])
assert repr(env) == "EnvList(['py39', 'py38'])"
def tests_env_list_eq() -> None:
env_1 = EnvList(["py39", "py38"])
env_2 = EnvList(["py39", "py38"])
assert env_1 == env_2
def tests_env_list_ne() -> None:
env_1 = EnvList(["py39", "py38"])
env_2 = EnvList(["py38", "py39"])
assert env_1 != env_2
tox-4.13.0/tests/conftest.py 0000664 0000000 0000000 00000012117 14564001166 0015757 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
import sys
from pathlib import Path
from typing import TYPE_CHECKING, Callable, Iterator, Protocol, Sequence
from unittest.mock import patch
from uuid import uuid4
import pytest
from distlib.scripts import ScriptMaker
from filelock import FileLock
from virtualenv import cli_run
from tox.config.cli.parser import Parsed
from tox.config.main import Config
from tox.config.source import discover_source
from tox.tox_env.python.api import PythonInfo, VersionInfo
from tox.tox_env.python.virtual_env.api import VirtualEnv
if TYPE_CHECKING:
from pytest_mock import MockerFixture
from tox.config.loader.api import Override
pytest_plugins = "tox.pytest"
HERE = Path(__file__).absolute().parent
@pytest.fixture(scope="session")
def value_error() -> Callable[[str], str]:
def _fmt(msg: str) -> str:
return f'ValueError("{msg}"{"," if sys.version_info < (3, 7) else ""})'
return _fmt
collect_ignore = []
if sys.implementation.name == "pypy":
# time-machine causes segfaults on PyPy
collect_ignore.append("util/test_spinner.py")
class ToxIniCreator(Protocol):
def __call__(self, conf: str, override: Sequence[Override] | None = None) -> Config: ...
@pytest.fixture()
def tox_ini_conf(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> ToxIniCreator:
def func(conf: str, override: Sequence[Override] | None = None) -> Config:
dest = tmp_path / "c"
dest.mkdir()
config_file = dest / "tox.ini"
config_file.write_bytes(conf.encode("utf-8"))
with monkeypatch.context() as context:
context.chdir(tmp_path)
source = discover_source(config_file, None)
return Config.make(
Parsed(work_dir=dest, override=override or [], config_file=config_file, root_dir=None),
pos_args=[],
source=source,
)
return func
@pytest.fixture(scope="session")
def demo_pkg_setuptools() -> Path:
return HERE / "demo_pkg_setuptools"
@pytest.fixture(scope="session")
def demo_pkg_inline() -> Iterator[Path]:
demo_path = HERE / "demo_pkg_inline"
with FileLock(f"{demo_path}.lock"):
yield demo_path
@pytest.fixture()
def patch_prev_py(mocker: MockerFixture) -> Callable[[bool], tuple[str, str]]:
def _func(has_prev: bool) -> tuple[str, str]:
ver = sys.version_info[0:2]
prev_ver = "".join(str(i) for i in (ver[0], ver[1] - 1))
prev_py = f"py{prev_ver}"
impl = sys.implementation.name.lower()
def get_python(self: VirtualEnv, base_python: list[str]) -> PythonInfo | None: # noqa: ARG001
if base_python[0] == "py31" or (base_python[0] == prev_py and not has_prev):
return None
raw = list(sys.version_info)
if base_python[0] == prev_py:
raw[1] -= 1 # type: ignore[operator]
ver_info = VersionInfo(*raw) # type: ignore[arg-type]
return PythonInfo(
implementation=impl,
version_info=ver_info,
version="",
is_64=True,
platform=sys.platform,
extra={"executable": Path(sys.executable)},
)
mocker.patch.object(VirtualEnv, "_get_python", get_python)
return prev_ver, impl
return _func
@pytest.fixture(scope="session", autouse=True)
def _do_not_share_virtualenv_for_parallel_runs(tmp_path_factory: pytest.TempPathFactory, worker_id: str) -> None:
# virtualenv uses locks to manage access to its cache, when running with xdist this may throw off test timings
if worker_id != "master": # pragma: no branch
temp_app_data = str(tmp_path_factory.mktemp(f"virtualenv-app-{worker_id}")) # pragma: no cover
os.environ["VIRTUALENV_APP_DATA"] = temp_app_data # pragma: no cover
seed_env_folder = str(tmp_path_factory.mktemp(f"seed-cache-{worker_id}")) # pragma: no cover
args = [seed_env_folder, "--without-pip", "--activators", ""] # pragma: no cover
cli_run(args, setup_logging=False) # pragma: no cover
@pytest.fixture(scope="session")
def fake_exe_on_path(tmp_path_factory: pytest.TempPathFactory) -> Iterator[Path]:
tmp_path = Path(tmp_path_factory.mktemp("a"))
cmd_name = uuid4().hex
maker = ScriptMaker(None, str(tmp_path))
maker.set_mode = True
maker.variants = {""}
maker.make(f"{cmd_name} = b:c")
with patch.dict(os.environ, {"PATH": f"{tmp_path}{os.pathsep}{os.environ['PATH']}"}):
yield tmp_path / cmd_name
@pytest.fixture(scope="session")
def demo_pkg_inline_wheel(tmp_path_factory: pytest.TempPathFactory, demo_pkg_inline: Path) -> Path:
return build_pkg(tmp_path_factory.mktemp("dist"), demo_pkg_inline, ["wheel"])
def build_pkg(dist_dir: Path, of: Path, distributions: list[str], isolation: bool = True) -> Path:
from build.__main__ import build_package # noqa: PLC0415,PLC2701
build_package(str(of), str(dist_dir), distributions=distributions, isolation=isolation)
return next(dist_dir.iterdir())
@pytest.fixture(scope="session")
def pkg_builder() -> Callable[[Path, Path, list[str], bool], Path]:
return build_pkg
tox-4.13.0/tests/demo_pkg_inline/ 0000775 0000000 0000000 00000000000 14564001166 0016701 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/demo_pkg_inline/build.py 0000664 0000000 0000000 00000010526 14564001166 0020356 0 ustar 00root root 0000000 0000000 """
Please keep this file Python 2.7 compatible.
See https://tox.readthedocs.io/en/rewrite/development.html#code-style-guide
"""
from __future__ import annotations
import os
import sys
import tarfile
from pathlib import Path
from textwrap import dedent
from zipfile import ZipFile
name = "demo_pkg_inline"
pkg_name = name.replace("_", "-")
version = "1.0.0"
dist_info = f"{name}-{version}.dist-info"
logic = f"{name}/__init__.py"
plugin = f"{name}/example_plugin.py"
entry_points = f"{dist_info}/entry_points.txt"
metadata = f"{dist_info}/METADATA"
wheel = f"{dist_info}/WHEEL"
record = f"{dist_info}/RECORD"
content = {
logic: f"def do():\n print('greetings from {name}')",
plugin: """
try:
from tox.plugin import impl
from tox.tox_env.python.virtual_env.runner import VirtualEnvRunner
from tox.tox_env.register import ToxEnvRegister
except ImportError:
pass
else:
class ExampleVirtualEnvRunner(VirtualEnvRunner):
@staticmethod
def id() -> str:
return "example"
@impl
def tox_register_tox_env(register: ToxEnvRegister) -> None:
register.add_run_env(ExampleVirtualEnvRunner)
""",
}
metadata_files = {
entry_points: f"""
[tox]
example = {name}.example_plugin""",
metadata: """
Metadata-Version: 2.1
Name: {}
Version: {}
Summary: UNKNOWN
Home-page: UNKNOWN
Author: UNKNOWN
Author-email: UNKNOWN
License: UNKNOWN
{}
Platform: UNKNOWN
UNKNOWN
""".format(
pkg_name,
version,
"\n ".join(os.environ.get("METADATA_EXTRA", "").split("\n")),
),
wheel: f"""
Wheel-Version: 1.0
Generator: {name}-{version}
Root-Is-Purelib: true
Tag: py{sys.version_info[0]}-none-any
""",
f"{dist_info}/top_level.txt": name,
record: f"""
{name}/__init__.py,,
{dist_info}/METADATA,,
{dist_info}/WHEEL,,
{dist_info}/top_level.txt,,
{dist_info}/RECORD,,
""",
}
def build_wheel(
wheel_directory: str,
config_settings: dict[str, str] | None = None, # noqa: ARG001
metadata_directory: str | None = None,
) -> str:
base_name = f"{name}-{version}-py{sys.version_info[0]}-none-any.whl"
path = Path(wheel_directory) / base_name
with ZipFile(str(path), "w") as zip_file_handler:
for arc_name, data in content.items(): # pragma: no branch
zip_file_handler.writestr(arc_name, dedent(data).strip())
if metadata_directory is not None:
for sub_directory, _, filenames in os.walk(metadata_directory):
for filename in filenames:
zip_file_handler.write(
str(Path(metadata_directory) / sub_directory / filename),
str(Path(sub_directory) / filename),
)
else:
for arc_name, data in metadata_files.items():
zip_file_handler.writestr(arc_name, dedent(data).strip())
print(f"created wheel {path}") # noqa: T201
return base_name
def get_requires_for_build_wheel(config_settings: dict[str, str] | None = None) -> list[str]: # noqa: ARG001
return [] # pragma: no cover # only executed in non-host pythons
if os.environ.get("BACKEND_HAS_EDITABLE"):
def build_editable(
wheel_directory: str,
config_settings: dict[str, str] | None = None,
metadata_directory: str | None = None,
) -> str:
return build_wheel(wheel_directory, config_settings, metadata_directory)
def build_sdist(sdist_directory: str, config_settings: dict[str, str] | None = None) -> str: # noqa: ARG001
result = f"{name}-{version}.tar.gz" # pragma: win32 cover
with tarfile.open(str(Path(sdist_directory) / result), "w:gz") as tar: # pragma: win32 cover
root = Path(__file__).parent # pragma: win32 cover
tar.add(str(root / "build.py"), "build.py") # pragma: win32 cover
tar.add(str(root / "pyproject.toml"), "pyproject.toml") # pragma: win32 cover
return result # pragma: win32 cover
def get_requires_for_build_sdist(config_settings: dict[str, str] | None = None) -> list[str]: # noqa: ARG001
return [] # pragma: no cover # only executed in non-host pythons
tox-4.13.0/tests/demo_pkg_inline/pyproject.toml 0000664 0000000 0000000 00000000160 14564001166 0021612 0 ustar 00root root 0000000 0000000 [build-system]
build-backend = "build"
requires = [
]
backend-path = [
".",
]
[tool.black]
line-length = 120
tox-4.13.0/tests/demo_pkg_setuptools/ 0000775 0000000 0000000 00000000000 14564001166 0017644 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/demo_pkg_setuptools/demo_pkg_setuptools/ 0000775 0000000 0000000 00000000000 14564001166 0023732 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/demo_pkg_setuptools/demo_pkg_setuptools/__init__.py 0000664 0000000 0000000 00000000165 14564001166 0026045 0 ustar 00root root 0000000 0000000 from __future__ import annotations
def do() -> None:
print("greetings from demo_pkg_setuptools") # noqa: T201
tox-4.13.0/tests/demo_pkg_setuptools/pyproject.toml 0000664 0000000 0000000 00000000132 14564001166 0022554 0 ustar 00root root 0000000 0000000 [build-system]
build-backend = 'setuptools.build_meta'
requires = [
"setuptools>=63",
]
tox-4.13.0/tests/demo_pkg_setuptools/setup.cfg 0000664 0000000 0000000 00000000122 14564001166 0021460 0 ustar 00root root 0000000 0000000 [metadata]
name = demo_pkg_setuptools
version = 1.2.3
[options]
packages = find:
tox-4.13.0/tests/execute/ 0000775 0000000 0000000 00000000000 14564001166 0015220 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/execute/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0017317 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/execute/conftest.py 0000664 0000000 0000000 00000000235 14564001166 0017417 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
import pytest
@pytest.fixture(scope="session")
def os_env() -> dict[str, str]:
return os.environ.copy()
tox-4.13.0/tests/execute/local_subprocess/ 0000775 0000000 0000000 00000000000 14564001166 0020562 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/execute/local_subprocess/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0022661 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/execute/local_subprocess/bad_process.py 0000664 0000000 0000000 00000001524 14564001166 0023422 0 ustar 00root root 0000000 0000000 """This is a non compliant process that does not listens to signals"""
# pragma: no cover
from __future__ import annotations
import os
import signal
import sys
import time
from pathlib import Path
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from types import FrameType
out = sys.stdout
def handler(signum: int, _: FrameType | None) -> None:
_p(f"how about no signal {signum!r}")
def _p(m: str) -> None:
out.write(f"{m}{os.linesep}")
out.flush() # force output flush in case we get killed
_p(f"start {__name__} with {sys.argv!r}")
signal.signal(signal.SIGINT, handler)
signal.signal(signal.SIGTERM, handler)
try:
start_file = Path(sys.argv[1])
_p(f"create {start_file}")
start_file.write_text("")
_p(f"created {start_file}")
while True:
time.sleep(0.01)
finally:
_p(f"done {__name__}")
tox-4.13.0/tests/execute/local_subprocess/local_subprocess_sigint.py 0000664 0000000 0000000 00000004714 14564001166 0026061 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import locale
import logging
import os
import signal
import sys
from io import TextIOWrapper
from pathlib import Path
from typing import TYPE_CHECKING
from unittest.mock import MagicMock
from tox.execute.local_sub_process import LocalSubProcessExecutor
from tox.execute.request import ExecuteRequest, StdinSource
from tox.report import NamedBytesIO
if TYPE_CHECKING:
from types import FrameType
from tox.execute import Outcome
logging.basicConfig(level=logging.DEBUG, format="%(relativeCreated)d\t%(levelname).1s\t%(message)s")
bad_process = Path(__file__).parent / "bad_process.py"
executor = LocalSubProcessExecutor(colored=False)
request = ExecuteRequest(
cmd=[sys.executable, bad_process, sys.argv[1]],
cwd=Path().absolute(),
env=os.environ.copy(),
stdin=StdinSource.API,
run_id="",
)
out_err = (
TextIOWrapper(NamedBytesIO("out"), encoding=locale.getpreferredencoding(False)),
TextIOWrapper(NamedBytesIO("err"), encoding=locale.getpreferredencoding(False)),
)
def show_outcome(outcome: Outcome | None) -> None:
if outcome is not None: # pragma: no branch
print(outcome.exit_code) # noqa: T201
print(repr(outcome.out)) # noqa: T201
print(repr(outcome.err)) # noqa: T201
print(outcome.elapsed, end="") # noqa: T201
print("done show outcome", file=sys.stderr) # noqa: T201
def handler(s: int, f: FrameType | None) -> None:
logging.info("signal %s at %s", s, f)
global interrupt_done # noqa: PLW0603
if interrupt_done is False: # pragma: no branch
interrupt_done = True
logging.info("interrupt via %s", status)
status.interrupt()
logging.info("interrupt finished via %s", status)
interrupt_done = False
signal.signal(signal.SIGINT, handler)
logging.info("PID %d start %r", os.getpid(), request)
tox_env = MagicMock(conf={"suicide_timeout": 0.01, "interrupt_timeout": 0.05, "terminate_timeout": 0.07})
try:
with executor.call(request, show=False, out_err=out_err, env=tox_env) as status:
logging.info("wait on %r", status)
while status.exit_code is None:
status.wait(timeout=0.01) # use wait here with timeout to not block the main thread
logging.info("wait over on %r", status)
show_outcome(status.outcome)
except Exception as exception: # pragma: no cover
logging.exception(exception) # noqa: TRY401 # pragma: no cover
finally:
logging.info("done")
logging.shutdown()
tox-4.13.0/tests/execute/local_subprocess/test_execute_util.py 0000664 0000000 0000000 00000001552 14564001166 0024675 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
from tox.execute.util import shebang
if TYPE_CHECKING:
from pathlib import Path
def test_shebang_found(tmp_path: Path) -> None:
script_path = tmp_path / "a"
script_path.write_text("#! /bin/python \t-c\t")
assert shebang(str(script_path)) == ["/bin/python", "-c"]
def test_shebang_file_missing(tmp_path: Path) -> None:
script_path = tmp_path / "a"
assert shebang(str(script_path)) is None
def test_shebang_no_shebang(tmp_path: Path) -> None:
script_path = tmp_path / "a"
script_path.write_bytes(b"magic")
assert shebang(str(script_path)) is None
def test_shebang_non_utf8_file(tmp_path: Path) -> None:
script_path, content = tmp_path / "a", b"#!" + bytearray.fromhex("c0")
script_path.write_bytes(content)
assert shebang(str(script_path)) is None
tox-4.13.0/tests/execute/local_subprocess/test_local_subprocess.py 0000664 0000000 0000000 00000037356 14564001166 0025553 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import json
import locale
import logging
import os
import shutil
import stat
import subprocess
import sys
from io import TextIOWrapper
from pathlib import Path
from typing import TYPE_CHECKING
from unittest.mock import MagicMock, create_autospec
import psutil
import pytest
from colorama import Fore
from psutil import AccessDenied
from tox.execute.api import ExecuteOptions, Outcome
from tox.execute.local_sub_process import SIG_INTERRUPT, LocalSubProcessExecuteInstance, LocalSubProcessExecutor
from tox.execute.local_sub_process.read_via_thread_unix import ReadViaThreadUnix
from tox.execute.request import ExecuteRequest, StdinSource
from tox.execute.stream import SyncWrite
from tox.report import NamedBytesIO
if TYPE_CHECKING:
from pytest_mock import MockerFixture
from tox.pytest import CaptureFixture, LogCaptureFixture, MonkeyPatch
class FakeOutErr:
def __init__(self) -> None:
self.out_err = (
TextIOWrapper(NamedBytesIO("out"), encoding=locale.getpreferredencoding(False)),
TextIOWrapper(NamedBytesIO("err"), encoding=locale.getpreferredencoding(False)),
)
def read_out_err(self) -> tuple[str, str]:
out_got = self.out_err[0].buffer.getvalue().decode(self.out_err[0].encoding) # type: ignore[attr-defined]
err_got = self.out_err[1].buffer.getvalue().decode(self.out_err[1].encoding) # type: ignore[attr-defined]
return out_got, err_got
@pytest.mark.parametrize("color", [True, False], ids=["color", "no_color"])
@pytest.mark.parametrize(("out", "err"), [("out", "err"), ("", "")], ids=["simple", "nothing"])
@pytest.mark.parametrize("show", [True, False], ids=["show", "no_show"])
def test_local_execute_basic_pass( # noqa: PLR0913
caplog: LogCaptureFixture,
os_env: dict[str, str],
out: str,
err: str,
show: bool,
color: bool,
) -> None:
caplog.set_level(logging.NOTSET)
executor = LocalSubProcessExecutor(colored=color)
code = f"import sys; print({out!r}, end=''); print({err!r}, end='', file=sys.stderr)"
request = ExecuteRequest(cmd=[sys.executable, "-c", code], cwd=Path(), env=os_env, stdin=StdinSource.OFF, run_id="")
out_err = FakeOutErr()
with executor.call(request, show=show, out_err=out_err.out_err, env=MagicMock()) as status:
while status.exit_code is None: # pragma: no branch
status.wait()
assert status.out == out.encode()
assert status.err == err.encode()
outcome = status.outcome
assert outcome is not None
assert bool(outcome) is True, outcome
assert outcome.exit_code == Outcome.OK
assert outcome.err == err
assert outcome.out == out
assert outcome.request == request
out_got, err_got = out_err.read_out_err()
if show:
assert out_got == out
expected = (f"{Fore.RED}{err}{Fore.RESET}" if color else err) if err else ""
assert err_got == expected
else:
assert not out_got
assert not err_got
assert not caplog.records
def test_local_execute_basic_pass_show_on_standard_newline_flush(caplog: LogCaptureFixture) -> None:
caplog.set_level(logging.NOTSET)
executor = LocalSubProcessExecutor(colored=False)
request = ExecuteRequest(
cmd=[sys.executable, "-c", "import sys; print('out'); print('yay')"],
cwd=Path(),
env=os.environ.copy(),
stdin=StdinSource.OFF,
run_id="",
)
out_err = FakeOutErr()
with executor.call(request, show=True, out_err=out_err.out_err, env=MagicMock()) as status:
while status.exit_code is None: # pragma: no branch
status.wait()
outcome = status.outcome
assert outcome is not None
assert repr(outcome)
assert bool(outcome) is True, outcome
assert outcome.exit_code == Outcome.OK
assert not outcome.err
assert outcome.out == f"out{os.linesep}yay{os.linesep}"
out, err = out_err.read_out_err()
assert out == f"out{os.linesep}yay{os.linesep}"
assert not err
assert not caplog.records
def test_local_execute_write_a_lot(os_env: dict[str, str]) -> None:
count = 10_000
executor = LocalSubProcessExecutor(colored=False)
request = ExecuteRequest(
cmd=[
sys.executable,
"-c",
(
"import sys; import time; from datetime import datetime; import os;"
f"print('e' * {count}, file=sys.stderr);"
f"print('o' * {count}, file=sys.stdout);"
"time.sleep(0.5);"
f"print('a' * {count}, file=sys.stderr);"
f"print('b' * {count}, file=sys.stdout);"
),
],
cwd=Path(),
env=os_env,
stdin=StdinSource.OFF,
run_id="",
)
out_err = FakeOutErr()
with executor.call(request, show=False, out_err=out_err.out_err, env=MagicMock()) as status:
while status.exit_code is None: # pragma: no branch
status.wait()
outcome = status.outcome
assert outcome is not None
assert bool(outcome), outcome
expected_out = f"{'o' * count}{os.linesep}{'b' * count}{os.linesep}"
assert outcome.out == expected_out, expected_out[len(outcome.out) :]
expected_err = f"{'e' * count}{os.linesep}{'a' * count}{os.linesep}"
assert outcome.err == expected_err, expected_err[len(outcome.err) :]
@pytest.mark.skipif(sys.platform == "win32", reason="Unix terminal size test")
def test_local_execute_terminal_size(os_env: dict[str, str], monkeypatch: MonkeyPatch) -> None:
"""Regression test for #2999 - check terminal size is set correctly in tox subprocess."""
import pty # noqa: PLC0415
terminal_size = os.terminal_size((84, 42))
main, child = pty.openpty() # type: ignore[attr-defined, unused-ignore]
# Use ReadViaThreadUnix to help with debugging the test itself.
pipe_out = ReadViaThreadUnix(main, sys.stdout.buffer.write, name="testout", drain=True) # type: ignore[arg-type]
with pipe_out, monkeypatch.context() as monkey, open( # noqa: PTH123
child, "w", encoding=locale.getpreferredencoding(False)
) as stdout_mock:
# Switch stdout with test pty
monkey.setattr(sys, "stdout", stdout_mock)
monkey.setenv("COLUMNS", "84")
monkey.setenv("LINES", "42")
executor = LocalSubProcessExecutor(colored=False)
request = ExecuteRequest(
cmd=[sys.executable, "-c", "import os; print(os.get_terminal_size())"],
cwd=Path(),
env=os_env,
stdin=StdinSource.OFF,
run_id="",
)
out_err = FakeOutErr()
with executor.call(request, show=False, out_err=out_err.out_err, env=MagicMock()) as status:
while status.exit_code is None: # pragma: no branch
status.wait()
outcome = status.outcome
assert outcome is not None
assert bool(outcome), outcome
expected_out = f"{terminal_size!r}\r\n"
assert outcome.out == expected_out, expected_out[len(outcome.out) :]
assert not outcome.err
def test_local_execute_basic_fail(capsys: CaptureFixture, caplog: LogCaptureFixture, monkeypatch: MonkeyPatch) -> None:
monkeypatch.chdir(Path(__file__).parents[3])
caplog.set_level(logging.NOTSET)
executor = LocalSubProcessExecutor(colored=False)
cwd = Path().absolute()
cmd = [
sys.executable,
"-c",
"import sys; print('out', end=''); print('err', file=sys.stderr, end=''); sys.exit(3)",
]
request = ExecuteRequest(cmd=cmd, cwd=cwd, env=os.environ.copy(), stdin=StdinSource.OFF, run_id="")
# run test
out_err = FakeOutErr()
with executor.call(request, show=False, out_err=out_err.out_err, env=MagicMock()) as status:
while status.exit_code is None: # pragma: no branch
status.wait()
outcome = status.outcome
assert outcome is not None
assert repr(outcome)
# assert no output, no logs
out, err = out_err.read_out_err()
assert not out
assert not err
assert not caplog.records
# assert return object
assert bool(outcome) is False, outcome
assert outcome.exit_code == 3
assert outcome.err == "err"
assert outcome.out == "out"
assert outcome.request == request
# asset fail
with pytest.raises(SystemExit) as context:
outcome.assert_success()
# asset fail
assert context.value.code == 3
out, err = capsys.readouterr()
assert out == "out\n"
expected = f"{Fore.RED}err{Fore.RESET}\n"
assert err == expected
assert len(caplog.records) == 1
record = caplog.records[0]
assert record.levelno == logging.CRITICAL
assert record.msg == "exit %s (%.2f seconds) %s> %s%s"
assert record.args is not None
_code, _duration, _cwd, _cmd, _metadata = record.args
assert _code == 3
assert _cwd == cwd
assert _cmd == request.shell_cmd
assert isinstance(_duration, float)
assert _duration > 0
assert isinstance(_metadata, str)
assert _metadata.startswith(" pid=")
def test_command_does_not_exist(caplog: LogCaptureFixture, os_env: dict[str, str]) -> None:
caplog.set_level(logging.NOTSET)
executor = LocalSubProcessExecutor(colored=False)
request = ExecuteRequest(
cmd=["sys-must-be-missing"],
cwd=Path().absolute(),
env=os_env,
stdin=StdinSource.OFF,
run_id="",
)
out_err = FakeOutErr()
with executor.call(request, show=False, out_err=out_err.out_err, env=MagicMock()) as status:
while status.exit_code is None: # pragma: no branch
status.wait() # pragma: no cover
outcome = status.outcome
assert outcome is not None
assert bool(outcome) is False, outcome
assert outcome.exit_code != Outcome.OK
assert not outcome.out
assert not outcome.err
assert not caplog.records
@pytest.mark.skipif(sys.platform == "win32", reason="You need a conhost shell for keyboard interrupt")
@pytest.mark.flaky(max_runs=3, min_passes=1)
def test_command_keyboard_interrupt(tmp_path: Path, monkeypatch: MonkeyPatch, capfd: CaptureFixture) -> None:
monkeypatch.chdir(tmp_path)
process_up_signal = tmp_path / "signal"
cmd = [sys.executable, str(Path(__file__).parent / "local_subprocess_sigint.py"), str(process_up_signal)]
process = subprocess.Popen(cmd)
while not process_up_signal.exists():
assert process.poll() is None
root = process.pid
try:
child = next(iter(psutil.Process(pid=root).children())).pid
except AccessDenied as exc: # pragma: no cover # on termux for example
pytest.skip(str(exc)) # pragma: no cover
raise # pragma: no cover
print(f"test running in {os.getpid()} and sending CTRL+C to {process.pid}", file=sys.stderr) # noqa: T201
process.send_signal(SIG_INTERRUPT)
try:
process.communicate(timeout=3)
except subprocess.TimeoutExpired: # pragma: no cover
process.kill()
raise
out, err = capfd.readouterr()
assert f"W requested interrupt of {child} from {root}, activate in 0.01" in err, err
assert f"W send signal SIGINT(2) to {child} from {root} with timeout 0.05" in err, err
assert f"W send signal SIGTERM(15) to {child} from {root} with timeout 0.07" in err, err
assert f"W send signal SIGKILL(9) to {child} from {root}" in err, err
outs = out.split("\n")
exit_code = int(outs[0])
assert exit_code == -9
assert float(outs[3]) > 0 # duration
assert "how about no signal 2" in outs[1], outs[1] # 2 - Interrupt
assert "how about no signal 15" in outs[1], outs[1] # 15 - Terminated
@pytest.mark.parametrize("tty_mode", ["on", "off"])
def test_local_subprocess_tty(monkeypatch: MonkeyPatch, mocker: MockerFixture, tty_mode: str) -> None:
monkeypatch.setenv("COLUMNS", "100")
monkeypatch.setenv("LINES", "100")
tty = tty_mode == "on"
mocker.patch("sys.stdout.isatty", return_value=tty)
mocker.patch("sys.stderr.isatty", return_value=tty)
try:
import termios # noqa: F401, PLC0415
except ImportError:
exp_tty = False # platforms without tty support at all
else:
# to avoid trying (and failing) to copy mode bits
exp_tty = tty
mocker.patch("termios.tcgetattr")
mocker.patch("termios.tcsetattr")
executor = LocalSubProcessExecutor(colored=False)
cmd: list[str] = [sys.executable, str(Path(__file__).parent / "tty_check.py")]
request = ExecuteRequest(cmd=cmd, stdin=StdinSource.API, cwd=Path.cwd(), env=dict(os.environ), run_id="")
out_err = FakeOutErr()
with executor.call(request, show=False, out_err=out_err.out_err, env=MagicMock()) as status:
while status.exit_code is None: # pragma: no branch
status.wait()
outcome = status.outcome
assert outcome is not None
assert outcome
info = json.loads(outcome.out)
assert info == {
"stdout": exp_tty,
"stderr": exp_tty,
"stdin": False,
"terminal": [100, 100],
}
@pytest.mark.parametrize("mode", ["stem", "full", "stem-pattern", "full-pattern", "all"])
def test_allow_list_external_ok(fake_exe_on_path: Path, mode: str) -> None:
exe = f"{fake_exe_on_path}{'.EXE' if sys.platform == 'win32' else ''}"
allow = exe if "full" in mode else fake_exe_on_path.stem
allow = f"{allow[:-2]}*" if "pattern" in mode else allow
allow = "*" if mode == "all" else allow
request = ExecuteRequest(
cmd=[fake_exe_on_path.stem],
cwd=Path.cwd(),
env={"PATH": os.environ["PATH"]},
stdin=StdinSource.OFF,
run_id="run-id",
allow=[allow],
)
inst = LocalSubProcessExecuteInstance(request, MagicMock(), out=SyncWrite("out", None), err=SyncWrite("err", None))
assert inst.cmd == [exe]
def test_shebang_limited_on(tmp_path: Path) -> None:
exe, script, instance = _create_shebang_test(tmp_path, env={"TOX_LIMITED_SHEBANG": "1"})
if sys.platform == "win32": # pragma: win32 cover
assert instance.cmd == [str(script), "--magic"]
else:
assert instance.cmd == [exe, "-s", str(script), "--magic"]
@pytest.mark.parametrize("env", [{}, {"TOX_LIMITED_SHEBANG": ""}])
def test_shebang_limited_off(tmp_path: Path, env: dict[str, str]) -> None:
_, script, instance = _create_shebang_test(tmp_path, env=env)
assert instance.cmd == [str(script), "--magic"]
def test_shebang_failed_to_parse(tmp_path: Path) -> None:
_, script, instance = _create_shebang_test(tmp_path, env={"TOX_LIMITED_SHEBANG": "yes"})
script.write_text("")
assert instance.cmd == [str(script), "--magic"]
def _create_shebang_test(tmp_path: Path, env: dict[str, str]) -> tuple[str, Path, LocalSubProcessExecuteInstance]:
exe = shutil.which("python")
assert exe is not None
script = tmp_path / f"s{'.EXE' if sys.platform == 'win32' else ''}"
script.write_text(f"#!{exe} -s")
script.chmod(script.stat().st_mode | stat.S_IEXEC) # mark it executable
env["PATH"] = str(script.parent)
request = create_autospec(ExecuteRequest, cmd=["s", "--magic"], env=env, allow=None)
writer = create_autospec(SyncWrite)
instance = LocalSubProcessExecuteInstance(request, create_autospec(ExecuteOptions), writer, writer)
return exe, script, instance
@pytest.mark.parametrize("key", ["COLUMNS", "ROWS"])
def test_local_execute_does_not_overwrite(key: str, mocker: MockerFixture) -> None:
mocker.patch("shutil.get_terminal_size", return_value=(101, 102))
env = dict(os.environ)
env[key] = key
executor = LocalSubProcessExecutor(colored=False)
cmd = [sys.executable, "-c", f"import os; print(os.environ['{key}'], end='')"]
request = ExecuteRequest(cmd=cmd, stdin=StdinSource.API, cwd=Path.cwd(), env=env, run_id="")
out_err = FakeOutErr()
with executor.call(request, show=False, out_err=out_err.out_err, env=MagicMock()) as status:
while status.exit_code is None: # pragma: no branch
status.wait()
outcome = status.outcome
assert outcome is not None
assert outcome.out == key
tox-4.13.0/tests/execute/local_subprocess/tty_check.py 0000664 0000000 0000000 00000000457 14564001166 0023117 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import json
import shutil
import sys
args = {
"stdout": sys.stdout.isatty(),
"stderr": sys.stderr.isatty(),
"stdin": sys.stdin.isatty(),
"terminal": shutil.get_terminal_size(fallback=(-1, -1)),
}
result = json.dumps(args)
print(result) # noqa: T201
tox-4.13.0/tests/execute/test_request.py 0000664 0000000 0000000 00000001312 14564001166 0020316 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
import sys
from pathlib import Path
import pytest
from tox.execute.request import ExecuteRequest, StdinSource
def test_execute_request_raise_on_empty_cmd(os_env: dict[str, str]) -> None:
with pytest.raises(ValueError, match="cannot execute an empty command"):
ExecuteRequest(cmd=[], cwd=Path().absolute(), env=os_env, stdin=StdinSource.OFF, run_id="")
def test_request_allow_star_is_none() -> None:
request = ExecuteRequest(
cmd=[sys.executable],
cwd=Path.cwd(),
env={"PATH": os.environ["PATH"]},
stdin=StdinSource.OFF,
run_id="run-id",
allow=["*", "magic"],
)
assert request.allow is None
tox-4.13.0/tests/execute/test_stream.py 0000664 0000000 0000000 00000000726 14564001166 0020131 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from colorama import Fore
from tox.execute.stream import SyncWrite
def test_sync_write_repr() -> None:
sync_write = SyncWrite(name="a", target=None, color=Fore.RED)
assert repr(sync_write) == f"SyncWrite(name='a', target=None, color={Fore.RED!r})"
def test_sync_write_decode_surrogate() -> None:
sync_write = SyncWrite(name="a", target=None)
sync_write.handler(b"\xed\n")
assert sync_write.text == "\udced\n"
tox-4.13.0/tests/journal/ 0000775 0000000 0000000 00000000000 14564001166 0015230 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/journal/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0017327 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/journal/test_main_journal.py 0000664 0000000 0000000 00000002356 14564001166 0021325 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import socket
import sys
from typing import Any
import pytest
from tox import __version__
from tox.journal.main import Journal
@pytest.fixture()
def base_info() -> dict[str, Any]:
return {
"reportversion": "1",
"toxversion": __version__,
"platform": sys.platform,
"host": socket.getfqdn(),
}
def test_journal_enabled_default(base_info: dict[str, Any]) -> None:
journal = Journal(enabled=True)
assert bool(journal) is True
assert journal.content == base_info
def test_journal_disabled_default() -> None:
journal = Journal(enabled=False)
assert bool(journal) is False
assert journal.content == {}
def test_env_journal_enabled(base_info: dict[str, Any]) -> None:
journal = Journal(enabled=True)
env = journal.get_env_journal("a")
assert journal.get_env_journal("a") is env
env["demo"] = 1
assert bool(env) is True
base_info["testenvs"] = {"a": {"demo": 1}}
assert journal.content == base_info
def test_env_journal_disabled() -> None:
journal = Journal(enabled=False)
env = journal.get_env_journal("a")
assert bool(env) is False
env["demo"] = 2
assert journal.content == {"testenvs": {"a": {"demo": 2}}}
tox-4.13.0/tests/plugin/ 0000775 0000000 0000000 00000000000 14564001166 0015054 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/plugin/conftest.py 0000664 0000000 0000000 00000000620 14564001166 0017251 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from pathlib import Path
from typing import Any, Sequence
HERE = Path(__file__).parent
def pytest_collection_modifyitems(items: Sequence[Any]) -> None:
"""automatically apply plugin test to all the test in this suite"""
root = str(HERE)
for item in items:
if item.module.__file__.startswith(root):
item.add_marker("plugin_test")
tox-4.13.0/tests/plugin/test_inline.py 0000664 0000000 0000000 00000001351 14564001166 0017743 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from tox.config.cli.parser import ToxParser
from tox.pytest import ToxProjectCreator
def test_inline_tox_py(tox_project: ToxProjectCreator) -> None:
def plugin() -> None: # pragma: no cover # the code is copied to a python file
import logging # noqa: PLC0415
from tox.plugin import impl # noqa: PLC0415
@impl
def tox_add_option(parser: ToxParser) -> None:
logging.warning("Add magic")
parser.add_argument("--magic", action="store_true")
project = tox_project({"toxfile.py": plugin})
result = project.run("-h")
result.assert_success()
assert "--magic" in result.out
tox-4.13.0/tests/plugin/test_plugin.py 0000664 0000000 0000000 00000022110 14564001166 0017757 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import logging
import os
import sys
from typing import TYPE_CHECKING, Any
from unittest.mock import patch
import pytest
from tox.config.cli.parser import ToxParser
from tox.config.loader.memory import MemoryLoader
from tox.config.sets import ConfigSet, CoreConfigSet, EnvConfigSet
from tox.execute import Outcome
from tox.plugin import impl
from tox.pytest import ToxProjectCreator, register_inline_plugin
from tox.session.state import State
from tox.tox_env.api import ToxEnv
from tox.tox_env.register import ToxEnvRegister
if TYPE_CHECKING:
from pathlib import Path
from pytest_mock import MockerFixture
def test_plugin_hooks_and_order(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
@impl
def tox_register_tox_env(register: ToxEnvRegister) -> None:
assert isinstance(register, ToxEnvRegister)
logging.warning("tox_register_tox_env")
@impl
def tox_add_option(parser: ToxParser) -> None:
assert isinstance(parser, ToxParser)
logging.warning("tox_add_option")
@impl
def tox_add_core_config(core_conf: CoreConfigSet, state: State) -> None:
assert isinstance(core_conf, CoreConfigSet)
assert isinstance(state, State)
logging.warning("tox_add_core_config")
@impl
def tox_add_env_config(env_conf: EnvConfigSet, state: State) -> None:
assert isinstance(env_conf, EnvConfigSet)
assert isinstance(state, State)
logging.warning("tox_add_env_config")
@impl
def tox_before_run_commands(tox_env: ToxEnv) -> None:
assert isinstance(tox_env, ToxEnv)
logging.warning("tox_before_run_commands")
@impl
def tox_on_install(tox_env: ToxEnv, arguments: Any, section: str, of_type: str) -> None:
assert isinstance(tox_env, ToxEnv)
assert arguments is not None
assert isinstance(section, str)
assert isinstance(of_type, str)
logging.warning("tox_on_install %s %s", section, of_type)
@impl
def tox_after_run_commands(tox_env: ToxEnv, exit_code: int, outcomes: list[Outcome]) -> None:
assert isinstance(tox_env, ToxEnv)
assert exit_code == 0
assert isinstance(outcomes, list)
assert all(isinstance(i, Outcome) for i in outcomes)
logging.warning("tox_after_run_commands")
@impl
def tox_env_teardown(tox_env: ToxEnv) -> None:
assert isinstance(tox_env, ToxEnv)
logging.warning("teardown")
plugins = tuple(v for v in locals().values() if callable(v) and hasattr(v, "tox_impl"))
assert len(plugins) == 8
register_inline_plugin(mocker, *plugins)
tox_ini = """
[tox]
env_list=a,b
[testenv]
package=skip
commands=python -c 'print(1)'
env_list=a,b
"""
project = tox_project({"tox.ini": tox_ini})
result = project.run("r", "-e", "a,b")
result.assert_success()
cmd = "print(1)" if sys.platform == "win32" else "'print(1)'"
expected = [
"ROOT: tox_register_tox_env",
"ROOT: tox_add_option",
"ROOT: tox_add_core_config",
"a: tox_add_env_config",
"b: tox_add_env_config",
"a: tox_on_install PythonRun deps",
"a: tox_before_run_commands",
f"a: commands[0]> python -c {cmd}",
mocker.ANY, # output a
"a: tox_after_run_commands",
"a: teardown",
mocker.ANY, # report finished A
"b: tox_on_install PythonRun deps",
"b: tox_before_run_commands",
f"b: commands[0]> python -c {cmd}",
mocker.ANY, # output b
"b: tox_after_run_commands",
"b: teardown",
mocker.ANY, # report a
mocker.ANY, # report b
mocker.ANY, # overall report
]
assert result.out.splitlines() == expected, result.out
@pytest.mark.parametrize(
"dir_name",
[
"tox_root",
"work_dir",
"temp_dir",
],
)
def test_plugin_can_set_core_conf(
tox_project: ToxProjectCreator,
mocker: MockerFixture,
dir_name: str,
tmp_path: Path,
) -> None:
@impl
def tox_add_core_config(core_conf: CoreConfigSet, state: State) -> None: # noqa: ARG001
core_conf.loaders.insert(0, MemoryLoader(**{dir_name: tmp_path}))
register_inline_plugin(mocker, tox_add_core_config)
project = tox_project({})
result = project.run("c")
result.assert_success()
assert result.state.conf.core[dir_name] == tmp_path
def test_plugin_can_read_env_list(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
@impl
def tox_add_core_config(core_conf: CoreConfigSet, state: State) -> None: # noqa: ARG001
logging.warning("All envs: %s", ", ".join(state.envs.iter(only_active=False)))
logging.warning("Default envs: %s", ", ".join(state.envs.iter(only_active=True)))
register_inline_plugin(mocker, tox_add_core_config)
ini = """
[tox]
env_list = explicit
[testenv]
package = skip
set_env =
implicit: A=1
[testenv:section]
"""
project = tox_project({"tox.ini": ini})
result = project.run()
assert "ROOT: All envs: explicit, section, implicit" in result.out
assert "ROOT: Default envs: explicit" in result.out
def test_plugin_can_read_sections(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
@impl
def tox_add_core_config(core_conf: CoreConfigSet, state: State) -> None: # noqa: ARG001
logging.warning("Sections: %s", ", ".join(i.key for i in state.conf.sections()))
register_inline_plugin(mocker, tox_add_core_config)
ini = """
[tox]
[testenv]
package = skip
[testenv:section]
[other:section]
"""
project = tox_project({"tox.ini": ini})
result = project.run()
result.assert_success()
assert "ROOT: Sections: tox, testenv, testenv:section, other:section" in result.out
def test_plugin_injects_invalid_python_run(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
@impl
def tox_add_env_config(env_conf: EnvConfigSet, state: State) -> None: # noqa: ARG001
env_conf.loaders.insert(0, MemoryLoader(deps=[1]))
with pytest.raises(TypeError, match="1"):
assert env_conf["deps"]
register_inline_plugin(mocker, tox_add_env_config)
project = tox_project({"tox.ini": "[testenv]\npackage=skip"})
result = project.run()
result.assert_failed()
assert "raise TypeError(raw)" in result.out
def test_plugin_extend_pass_env(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
@impl
def tox_add_env_config(env_conf: EnvConfigSet, state: State) -> None: # noqa: ARG001
env_conf["pass_env"].append("MAGIC_*")
register_inline_plugin(mocker, tox_add_env_config)
ini = """
[testenv]
package=skip
commands=python -c 'import os; print(os.environ["MAGIC_1"]); print(os.environ["MAGIC_2"])'
"""
project = tox_project({"tox.ini": ini})
with patch.dict(os.environ, {"MAGIC_1": "magic_1", "MAGIC_2": "magic_2"}):
result = project.run("r")
result.assert_success()
assert "magic_1" in result.out
assert "magic_2" in result.out
result_conf = project.run("c", "-e", "py", "-k", "pass_env")
result_conf.assert_success()
assert "MAGIC_*" in result_conf.out
def test_plugin_extend_set_env(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
@impl
def tox_add_env_config(env_conf: EnvConfigSet, state: State) -> None: # noqa: ARG001
env_conf["set_env"].update({"MAGI_CAL": "magi_cal"})
register_inline_plugin(mocker, tox_add_env_config)
ini = """
[testenv]
package=skip
commands=python -c 'import os; print(os.environ["MAGI_CAL"])'
"""
project = tox_project({"tox.ini": ini})
result = project.run("r")
result.assert_success()
assert "magi_cal" in result.out
result_conf = project.run("c", "-e", "py", "-k", "set_env")
result_conf.assert_success()
assert "MAGI_CAL=magi_cal" in result_conf.out
def test_plugin_config_frozen_past_add_env(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
def _cannot_extend_config(config_set: ConfigSet) -> None:
for _conf in (
lambda c: c.add_constant("c", "desc", "v"),
lambda c: c.add_config("c", of_type=str, default="c", desc="d"),
):
try:
_conf(config_set) # type: ignore[no-untyped-call] # call to not typed function
raise NotImplementedError
except RuntimeError as exc: # noqa: PERF203
assert str(exc) == "config set has been marked final and cannot be extended" # noqa: PT017
@impl
def tox_before_run_commands(tox_env: ToxEnv) -> None:
_cannot_extend_config(tox_env.conf)
_cannot_extend_config(tox_env.core)
@impl
def tox_after_run_commands(tox_env: ToxEnv, exit_code: int, outcomes: list[Outcome]) -> None: # noqa: ARG001
_cannot_extend_config(tox_env.conf)
_cannot_extend_config(tox_env.core)
register_inline_plugin(mocker, tox_before_run_commands, tox_after_run_commands)
project = tox_project({"tox.ini": "[testenv]\npackage=skip"})
result = project.run("r")
result.assert_success()
tox-4.13.0/tests/plugin/test_plugin_custom_config_set.py 0000664 0000000 0000000 00000007024 14564001166 0023560 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import logging
from functools import partial
from typing import TYPE_CHECKING, Optional
import pytest
from tox.config.loader.section import Section
from tox.config.sets import ConfigSet, EnvConfigSet
from tox.plugin import impl
from tox.pytest import ToxProjectCreator, register_inline_plugin
if TYPE_CHECKING:
from pytest_mock import MockerFixture
from tox.session.state import State
from tox.tox_env.api import ToxEnv
@pytest.fixture(autouse=True)
def _custom_config_set(mocker: MockerFixture) -> None:
class DockerConfigSet(ConfigSet):
def register_config(self) -> None:
self.add_config(keys="A", of_type=int, default=0, desc="a config")
@impl
def tox_add_env_config(env_conf: EnvConfigSet, state: State) -> None:
def factory(for_env: str, raw: object) -> DockerConfigSet:
assert isinstance(raw, str)
section = Section("docker", raw)
return state.conf.get_section_config(section, base=["docker"], of_type=DockerConfigSet, for_env=for_env)
env_conf.add_config(
"docker",
of_type=Optional[DockerConfigSet], # type: ignore[arg-type] # mypy fails to understand the type info
default=None,
desc="docker env",
factory=partial(factory, env_conf.name),
)
@impl
def tox_before_run_commands(tox_env: ToxEnv) -> None:
docker: DockerConfigSet | None = tox_env.conf["docker"]
assert docker is not None
logging.warning("Name=%s env=%s A=%d", docker.name, docker.env_name, docker["A"])
register_inline_plugin(mocker, tox_add_env_config, tox_before_run_commands)
def test_define_custom_config_set(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv]\npackage=skip\ndocker=a\n[docker:a]\nA=2"})
result = project.run()
result.assert_success()
assert "py: Name=a env=py A=2" in result.out
def test_define_custom_config_base(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv]\npackage=skip\ndocker=a\n[docker]\nA=2"})
result = project.run()
result.assert_success()
assert "py: Name=a env=py A=2" in result.out
def test_define_custom_config_override_base(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv]\npackage=skip\ndocker=a\n[M]\nA=2\n[docker:a]\nbase=M"})
result = project.run()
result.assert_success()
assert "py: Name=a env=py A=2" in result.out
def test_define_custom_config_override_base_implicit(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv]\npackage=skip\ndocker=a\n[docker:M]\nA=2\n[docker:a]\nbase=M"})
result = project.run()
result.assert_success()
assert "py: Name=a env=py A=2" in result.out
def test_define_custom_config_replace(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv]\npackage=skip\ndocker=a\n[docker]\nA={[docker]B}\nB=2"})
result = project.run()
result.assert_success()
assert "py: Name=a env=py A=2" in result.out
def test_define_custom_config_factor_filter(tox_project: ToxProjectCreator) -> None:
ini = """
[tox]
env_list =
a
b
[testenv]
package = skip
docker = db
[docker:db]
A =
a: 1
b: 2"""
project = tox_project({"tox.ini": ini})
result = project.run("r", "-e", "a,b")
result.assert_success()
assert "a: Name=db env=a A=1" in result.out
assert "b: Name=db env=b A=2" in result.out
tox-4.13.0/tests/pytest_/ 0000775 0000000 0000000 00000000000 14564001166 0015245 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/pytest_/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0017344 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/pytest_/test_init.py 0000664 0000000 0000000 00000007713 14564001166 0017631 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
import sys
from itertools import chain, combinations
from textwrap import dedent
from typing import TYPE_CHECKING, Sequence
import pytest
from tox.pytest import MonkeyPatch, ToxProjectCreator, check_os_environ
from tox.report import HandledError
if TYPE_CHECKING:
from pathlib import Path
from pytest_mock import MockerFixture
def test_tox_project_no_base(tox_project: ToxProjectCreator) -> None:
project = tox_project(
{
"tox.ini": "[tox]",
"src": {"__init__.py": "pass", "a": "out", "b": {"c": "out"}, "e": {"f": ""}},
},
)
assert str(project.path) in repr(project)
assert project.path.exists()
assert project.structure == {
"tox.ini": "[tox]",
"src": {"__init__.py": "pass", "a": "out", "e": {"f": ""}, "b": {"c": "out"}},
}
def test_tox_project_base(tmp_path: Path, tox_project: ToxProjectCreator) -> None:
base = tmp_path / "base"
base.mkdir()
(base / "out").write_text("a")
project = tox_project({"tox.ini": "[tox]"}, base=base)
assert project.structure
COMB = list(chain.from_iterable(combinations(["DIFF", "MISS", "EXTRA"], i) for i in range(4)))
@pytest.mark.parametrize("ops", COMB, ids=["-".join(i) for i in COMB])
def test_env_var(monkeypatch: MonkeyPatch, ops: list[str]) -> None:
with monkeypatch.context() as m:
if "DIFF" in ops:
m.setenv("DIFF", "B")
if "MISS" in ops:
m.setenv("MISS", "1")
m.setenv("NO_CHANGE", "yes")
m.setenv("PYTHONPATH", "yes") # values to clean before run
with check_os_environ():
assert "PYTHONPATH" not in os.environ
if "EXTRA" in ops:
m.setenv("EXTRA", "A")
if "DIFF" in ops:
m.setenv("DIFF", "D")
if "MISS" in ops:
m.delenv("MISS")
from tox.pytest import pytest as tox_pytest # type: ignore[attr-defined] # noqa: PLC0415
exp = "test changed environ"
if "EXTRA" in ops:
exp += " extra {'EXTRA': 'A'}"
if "MISS" in ops:
exp += " miss {'MISS': '1'}"
if "DIFF" in ops:
exp += " diff {'DIFF = B vs D'}"
def fail(msg: str) -> None:
assert msg == exp
m.setattr(tox_pytest, "fail", fail)
assert "PYTHONPATH" in os.environ
def test_tox_run_does_not_return_exit_code(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
project = tox_project({"tox.ini": ""})
mocker.patch("tox.run.main", return_value=None)
with pytest.raises(RuntimeError, match="exit code not set"):
project.run("c")
def test_tox_run_fails_before_state_setup(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
project = tox_project({"tox.ini": ""})
mocker.patch("tox.run.main", side_effect=HandledError("something went bad"))
outcome = project.run("c")
with pytest.raises(RuntimeError, match="no state"):
assert outcome.state
def test_tox_run_outcome_repr(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": ""})
outcome = project.run("l")
msg = dedent(
f"""
code: 0
cmd: {sys.executable} -m tox l
cwd: {project.path}
standard output
default environments:
py -> [no description]
""",
).lstrip()
assert repr(outcome) == msg
assert outcome.shell_cmd == f"{sys.executable} -m tox l"
def test_tox_run_assert_out_err_no_dedent(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
project = tox_project({"tox.ini": ""})
def _main(args: Sequence[str]) -> int: # noqa: ARG001
print(" goes on out", file=sys.stdout) # noqa: T201
print(" goes on err", file=sys.stderr) # noqa: T201
return 0
mocker.patch("tox.run.main", side_effect=_main)
outcome = project.run("c")
outcome.assert_out_err(" goes on out\n", " goes on err\n", dedent=False)
tox-4.13.0/tests/session/ 0000775 0000000 0000000 00000000000 14564001166 0015241 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/session/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0017340 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/session/cmd/ 0000775 0000000 0000000 00000000000 14564001166 0016004 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/session/cmd/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0020103 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/session/cmd/run/ 0000775 0000000 0000000 00000000000 14564001166 0016610 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/session/cmd/run/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0020707 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/session/cmd/run/test_common.py 0000664 0000000 0000000 00000005064 14564001166 0021516 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
import re
from argparse import ArgumentError, ArgumentParser, Namespace
from typing import TYPE_CHECKING
import pytest
from tox.session.cmd.run.common import InstallPackageAction, SkipMissingInterpreterAction
if TYPE_CHECKING:
from pathlib import Path
from tox.pytest import ToxProjectCreator
@pytest.mark.parametrize("values", ["config", None, "true", "false"])
def test_skip_missing_interpreter_action_ok(values: str | None) -> None:
args_namespace = Namespace()
SkipMissingInterpreterAction(option_strings=["-i"], dest="into")(ArgumentParser(), args_namespace, values)
expected = "true" if values is None else values
assert args_namespace.into == expected
def test_skip_missing_interpreter_action_nok() -> None:
argument_parser = ArgumentParser()
with pytest.raises(ArgumentError, match=r"value must be 'config', 'true', or 'false' \(got 'bad value'\)"):
SkipMissingInterpreterAction(option_strings=["-i"], dest="into")(argument_parser, Namespace(), "bad value")
def test_install_pkg_ok(tmp_path: Path) -> None:
argument_parser = ArgumentParser()
path = tmp_path / "a"
path.write_text("")
namespace = Namespace()
InstallPackageAction(option_strings=["--install-pkg"], dest="into")(argument_parser, namespace, str(path))
assert namespace.into == path
def test_install_pkg_does_not_exist(tmp_path: Path) -> None:
argument_parser = ArgumentParser()
path = str(tmp_path / "a")
with pytest.raises(ArgumentError, match=re.escape(f"argument --install-pkg: {path} does not exist")):
InstallPackageAction(option_strings=["--install-pkg"], dest="into")(argument_parser, Namespace(), path)
def test_install_pkg_not_file(tmp_path: Path) -> None:
argument_parser = ArgumentParser()
path = str(tmp_path)
with pytest.raises(ArgumentError, match=re.escape(f"argument --install-pkg: {path} is not a file")):
InstallPackageAction(option_strings=["--install-pkg"], dest="into")(argument_parser, Namespace(), path)
def test_install_pkg_empty() -> None:
argument_parser = ArgumentParser()
with pytest.raises(ArgumentError, match=re.escape("argument --install-pkg: cannot be empty")):
InstallPackageAction(option_strings=["--install-pkg"], dest="into")(argument_parser, Namespace(), "")
def test_empty_report(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": ""})
outcome = proj.run("exec", "-qq", "--", "python", "-c", "print('foo')")
outcome.assert_success()
outcome.assert_out_err(f"foo{os.linesep}", "")
tox-4.13.0/tests/session/cmd/test_depends.py 0000664 0000000 0000000 00000003255 14564001166 0021044 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from textwrap import dedent
from typing import TYPE_CHECKING, Callable
if TYPE_CHECKING:
from tox.pytest import ToxProjectCreator
def test_depends(tox_project: ToxProjectCreator, patch_prev_py: Callable[[bool], tuple[str, str]]) -> None:
prev_ver, impl = patch_prev_py(True) # has previous python
ver = sys.version_info[0:2]
py = f"py{''.join(str(i) for i in ver)}"
prev_py = f"py{prev_ver}"
ini = f"""
[tox]
env_list = py,{py},{prev_py},py31,cov2,cov
[testenv]
package = wheel
[testenv:cov]
depends = py,{py},{prev_py},py31
skip_install = true
[testenv:cov2]
depends = cov
skip_install = true
"""
project = tox_project({"tox.ini": ini, "pyproject.toml": ""})
outcome = project.run("de")
outcome.assert_success()
expected = f"""
Execution order: py, {py}, {prev_py}, py31, cov, cov2
ALL
py ~ .pkg
{py} ~ .pkg
{prev_py} ~ .pkg | .pkg-{impl}{prev_ver}
py31 ~ .pkg | ... (could not find python interpreter with spec(s): py31)
cov2
cov
py ~ .pkg
{py} ~ .pkg
{prev_py} ~ .pkg | .pkg-{impl}{prev_ver}
py31 ~ .pkg | ... (could not find python interpreter with spec(s): py31)
cov
py ~ .pkg
{py} ~ .pkg
{prev_py} ~ .pkg | .pkg-{impl}{prev_ver}
py31 ~ .pkg | ... (could not find python interpreter with spec(s): py31)
"""
assert outcome.out == dedent(expected).lstrip()
def test_depends_help(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("de", "-h")
outcome.assert_success()
tox-4.13.0/tests/session/cmd/test_devenv.py 0000664 0000000 0000000 00000002254 14564001166 0020707 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
import pytest
if TYPE_CHECKING:
from tox.pytest import ToxProjectCreator
def test_devenv_fail_multiple_target(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": "[tox]\nenv_list=a,b"}).run("d", "-e", "a,b")
outcome.assert_failed()
msg = "ROOT: HandledError| exactly one target environment allowed in devenv mode but found a, b\n"
outcome.assert_out_err(msg, "")
@pytest.mark.integration()
def test_devenv_ok(tox_project: ToxProjectCreator, enable_pip_pypi_access: str | None) -> None: # noqa: ARG001
content = {
"setup.py": "from setuptools import setup\nsetup(name='demo', version='1.0')",
"tox.ini": "[tox]\nenv_list = py\n[testenv]\nusedevelop = True",
}
project = tox_project(content)
outcome = project.run("d", "-e", "py")
outcome.assert_success()
assert (project.path / "venv").exists()
assert f"created development environment under {project.path / 'venv'}" in outcome.out
def test_devenv_help(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("d", "-h")
outcome.assert_success()
tox-4.13.0/tests/session/cmd/test_exec_.py 0000664 0000000 0000000 00000002754 14564001166 0020510 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from typing import TYPE_CHECKING
import pytest
if TYPE_CHECKING:
from tox.pytest import ToxProjectCreator
@pytest.mark.parametrize("trail", [[], ["--"]], ids=["no_posargs", "empty_posargs"])
def test_exec_fail_no_posargs(tox_project: ToxProjectCreator, trail: list[str]) -> None:
outcome = tox_project({"tox.ini": ""}).run("e", "-e", "py39", *trail)
outcome.assert_failed()
msg = "ROOT: HandledError| You must specify a command as positional arguments, use -- \n"
outcome.assert_out_err(msg, "")
def test_exec_fail_multiple_target(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("e", "-e", "py39,py38", "--", "py")
outcome.assert_failed()
msg = "ROOT: HandledError| exactly one target environment allowed in exec mode but found py39, py38\n"
outcome.assert_out_err(msg, "")
@pytest.mark.parametrize("exit_code", [1, 0])
def test_exec(tox_project: ToxProjectCreator, exit_code: int) -> None:
prj = tox_project({"tox.ini": "[testenv]\npackage=skip"})
py_cmd = f"import sys; print(sys.version); raise SystemExit({exit_code})"
outcome = prj.run("e", "-e", "py", "--", "python", "-c", py_cmd)
if exit_code:
outcome.assert_failed()
else:
outcome.assert_success()
assert sys.version in outcome.out
def test_exec_help(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("e", "-h")
outcome.assert_success()
tox-4.13.0/tests/session/cmd/test_legacy.py 0000664 0000000 0000000 00000012761 14564001166 0020670 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
import pytest
if TYPE_CHECKING:
from pathlib import Path
from pytest_mock import MockerFixture
from tox.pytest import ToxProjectCreator
def test_legacy_show_config(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
show_config = mocker.patch("tox.session.cmd.legacy.show_config")
outcome = tox_project({"tox.ini": ""}).run("le", "--showconfig")
assert show_config.call_count == 1
assert outcome.state.conf.options.list_keys_only == []
assert outcome.state.conf.options.show_core is True
def test_legacy_show_config_with_env(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
show_config = mocker.patch("tox.session.cmd.legacy.show_config")
outcome = tox_project({"tox.ini": ""}).run("le", "--showconfig", "-e", "py")
assert show_config.call_count == 1
assert outcome.state.conf.options.list_keys_only == []
assert outcome.state.conf.options.show_core is False
@pytest.mark.parametrize("verbose", range(3))
def test_legacy_list_default(tox_project: ToxProjectCreator, mocker: MockerFixture, verbose: int) -> None:
list_env = mocker.patch("tox.session.cmd.legacy.list_env")
outcome = tox_project({"tox.ini": ""}).run("le", "-l", *(["-v"] * verbose))
assert list_env.call_count == 1
assert outcome.state.conf.options.list_no_description is (verbose < 1)
assert outcome.state.conf.options.list_default_only is True
assert outcome.state.conf.options.show_core is False
@pytest.mark.parametrize(
"configuration",
[
pytest.param("", id="missing toxenv section"),
pytest.param("[toxenv]", id="missing envlist"),
pytest.param("[toxenv]\nenv_list=", id="empty envlist"),
],
)
def test_legacy_list_env_with_empty_or_missing_env_list(tox_project: ToxProjectCreator, configuration: str) -> None:
"""we want to stay backwards compatible with tox 3 and show no output"""
outcome = tox_project({"tox.ini": configuration}).run("le", "-l")
outcome.assert_success()
assert not outcome.err
assert not outcome.out
def test_legacy_list_env_with_no_tox_file(tox_project: ToxProjectCreator) -> None:
project = tox_project({})
outcome = project.run("le", "-l")
outcome.assert_success()
out = f"ROOT: No tox.ini or setup.cfg or pyproject.toml found, assuming empty tox.ini at {project.path}\n"
assert not outcome.err
assert outcome.out == out
@pytest.mark.parametrize("verbose", range(3))
def test_legacy_list_all(tox_project: ToxProjectCreator, mocker: MockerFixture, verbose: int) -> None:
list_env = mocker.patch("tox.session.cmd.legacy.list_env")
outcome = tox_project({"tox.ini": ""}).run("le", "-a", *(["-v"] * verbose))
assert list_env.call_count == 1
assert outcome.state.conf.options.list_no_description is (verbose < 1)
assert outcome.state.conf.options.list_default_only is False
assert outcome.state.conf.options.show_core is False
@pytest.mark.parametrize(
"args",
[
pytest.param((), id="empty"),
pytest.param(("-e", "py"), id="select"),
],
)
def test_legacy_devenv(
tox_project: ToxProjectCreator,
mocker: MockerFixture,
tmp_path: Path,
args: tuple[str, ...],
) -> None:
run_sequential = mocker.patch("tox.session.cmd.devenv.run_sequential")
into = tmp_path / "b"
outcome = tox_project({"tox.ini": ""}).run("le", "--devenv", str(into), *args)
assert run_sequential.call_count == 1
assert outcome.state.conf.options.devenv_path == into
assert set(outcome.state.conf.options.env) == {"py"}
def test_legacy_run_parallel(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
run_parallel = mocker.patch("tox.session.cmd.legacy.run_parallel")
tox_project({"tox.ini": ""}).run("le", "-p", "all", "-e", "py")
assert run_parallel.call_count == 1
def test_legacy_run_sequential(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
run_sequential = mocker.patch("tox.session.cmd.legacy.run_sequential")
tox_project({"tox.ini": ""}).run("le", "-e", "py")
assert run_sequential.call_count == 1
def test_legacy_help(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("le", "-h")
outcome.assert_success()
def test_legacy_cli_flags(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
session = mocker.MagicMock()
session.creator.interpreter.system_executable = "I"
virtualenv_session = mocker.patch("tox.tox_env.python.virtual_env.api.session_via_cli", return_value=session)
ini = "[testenv]\ndeps = p>6\n c\n -rr.txt\npackage=skip\nset_env = PIP_PRE = 0"
proj = tox_project({"tox.ini": ini})
(proj.path / "r.txt").write_text("d")
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
args = ["--pre", "--force-dep", "p<1", "--force-dep", "b>2", "--sitepackages", "--alwayscopy"]
result = proj.run("le", "-e", "py", *args)
result.assert_success()
calls = [(i[0][0].conf.name, i[0][3].run_id, i[0][3].cmd[5:]) for i in execute_calls.call_args_list]
assert calls[0] == ("py", "install_deps", ["c", "p<1", "-r", "r.txt", "b>2"])
for call in execute_calls.call_args_list:
if call[0][0].name == "py":
assert call[0][3].env["PIP_PRE"] == "1"
assert len(virtualenv_session.call_args_list) == 1
v_env = virtualenv_session.call_args_list[0][1]["env"]
assert v_env["VIRTUALENV_SYSTEM_SITE_PACKAGES"] == "True"
assert v_env["VIRTUALENV_COPIES"] == "True"
tox-4.13.0/tests/session/cmd/test_list_envs.py 0000664 0000000 0000000 00000005227 14564001166 0021431 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
import pytest
if TYPE_CHECKING:
from tox.pytest import ToxProject, ToxProjectCreator
@pytest.fixture()
def project(tox_project: ToxProjectCreator) -> ToxProject:
ini = """
[tox]
env_list=py32,py31,py
[testenv]
package = wheel
wheel_build_env = pkg
description = with {basepython}
deps = pypy:
[testenv:py]
basepython=py32,py31
[testenv:fix]
description = fix it
[testenv:pkg]
"""
return tox_project({"tox.ini": ini})
def test_list_env(project: ToxProject) -> None:
outcome = project.run("l")
outcome.assert_success()
expected = """
default environments:
py32 -> with py32
py31 -> with py31
py -> with py32 py31
additional environments:
fix -> fix it
pypy -> with pypy
"""
outcome.assert_out_err(expected, "")
def test_list_env_default(project: ToxProject) -> None:
outcome = project.run("l", "-d")
outcome.assert_success()
expected = """
default environments:
py32 -> with py32
py31 -> with py31
py -> with py32 py31
"""
outcome.assert_out_err(expected, "")
def test_list_env_quiet(project: ToxProject) -> None:
outcome = project.run("l", "--no-desc")
outcome.assert_success()
expected = """
py32
py31
py
fix
pypy
"""
outcome.assert_out_err(expected, "")
def test_list_env_quiet_default(project: ToxProject) -> None:
outcome = project.run("l", "--no-desc", "-d")
outcome.assert_success()
expected = """
py32
py31
py
"""
outcome.assert_out_err(expected, "")
def test_list_env_package_env_before_run(tox_project: ToxProjectCreator) -> None:
ini = """
[testenv:pkg]
[testenv:run]
package = wheel
wheel_build_env = pkg
"""
project = tox_project({"tox.ini": ini})
outcome = project.run("l")
outcome.assert_success()
expected = """
default environments:
py -> [no description]
additional environments:
run -> [no description]
"""
outcome.assert_out_err(expected, "")
def test_list_env_package_self(tox_project: ToxProjectCreator) -> None:
ini = """
[tox]
env_list = pkg
[testenv:pkg]
package = wheel
wheel_build_env = pkg
"""
project = tox_project({"tox.ini": ini})
outcome = project.run("l")
outcome.assert_failed()
assert outcome.out.splitlines() == ["ROOT: HandledError| pkg cannot self-package"]
def test_list_envs_help(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("l", "-h")
outcome.assert_success()
tox-4.13.0/tests/session/cmd/test_parallel.py 0000664 0000000 0000000 00000015075 14564001166 0021221 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from argparse import ArgumentTypeError
from signal import SIGINT
from subprocess import PIPE, Popen
from time import sleep
from typing import TYPE_CHECKING
from unittest import mock
import pytest
from tox.session.cmd.run import parallel
from tox.session.cmd.run.parallel import parse_num_processes
from tox.tox_env.api import ToxEnv
from tox.tox_env.errors import Fail
if TYPE_CHECKING:
from pathlib import Path
from pytest_mock import MockerFixture
from tox.pytest import MonkeyPatch, ToxProjectCreator
def test_parse_num_processes_all() -> None:
assert parse_num_processes("all") is None
def test_parse_num_processes_auto() -> None:
auto = parse_num_processes("auto")
assert isinstance(auto, int)
assert auto > 0
def test_parse_num_processes_exact() -> None:
assert parse_num_processes("3") == 3
def test_parse_num_processes_not_number() -> None:
with pytest.raises(ArgumentTypeError, match="value must be a positive number"):
parse_num_processes("3df")
def test_parse_num_processes_minus_one() -> None:
with pytest.raises(ArgumentTypeError, match="value must be positive"):
parse_num_processes("-1")
def test_parallel_general(tox_project: ToxProjectCreator, monkeypatch: MonkeyPatch, mocker: MockerFixture) -> None:
def setup(self: ToxEnv) -> None:
if self.name == "f":
msg = "something bad happened"
raise Fail(msg)
return prev_setup(self)
prev_setup = ToxEnv._setup_env # noqa: SLF001
mocker.patch.object(ToxEnv, "_setup_env", autospec=True, side_effect=setup)
monkeypatch.setenv("PATH", "")
ini = """
[tox]
no_package=true
skip_missing_interpreters = true
env_list= a, b, c, d, e, f
[testenv]
commands=python -c 'print("run {env_name}")'
depends = !c: c
parallel_show_output = c: true
[testenv:d]
base_python = missing_skip
[testenv:e]
commands=python -c 'import sys; print("run {env_name}"); sys.exit(1)'
"""
project = tox_project({"tox.ini": ini})
outcome = project.run("p", "-p", "all")
outcome.assert_failed()
out = outcome.out
oks, skips, fails = {"a", "b", "c"}, {"d"}, {"e", "f"}
missing = set()
for env in "a", "b", "c", "d", "e", "f":
if env in {"c", "e"}:
assert "run c" in out, out
elif env == "f":
assert "f: failed with something bad happened" in out, out
else:
assert f"run {env}" not in out, out
of_type = "OK" if env in oks else ("SKIP" if env in skips else "FAIL")
of_type_icon = "✔" if env in oks else ("⚠" if env in skips else "✖")
env_done = f"{env}: {of_type} {of_type_icon}"
is_missing = env_done not in out
if is_missing:
missing.add(env_done)
env_report = f" {env}: {of_type} {'code 1 ' if env in fails else ''}("
assert env_report in out, out
if not is_missing:
assert out.index(env_done) < out.index(env_report), out
assert len(missing) == 1, out
def test_parallel_run_live_out(tox_project: ToxProjectCreator) -> None:
ini = """
[tox]
no_package=true
env_list= a, b
[testenv]
commands=python -c 'print("run {env_name}")'
"""
project = tox_project({"tox.ini": ini})
outcome = project.run("p", "-p", "2", "--parallel-live")
outcome.assert_success()
assert "python -c" in outcome.out
assert "run a" in outcome.out
assert "run b" in outcome.out
def test_parallel_show_output_with_pkg(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
ini = "[testenv]\nparallel_show_output=True\ncommands=python -c 'print(\"r {env_name}\")'"
project = tox_project({"tox.ini": ini})
result = project.run("p", "--root", str(demo_pkg_inline))
assert "r py" in result.out
@pytest.mark.skipif(sys.platform == "win32", reason="You need a conhost shell for keyboard interrupt")
@pytest.mark.flaky(max_runs=3, min_passes=1)
def test_keyboard_interrupt(tox_project: ToxProjectCreator, demo_pkg_inline: Path, tmp_path: Path) -> None:
marker = tmp_path / "a"
ini = f"""
[testenv]
package=wheel
commands=python -c 'from time import sleep; from pathlib import Path; \
p = Path("{marker!s}"); p.write_text(""); sleep(100)'
[testenv:dep]
depends=py
"""
proj = tox_project(
{
"tox.ini": ini,
"pyproject.toml": (demo_pkg_inline / "pyproject.toml").read_text(),
"build.py": (demo_pkg_inline / "build.py").read_text(),
},
)
cmd = ["-c", str(proj.path / "tox.ini"), "p", "-p", "1", "-e", f"py,py{sys.version_info[0]},dep"]
process = Popen([sys.executable, "-m", "tox", *cmd], stdout=PIPE, stderr=PIPE, universal_newlines=True)
while not marker.exists() and (process.poll() is None):
sleep(0.05)
process.send_signal(SIGINT)
out, err = process.communicate()
assert process.returncode != 0
assert "KeyboardInterrupt" in err, err
assert "KeyboardInterrupt - teardown started\n" in out, out
assert "interrupt tox environment: py\n" in out, out
assert "requested interrupt of" in out, out
assert "send signal SIGINT" in out, out
assert "interrupt finished with success" in out, out
assert "interrupt tox environment: .pkg" in out, out
def test_parallels_help(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("p", "-h")
outcome.assert_success()
def test_parallel_legacy_accepts_no_arg(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("-p", "-h")
outcome.assert_success()
def test_parallel_requires_arg(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("p", "-p", "-h")
outcome.assert_failed()
assert "argument -p/--parallel: expected one argument" in outcome.err
def test_parallel_no_spinner(tox_project: ToxProjectCreator) -> None:
"""Ensure passing `--parallel-no-spinner` implies `--parallel`."""
with mock.patch.object(parallel, "execute") as mocked:
tox_project({"tox.ini": ""}).run("p", "--parallel-no-spinner")
mocked.assert_called_once_with(
mock.ANY,
max_workers=None,
has_spinner=False,
live=False,
)
def test_parallel_no_spinner_legacy(tox_project: ToxProjectCreator) -> None:
with mock.patch.object(parallel, "execute") as mocked:
tox_project({"tox.ini": ""}).run("--parallel-no-spinner")
mocked.assert_called_once_with(
mock.ANY,
max_workers=None,
has_spinner=False,
live=False,
)
tox-4.13.0/tests/session/cmd/test_quickstart.py 0000664 0000000 0000000 00000003235 14564001166 0021612 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from textwrap import dedent
from typing import TYPE_CHECKING
from packaging.version import Version
from tox.version import version as __version__
if TYPE_CHECKING:
from tox.pytest import ToxProjectCreator
def test_quickstart_ok(tox_project: ToxProjectCreator) -> None:
project = tox_project({})
tox_ini = project.path / "demo" / "tox.ini"
assert not tox_ini.exists()
outcome = project.run("q", str(tox_ini.parent))
outcome.assert_success()
assert tox_ini.exists()
found = tox_ini.read_text()
version = str(Version(__version__.split("+")[0]))
text = f"""
[tox]
env_list =
py{''.join(str(i) for i in sys.version_info[0:2])}
minversion = {version}
[testenv]
description = run the tests with pytest
package = wheel
wheel_build_env = .pkg
deps =
pytest>=6
commands =
pytest {{tty:--color=yes}} {{posargs}}
"""
content = dedent(text).lstrip()
assert found == content
def test_quickstart_refuse(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": ""})
outcome = project.run("q", str(project.path))
outcome.assert_failed(code=1)
assert "tox.ini already exist, refusing to overwrite" in outcome.out
def test_quickstart_help(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("q", "-h")
outcome.assert_success()
def test_quickstart_no_args(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({}).run("q")
outcome.assert_success()
tox-4.13.0/tests/session/cmd/test_sequential.py 0000664 0000000 0000000 00000044663 14564001166 0021604 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import json
import os
import re
import sys
from pathlib import Path
from typing import TYPE_CHECKING, Any
import pytest
from re_assert import Matches
from virtualenv.discovery.py_info import PythonInfo
from tox import __version__
from tox.tox_env.api import ToxEnv
from tox.tox_env.info import Info
if TYPE_CHECKING:
from tox.pytest import ToxProjectCreator
@pytest.mark.parametrize("prefix", ["-", "- "])
def test_run_ignore_cmd_exit_code(tox_project: ToxProjectCreator, prefix: str) -> None:
cmd = [
f"{prefix}python -c 'import sys; print(\"magic fail\", file=sys.stderr); sys.exit(1)'",
"python -c 'import sys; print(\"magic pass\", file=sys.stdout); sys.exit(0)'",
]
project = tox_project({"tox.ini": f"[tox]\nno_package=true\n[testenv]\ncommands={cmd[0]}\n {cmd[1]}"})
outcome = project.run("r", "-e", "py")
outcome.assert_success()
assert "magic pass" in outcome.out
assert "magic fail" in outcome.err
def test_run_sequential_fail(tox_project: ToxProjectCreator) -> None:
def _cmd(value: int) -> str:
return f"python -c 'import sys; print(\"exit {value}\"); sys.exit({value})'"
ini = f"[tox]\nenv_list=a,b\nno_package=true\n[testenv:a]\ncommands={_cmd(1)}\n[testenv:b]\ncommands={_cmd(0)}"
project = tox_project({"tox.ini": ini})
outcome = project.run("r", "-e", "a,b")
outcome.assert_failed()
reports = outcome.out.splitlines()[-3:]
assert Matches(r" evaluation failed :\( \(.* seconds\)") == reports[-1]
assert Matches(r" b: OK \(.*=setup\[.*\]\+cmd\[.*\] seconds\)") == reports[-2]
assert Matches(r" a: FAIL code 1 \(.*=setup\[.*\]\+cmd\[.*\] seconds\)") == reports[-3]
def test_run_sequential_quiet(tox_project: ToxProjectCreator) -> None:
ini = "[tox]\nenv_list=a\nno_package=true\n[testenv]\ncommands=python -V"
project = tox_project({"tox.ini": ini})
outcome = project.run("r", "-q", "-e", "a")
outcome.assert_success()
reports = outcome.out.splitlines()[-3:]
assert Matches(r" congratulations :\) \(.* seconds\)") == reports[-1]
assert Matches(r" a: OK \([\d.]+ seconds\)") == reports[-2]
@pytest.mark.integration()
def test_result_json_sequential(
tox_project: ToxProjectCreator,
enable_pip_pypi_access: str | None, # noqa: ARG001
) -> None:
cmd = [
"- python -c 'import sys; print(\"magic fail\", file=sys.stderr); sys.exit(1)'",
"python -c 'import sys; print(\"magic pass\"); sys.exit(0)'",
]
project = tox_project(
{
"tox.ini": f"[tox]\nenvlist=py\n[testenv]\npackage=wheel\ncommands={cmd[0]}\n {cmd[1]}",
"setup.py": "from setuptools import setup\nsetup(name='a', version='1.0', py_modules=['run'],"
"install_requires=['setuptools>44'])",
"run.py": "print('run')",
"pyproject.toml": '[build-system]\nrequires=["setuptools","wheel"]\nbuild-backend="setuptools.build_meta"',
},
)
log = project.path / "log.json"
outcome = project.run("r", "-vv", "-e", "py", "--result-json", str(log))
outcome.assert_success()
with log.open("rt") as file_handler:
log_report = json.load(file_handler)
py_info = PythonInfo.current_system()
host_python = {
"executable": str(Path(py_info.system_executable).resolve()),
"extra_version_info": None,
"implementation": py_info.implementation,
"is_64": py_info.architecture == 64,
"sysplatform": py_info.platform,
"version": py_info.version,
"version_info": list(py_info.version_info),
}
packaging_setup = get_cmd_exit_run_id(log_report, ".pkg", "setup")
assert "result" not in log_report["testenvs"][".pkg"]
assert packaging_setup[-1][0] in {0, None}
assert packaging_setup[-1][1] == "_exit"
assert packaging_setup[:-1] == [
(0, "install_requires"),
(None, "_optional_hooks"),
(None, "get_requires_for_build_wheel"),
(0, "install_requires_for_build_wheel"),
(0, "freeze"),
]
packaging_test = get_cmd_exit_run_id(log_report, ".pkg", "test")
assert packaging_test == [(None, "build_wheel")]
packaging_installed = log_report["testenvs"][".pkg"].pop("installed_packages")
assert {i[: i.find("==")] for i in packaging_installed} == {"pip", "setuptools", "wheel"}
result_py = log_report["testenvs"]["py"].pop("result")
assert result_py.pop("duration") > 0
assert result_py == {"success": True, "exit_code": 0}
py_setup = get_cmd_exit_run_id(log_report, "py", "setup")
assert py_setup == [(0, "install_package_deps"), (0, "install_package"), (0, "freeze")]
py_test = get_cmd_exit_run_id(log_report, "py", "test")
assert py_test == [(1, "commands[0]"), (0, "commands[1]")]
packaging_installed = log_report["testenvs"]["py"].pop("installed_packages")
expected_pkg = {"pip", "setuptools", "wheel", "a"}
assert {i[: i.find("==")] if "@" not in i else "a" for i in packaging_installed} == expected_pkg
install_package = log_report["testenvs"]["py"].pop("installpkg")
assert re.match("^[a-fA-F0-9]{64}$", install_package.pop("sha256"))
assert install_package == {"basename": "a-1.0-py3-none-any.whl", "type": "file"}
expected = {
"reportversion": "1",
"toxversion": __version__,
"platform": sys.platform,
"testenvs": {
"py": {"python": host_python},
".pkg": {"python": host_python},
},
}
assert "host" in log_report
assert log_report.pop("host")
assert log_report == expected
def get_cmd_exit_run_id(report: dict[str, Any], name: str, group: str) -> list[tuple[int | None, str]]:
return [(i["retcode"], i["run_id"]) for i in report["testenvs"][name].pop(group)]
def test_rerun_sequential_skip(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
proj = tox_project({"tox.ini": "[testenv]\npackage=skip\ncommands=python -c 'print(1)'"})
result_first = proj.run("--root", str(demo_pkg_inline))
result_first.assert_success()
result_rerun = proj.run("--root", str(demo_pkg_inline))
result_rerun.assert_success()
def test_rerun_sequential_wheel(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
proj = tox_project(
{"tox.ini": "[testenv]\npackage=wheel\ncommands=python -c 'from demo_pkg_inline import do; do()'"},
)
result_first = proj.run("--root", str(demo_pkg_inline))
result_first.assert_success()
result_rerun = proj.run("--root", str(demo_pkg_inline))
result_rerun.assert_success()
@pytest.mark.integration()
def test_rerun_sequential_sdist(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
proj = tox_project(
{"tox.ini": "[testenv]\npackage=sdist\ncommands=python -c 'from demo_pkg_inline import do; do()'"},
)
result_first = proj.run("--root", str(demo_pkg_inline))
result_first.assert_success()
result_rerun = proj.run("--root", str(demo_pkg_inline))
result_rerun.assert_success()
def test_recreate_package(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
proj = tox_project(
{"tox.ini": "[testenv]\npackage=wheel\ncommands=python -c 'from demo_pkg_inline import do; do()'"},
)
result_first = proj.run("--root", str(demo_pkg_inline), "-r")
result_first.assert_success()
result_rerun = proj.run("-r", "--root", str(demo_pkg_inline), "--no-recreate-pkg")
result_rerun.assert_success()
def test_package_deps_change(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
toml = (demo_pkg_inline / "pyproject.toml").read_text()
build = (demo_pkg_inline / "build.py").read_text()
proj = tox_project({"tox.ini": "[testenv]\npackage=wheel", "pyproject.toml": toml, "build.py": build})
proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result_first = proj.run("r")
result_first.assert_success()
assert ".pkg: install" not in result_first.out # no deps initially
# new deps are picked up
(proj.path / "pyproject.toml").write_text(toml.replace("requires = [\n]", 'requires = ["wheel"]'))
(proj.path / "build.py").write_text(build.replace("return []", "return ['setuptools']"))
result_rerun = proj.run("r")
result_rerun.assert_success()
# and installed
rerun_install = [i for i in result_rerun.out.splitlines() if i.startswith(".pkg: install")]
assert len(rerun_install) == 2
assert rerun_install[0].endswith("wheel")
assert rerun_install[1].endswith("setuptools")
def test_package_build_fails(tox_project: ToxProjectCreator) -> None:
proj = tox_project(
{
"tox.ini": "[testenv]\npackage=wheel",
"pyproject.toml": '[build-system]\nrequires=[]\nbuild-backend="build"\nbackend-path=["."]',
"build.py": "",
},
)
result = proj.run("r")
result.assert_failed(code=1)
assert "has no attribute 'build_wheel'" in result.out, result.out
def test_backend_not_found(tox_project: ToxProjectCreator) -> None:
proj = tox_project(
{
"tox.ini": "[testenv]\npackage=wheel",
"pyproject.toml": '[build-system]\nrequires=[]\nbuild-backend="build"',
"build.py": "",
},
)
result = proj.run("r")
result.assert_failed(code=-5)
assert "packaging backend failed (code=-5), with FailedToStart: could not start backend" in result.out, result.out
def test_missing_interpreter_skip_on(tox_project: ToxProjectCreator) -> None:
ini = "[tox]\nskip_missing_interpreters=true\n[testenv]\npackage=skip\nbase_python=missing-interpreter"
proj = tox_project({"tox.ini": ini})
result = proj.run("r")
result.assert_failed()
assert "py: SKIP" in result.out
def test_missing_interpreter_skip_off(tox_project: ToxProjectCreator) -> None:
ini = "[tox]\nskip_missing_interpreters=false\n[testenv]\npackage=skip\nbase_python=missing-interpreter"
proj = tox_project({"tox.ini": ini})
result = proj.run("r")
result.assert_failed()
exp = "py: failed with could not find python interpreter matching any of the specs missing-interpreter"
assert exp in result.out
def test_env_tmp_dir_reset(tox_project: ToxProjectCreator) -> None:
ini = '[testenv]\npackage=skip\ncommands=python -c \'import os; os.mkdir(os.path.join( r"{env_tmp_dir}", "a"))\''
proj = tox_project({"tox.ini": ini})
result_first = proj.run("r")
result_first.assert_success()
result_second = proj.run("r", "-v", "-v")
result_second.assert_success()
assert "D clear env temp folder " in result_second.out, result_second.out
def test_env_name_change_recreate(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv]\npackage=skip\ncommands=\n"})
result_first = proj.run("r")
result_first.assert_success()
tox_env = result_first.state.envs["py"]
assert repr(tox_env) == "VirtualEnvRunner(name=py)"
path = tox_env.env_dir
with Info(path).compare({"name": "p", "type": "magical"}, ToxEnv.__name__):
pass
result_second = proj.run("r")
result_second.assert_success()
output = (
"recreate env because env type changed from {'name': 'p', 'type': 'magical'} "
"to {'name': 'py', 'type': 'VirtualEnvRunner'}"
)
assert output in result_second.out
assert "py: remove tox env folder" in result_second.out
def test_skip_pkg_install(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
proj = tox_project({"tox.ini": "[testenv]\npackage=wheel\n"})
result_first = proj.run("--root", str(demo_pkg_inline), "--skip-pkg-install")
result_first.assert_success()
assert result_first.out.startswith("py: skip building and installing the package"), result_first.out
def test_skip_develop_mode(tox_project: ToxProjectCreator, demo_pkg_setuptools: Path) -> None:
proj = tox_project({"tox.ini": "[testenv]\npackage=wheel\n"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("--root", str(demo_pkg_setuptools), "--develop", "--workdir", str(proj.path / ".tox"))
result.assert_success()
calls = [(i[0][0].conf.name, i[0][3].run_id) for i in execute_calls.call_args_list]
expected = [
(".pkg", "install_requires"),
(".pkg", "_optional_hooks"),
(".pkg", "get_requires_for_build_editable"),
(".pkg", "install_requires_for_build_editable"),
(".pkg", "build_editable"),
("py", "install_package"),
(".pkg", "_exit"),
]
assert calls == expected
def _c(code: int) -> str:
return f"python -c 'raise SystemExit({code})'"
def test_commands_pre_fail_post_runs(tox_project: ToxProjectCreator) -> None:
ini = f"[testenv]\npackage=skip\ncommands_pre={_c(8)}\ncommands={_c(0)}\ncommands_post={_c(9)}"
proj = tox_project({"tox.ini": ini})
result = proj.run()
result.assert_failed(code=8)
assert "commands_pre[0]" in result.out
assert "commands[0]" not in result.out
assert "commands_post[0]" in result.out
def test_commands_pre_pass_post_runs_main_fails(tox_project: ToxProjectCreator) -> None:
ini = f"[testenv]\npackage=skip\ncommands_pre={_c(0)}\ncommands={_c(8)}\ncommands_post={_c(9)}"
proj = tox_project({"tox.ini": ini})
result = proj.run()
result.assert_failed(code=8)
assert "commands_pre[0]" in result.out
assert "commands[0]" in result.out
assert "commands_post[0]" in result.out
def test_commands_post_fails_exit_code(tox_project: ToxProjectCreator) -> None:
ini = f"[testenv]\npackage=skip\ncommands_pre={_c(0)}\ncommands={_c(0)}\ncommands_post={_c(9)}"
proj = tox_project({"tox.ini": ini})
result = proj.run()
result.assert_failed(code=9)
assert "commands_pre[0]" in result.out
assert "commands[0]" in result.out
assert "commands_post[0]" in result.out
@pytest.mark.parametrize(
("pre", "main", "post", "outcome"),
[
(0, 8, 0, 8),
(0, 0, 8, 8),
(8, 0, 0, 8),
],
)
def test_commands_ignore_errors(tox_project: ToxProjectCreator, pre: int, main: int, post: int, outcome: int) -> None:
def _s(key: str, code: int) -> str:
return f"\ncommands{key}=\n {_c(code)}\n {'' if code == 0 else _c(code + 1)}"
ini = f"[testenv]\npackage=skip\nignore_errors=True{_s('_pre', pre)}{_s('', main)}{_s('_post', post)}"
proj = tox_project({"tox.ini": ini})
result = proj.run()
result.assert_failed(code=outcome)
assert "commands_pre[0]" in result.out
assert "commands[0]" in result.out
assert "commands_post[0]" in result.out
def test_ignore_outcome(tox_project: ToxProjectCreator) -> None:
ini = "[tox]\nno_package=true\n[testenv]\ncommands=python -c 'exit(1)'\nignore_outcome=true"
project = tox_project({"tox.ini": ini})
result = project.run("r")
result.assert_success()
reports = result.out.splitlines()
assert Matches(r" py: IGNORED FAIL code 1 .*") == reports[-2]
assert Matches(r" congratulations :\) .*") == reports[-1]
def test_platform_does_not_match_run_env(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\npackage=skip\nplatform=wrong_platform"
proj = tox_project({"tox.ini": ini})
result = proj.run("r")
result.assert_failed()
exp = f"py: skipped because platform {sys.platform} does not match wrong_platform"
assert exp in result.out
def test_platform_matches_run_env(tox_project: ToxProjectCreator) -> None:
ini = f"[testenv]\npackage=skip\nplatform={sys.platform}"
proj = tox_project({"tox.ini": ini})
result = proj.run("r")
result.assert_success()
def test_platform_does_not_match_package_env(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
toml = (demo_pkg_inline / "pyproject.toml").read_text()
build = (demo_pkg_inline / "build.py").read_text()
ini = "[tox]\nenv_list=a,b\n[testenv]\npackage=wheel\n[testenv:.pkg]\nplatform=wrong_platform"
proj = tox_project({"tox.ini": ini, "pyproject.toml": toml, "build.py": build})
result = proj.run("r", "-e", "a,b")
result.assert_failed() # tox run fails as all envs are skipped
assert "a: SKIP" in result.out
assert "b: SKIP" in result.out
msg = f"skipped because platform {sys.platform} does not match wrong_platform for package environment .pkg"
assert f"a: {msg}" in result.out
assert f"b: {msg}" in result.out
def test_sequential_run_all(tox_project: ToxProjectCreator) -> None:
ini = "[tox]\nenv_list=a\n[testenv]\npackage=skip\n[testenv:b]"
outcome = tox_project({"tox.ini": ini}).run("r", "-e", "ALL")
assert "a: OK" in outcome.out
assert "b: OK" in outcome.out
def test_virtualenv_cache(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\npackage=skip"
proj = tox_project({"tox.ini": ini})
result_first = proj.run("r", "-v", "-v")
result_first.assert_success()
assert " create virtual environment via " in result_first.out
result_second = proj.run("r", "-v", "-v")
result_second.assert_success()
assert " create virtual environment via " not in result_second.out
def test_sequential_help(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("r", "-h")
outcome.assert_success()
def test_sequential_clears_pkg_at_most_once(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
project = tox_project({"tox.ini": "[tox]\nenv_list=a,b"})
result = project.run("r", "--root", str(demo_pkg_inline), "-e", "a,b", "-r")
result.assert_success()
def test_sequential_inserted_env_vars(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
ini = """
[testenv]
commands=python -c 'import os; [print(f"{k}={v}") for k, v in os.environ.items() if \
k.startswith("TOX_") or k == "VIRTUAL_ENV"]'
"""
project = tox_project({"tox.ini": ini})
result = project.run("r", "--root", str(demo_pkg_inline), "--workdir", str(project.path / ".tox"))
result.assert_success()
assert re.search(f"TOX_PACKAGE={re.escape(str(project.path))}.*.tar.gz{os.linesep}", result.out)
assert f"TOX_ENV_NAME=py{os.linesep}" in result.out
work_dir = project.path / ".tox"
assert f"TOX_WORK_DIR={work_dir}{os.linesep}" in result.out
env_dir = work_dir / "py"
assert f"TOX_ENV_DIR={env_dir}{os.linesep}" in result.out
assert f"VIRTUAL_ENV={env_dir}{os.linesep}" in result.out
def test_missing_command_success_if_ignored(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv]\ncommands= - missing-command\nskip_install=true"})
result = project.run()
result.assert_success()
assert "py: command failed but is marked ignore outcome so handling it as success" in result.out
tox-4.13.0/tests/session/cmd/test_show_config.py 0000664 0000000 0000000 00000026200 14564001166 0021722 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import platform
import sys
from configparser import ConfigParser
from textwrap import dedent
from typing import TYPE_CHECKING, Callable
import pytest
from tox.config.types import Command
if TYPE_CHECKING:
from pathlib import Path
from pytest_mock import MockerFixture
from tox.pytest import MonkeyPatch, ToxProjectCreator
def test_show_config_default_run_env(tox_project: ToxProjectCreator, monkeypatch: MonkeyPatch) -> None:
py_ver = sys.version_info[0:2]
name = f"py{py_ver[0]}{py_ver[1]}" if platform.python_implementation() == "CPython" else "pypy3"
project = tox_project({"tox.ini": f"[tox]\nenv_list = {name}\n[testenv:{name}]\ncommands={{posargs}}"})
result = project.run("c", "-e", name, "--core", "--", "magic")
state = result.state
assert state.args == ("c", "-e", name, "--core", "--", "magic")
outcome = list(state.envs.iter(only_active=False))
assert outcome == [name]
monkeypatch.delenv("TERM", raising=False) # disable conditionally set flag
parser = ConfigParser(interpolation=None)
parser.read_string(result.out)
assert list(parser.sections()) == [f"testenv:{name}", "tox"]
def test_show_config_commands(tox_project: ToxProjectCreator) -> None:
project = tox_project(
{
"tox.ini": """
[tox]
env_list = py
no_package = true
[testenv]
commands_pre =
python -c 'import sys; print("start", sys.executable)'
commands =
pip config list
pip list
commands_post =
python -c 'import sys; print("end", sys.executable)'
""",
},
)
outcome = project.run("c")
outcome.assert_success()
env_config = outcome.env_conf("py")
assert env_config["commands_pre"] == [Command(args=["python", "-c", 'import sys; print("start", sys.executable)'])]
assert env_config["commands"] == [
Command(args=["pip", "config", "list"]),
Command(args=["pip", "list"]),
]
assert env_config["commands_post"] == [Command(args=["python", "-c", 'import sys; print("end", sys.executable)'])]
def test_show_config_filter_keys(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv]\nmagic=yes"})
outcome = project.run("c", "-e", "py", "-k", "no_package", "env_name", "--core")
outcome.assert_success()
outcome.assert_out_err("[testenv:py]\nenv_name = py\n\n[tox]\nno_package = False\n", "")
def test_show_config_unused(tox_project: ToxProjectCreator) -> None:
tox_ini = "[testenv]\nok=false\n[testenv:py]\nmagical=yes\nmagic=yes"
outcome = tox_project({"tox.ini": tox_ini}).run("c", "-e", "py")
outcome.assert_success()
assert "\n# !!! unused: magic, magical\n" in outcome.out
def test_show_config_py_ver_impl_constants(tox_project: ToxProjectCreator) -> None:
tox_ini = "[testenv]\npackage=skip\ndeps= {py_impl}{py_dot_ver}"
outcome = tox_project({"tox.ini": tox_ini}).run("c", "-e", "py", "-k", "py_dot_ver", "py_impl", "deps")
outcome.assert_success()
py_ver = ".".join(str(i) for i in sys.version_info[0:2])
impl = sys.implementation.name
assert outcome.out == f"[testenv:py]\npy_dot_ver = {py_ver}\npy_impl = {impl}\ndeps = {impl}{py_ver}\n"
def test_show_config_exception(tox_project: ToxProjectCreator) -> None:
project = tox_project(
{
"tox.ini": """
[testenv:a]
base_python = missing-python
""",
},
)
outcome = project.run("c", "-e", "a", "-k", "env_site_packages_dir")
outcome.assert_success()
txt = (
"\nenv_site_packages_dir = # Exception: "
"RuntimeError(\"failed to find interpreter for Builtin discover of python_spec='missing-python'"
)
assert txt in outcome.out
def test_show_config_empty_install_command_exception(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv:a]\ninstall_command="})
outcome = project.run("c", "-e", "a", "-k", "install_command")
outcome.assert_success()
txt = "\ninstall_command = # Exception: ValueError(\"attempting to parse '' into a command failed\")"
assert txt in outcome.out
@pytest.mark.parametrize("stdout_is_atty", [True, False])
def test_pass_env_config_default(tox_project: ToxProjectCreator, stdout_is_atty: bool, mocker: MockerFixture) -> None:
mocker.patch("sys.stdout.isatty", return_value=stdout_is_atty)
project = tox_project({"tox.ini": ""})
outcome = project.run("c", "-e", "py", "-k", "pass_env")
pass_env = outcome.env_conf("py")["pass_env"]
is_win = sys.platform == "win32"
expected = (
[]
+ (["APPDATA"] if is_win else [])
+ ["CC", "CCSHARED", "CFLAGS"]
+ (["COMSPEC"] if is_win else [])
+ ["CPPFLAGS", "CURL_CA_BUNDLE", "CXX", "FORCE_COLOR", "HOME", "LANG"]
+ ["LANGUAGE", "LDFLAGS", "LD_LIBRARY_PATH"]
+ (["MSYSTEM"] if is_win else [])
+ ["NO_COLOR"]
+ (["NUMBER_OF_PROCESSORS", "PATHEXT"] if is_win else [])
+ ["PIP_*", "PKG_CONFIG", "PKG_CONFIG_PATH", "PKG_CONFIG_SYSROOT_DIR"]
+ (["PROCESSOR_ARCHITECTURE"] if is_win else [])
+ (["PROGRAMDATA"] if is_win else [])
+ (["PROGRAMFILES"] if is_win else [])
+ (["PROGRAMFILES(x86)"] if is_win else [])
+ ["REQUESTS_CA_BUNDLE", "SSL_CERT_FILE"]
+ (["SYSTEMDRIVE", "SYSTEMROOT", "TEMP"] if is_win else [])
+ (["TERM"] if stdout_is_atty else [])
+ (["TMP", "USERPROFILE"] if is_win else ["TMPDIR"])
+ ["VIRTUALENV_*", "http_proxy", "https_proxy", "no_proxy"]
)
assert pass_env == expected
def test_show_config_pkg_env_once(
tox_project: ToxProjectCreator,
patch_prev_py: Callable[[bool], tuple[str, str]],
) -> None:
prev_ver, impl = patch_prev_py(True)
ini = f"[tox]\nenv_list=py{prev_ver},py\n[testenv]\npackage=wheel"
project = tox_project({"tox.ini": ini, "pyproject.toml": ""})
result = project.run("c", "-e", "ALL")
result.assert_success()
parser = ConfigParser(interpolation=None)
parser.read_string(result.out)
sections = set(parser.sections())
assert sections == {"testenv:.pkg", f"testenv:.pkg-{impl}{prev_ver}", f"testenv:py{prev_ver}", "testenv:py", "tox"}
def test_show_config_pkg_env_skip(
tox_project: ToxProjectCreator,
patch_prev_py: Callable[[bool], tuple[str, str]],
) -> None:
prev_ver, _impl = patch_prev_py(False)
ini = f"[tox]\nenv_list=py{prev_ver},py\n[testenv]\npackage=wheel"
project = tox_project({"tox.ini": ini, "pyproject.toml": ""})
result = project.run("c", "-e", "ALL")
result.assert_success()
parser = ConfigParser(interpolation=None)
parser.read_string(result.out)
sections = set(parser.sections())
assert sections == {"testenv:.pkg", "tox", "testenv:py", f"testenv:py{prev_ver}"}
def test_show_config_select_only(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[tox]\nenv_list=\n a\n b", "pyproject.toml": ""})
result = project.run("c", "-e", ".pkg,b,.pkg")
result.assert_success()
parser = ConfigParser(interpolation=None)
parser.read_string(result.out)
sections = list(parser.sections())
assert sections == ["testenv:.pkg", "testenv:b"]
def test_show_config_alias(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("c", "-e", "py", "-k", "setenv")
outcome.assert_success()
assert "set_env =" in outcome.out
def test_show_config_description_normalize(tox_project: ToxProjectCreator) -> None:
tox_ini = "[testenv]\ndescription = A magical\t pipe\n of\tthis"
outcome = tox_project({"tox.ini": tox_ini}).run("c", "-e", "py", "-k", "description")
outcome.assert_success()
assert outcome.out == "[testenv:py]\ndescription = A magical pipe of this\n"
def test_show_config_ini_comment_path(tox_project: ToxProjectCreator, tmp_path: Path) -> None:
prj_path = tmp_path / "#magic"
prj_path.mkdir()
ini = """
[testenv]
package = skip
set_env =
A=1 # comment
# more comment
commands = {envpython} -c 'import os; print(os.linesep.join(f"{k}={v}" for k, v in os.environ.items()))'
[testenv:py]
set_env =
{[testenv]set_env}
B = {tox_root} # just some comment
"""
project = tox_project({"tox.ini": dedent(ini)}, prj_path=prj_path)
result = project.run("r", "-e", "py")
result.assert_success()
a_line = next(i for i in result.out.splitlines() if i.startswith("A=")) # pragma: no branch # not found raises
assert a_line == "A=1"
b_line = next(i for i in result.out.splitlines() if i.startswith("B=")) # pragma: no branch # not found raises
assert b_line == f"B={prj_path}"
def test_show_config_cli_flag(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "", "pyproject.toml": ""})
result = project.run("c", "-e", "py,.pkg", "-k", "package", "recreate", "--develop", "-r", "--no-recreate-pkg")
expected = "[testenv:py]\npackage = editable\nrecreate = True\n\n[testenv:.pkg]\nrecreate = False\n"
assert result.out == expected
def test_show_config_timeout_default(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": "[testenv]\npakcage=skip"})
result = project.run("c", "-e", "py", "-k", "suicide_timeout", "interrupt_timeout", "terminate_timeout")
expected = "[testenv:py]\nsuicide_timeout = 0.0\ninterrupt_timeout = 0.3\nterminate_timeout = 0.2\n"
assert result.out == expected
def test_show_config_timeout_custom(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\npakcage=skip\nsuicide_timeout = 1\ninterrupt_timeout = 2.222\nterminate_timeout = 3.0\n"
project = tox_project({"tox.ini": ini})
result = project.run("c", "-e", "py", "-k", "suicide_timeout", "interrupt_timeout", "terminate_timeout")
expected = "[testenv:py]\nsuicide_timeout = 1.0\ninterrupt_timeout = 2.222\nterminate_timeout = 3.0\n"
assert result.out == expected
def test_show_config_help(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("c", "-h")
outcome.assert_success()
def test_show_config_core_host_python(tox_project: ToxProjectCreator) -> None:
project = tox_project({"tox.ini": ""})
outcome = project.run("c", "--core", "-e", "py", "-k", "host_python")
outcome.assert_success()
assert f"host_python = {sys.executable}" in outcome.out
def test_show_config_matching_env_section(tox_project: ToxProjectCreator) -> None:
ini = """
[a]
[testenv:a]
deps = c>=1
[testenv:b]
deps = {[testenv:a]deps}"""
project = tox_project({"tox.ini": ini})
outcome = project.run("c", "-e", "a,b", "-k", "deps")
outcome.assert_success()
assert outcome.out.count("c>=1") == 2, outcome.out
def test_package_env_inherits_from_pkgenv(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
project = tox_project({"tox.ini": "[pkgenv]\npass_env = A, AA\ndeps=C\n D"})
outcome = project.run("c", "--root", str(demo_pkg_inline), "-k", "deps", "pass_env", "-e", "py,.pkg")
outcome.assert_success()
exp = """
[testenv:.pkg]
deps =
C
D
pass_env =
A
AA
"""
exp = dedent(exp)
assert exp in outcome.out
tox-4.13.0/tests/session/cmd/test_state.py 0000664 0000000 0000000 00000001551 14564001166 0020537 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from tox.pytest import ToxProjectCreator
def test_env_already_packaging(tox_project: ToxProjectCreator) -> None:
proj = tox_project(
{
"tox.ini": "[testenv]\npackage=wheel",
"pyproject.toml": '[build-system]\nrequires=[]\nbuild-backend="build"',
},
)
result = proj.run("r", "-e", "py,.pkg")
result.assert_failed(code=-2)
assert "cannot run packaging environment(s) .pkg" in result.out, result.out
def test_env_run_cannot_be_packaging_too(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv]\npackage=wheel\npackage_env=py", "pyproject.toml": ""})
result = proj.run("r", "-e", "py")
result.assert_failed(code=-2)
assert " py cannot self-package" in result.out, result.out
tox-4.13.0/tests/session/test_env_select.py 0000664 0000000 0000000 00000022076 14564001166 0021010 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from typing import TYPE_CHECKING
import pytest
from tox.config.cli.parse import get_options
from tox.session.env_select import _DYNAMIC_ENV_FACTORS, CliEnv, EnvSelector # noqa: PLC2701
from tox.session.state import State
if TYPE_CHECKING:
from tox.pytest import MonkeyPatch, ToxProjectCreator
CURRENT_PY_ENV = f"py{sys.version_info[0]}{sys.version_info[1]}" # e.g. py310
@pytest.mark.parametrize(
("user_input", "env_names", "is_all", "is_default"),
[
(None, (), False, True),
("", (), False, True),
("a1", ("a1",), False, False),
("a1,b2,c3", ("a1", "b2", "c3"), False, False),
(" a1, b2 , c3 ", ("a1", "b2", "c3"), False, False),
# If the user gives "ALL" as any envname, this becomes an "is_all" and other envnames are ignored.
("ALL", (), True, False),
("a1,ALL,b2", (), True, False),
# Zero-length envnames are ignored as being not present. This is not intentional.
(",,a1,,,b2,,", ("a1", "b2"), False, False),
(",,", (), False, True),
# Environment names with "invalid" characters are accepted here; the client is expected to deal with this.
("\x01.-@\x02,xxx", ("\x01.-@\x02", "xxx"), False, False),
],
)
def test_clienv(user_input: str, env_names: tuple[str], is_all: bool, is_default: bool) -> None:
ce = CliEnv(user_input)
assert (ce.is_all, ce.is_default_list, tuple(ce)) == (is_all, is_default, tuple(env_names))
assert ce is not ce.is_default_list
assert CliEnv(user_input) == ce
@pytest.mark.parametrize(
("user_input", "expected"),
[
("", False),
("all", False),
("All", False),
("ALL", True),
("a,ALL,b", True),
],
)
def test_clienv_is_all(user_input: str, expected: bool) -> None:
assert CliEnv(user_input).is_all is expected
def test_env_select_lazily_looks_at_envs() -> None:
state = State(get_options(), [])
env_selector = EnvSelector(state)
# late-assigning env should be reflected in env_selector
state.conf.options.env = CliEnv("py")
assert set(env_selector.iter()) == {"py"}
def test_label_core_can_define(tox_project: ToxProjectCreator) -> None:
ini = """
[tox]
labels =
test = py3{10,9}
static = flake8, type
"""
project = tox_project({"tox.ini": ini})
outcome = project.run("l", "--no-desc")
outcome.assert_success()
outcome.assert_out_err("py\npy310\npy39\nflake8\ntype\n", "")
def test_label_core_select(tox_project: ToxProjectCreator) -> None:
ini = """
[tox]
labels =
test = py3{10,9}
static = flake8, type
"""
project = tox_project({"tox.ini": ini})
outcome = project.run("l", "--no-desc", "-m", "test")
outcome.assert_success()
outcome.assert_out_err("py310\npy39\n", "")
def test_label_select_trait(tox_project: ToxProjectCreator) -> None:
ini = """
[tox]
env_list = py310, py39, flake8, type
[testenv]
labels = test
[testenv:flake8]
labels = static
[testenv:type]
labels = static
"""
project = tox_project({"tox.ini": ini})
outcome = project.run("l", "--no-desc", "-m", "test")
outcome.assert_success()
outcome.assert_out_err("py310\npy39\n", "")
def test_label_core_and_trait(tox_project: ToxProjectCreator) -> None:
ini = """
[tox]
env_list = py310, py39, flake8, type
labels =
static = flake8, type
[testenv]
labels = test
"""
project = tox_project({"tox.ini": ini})
outcome = project.run("l", "--no-desc", "-m", "test", "static")
outcome.assert_success()
outcome.assert_out_err("py310\npy39\nflake8\ntype\n", "")
@pytest.mark.parametrize(
("selection_arguments", "expect_envs"),
[
(
("-f", "cov", "django20"),
("py310-django20-cov", "py39-django20-cov"),
),
(
("-f", "cov-django20"),
("py310-django20-cov", "py39-django20-cov"),
),
(
("-f", "py39", "django20", "-f", "py310", "django21"),
("py310-django21-cov", "py310-django21", "py39-django20-cov", "py39-django20"),
),
],
)
def test_factor_select(
tox_project: ToxProjectCreator,
selection_arguments: tuple[str, ...],
expect_envs: tuple[str, ...],
) -> None:
ini = """
[tox]
env_list = py3{10,9}-{django20,django21}{-cov,}
"""
project = tox_project({"tox.ini": ini})
outcome = project.run("l", "--no-desc", *selection_arguments)
outcome.assert_success()
outcome.assert_out_err("{}\n".format("\n".join(expect_envs)), "")
def test_tox_skip_env(tox_project: ToxProjectCreator, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setenv("TOX_SKIP_ENV", "m[y]py")
project = tox_project({"tox.ini": "[tox]\nenv_list = py3{10,9},mypy"})
outcome = project.run("l", "--no-desc", "-q")
outcome.assert_success()
outcome.assert_out_err("py310\npy39\n", "")
def test_tox_skip_env_cli(tox_project: ToxProjectCreator, monkeypatch: MonkeyPatch) -> None:
monkeypatch.delenv("TOX_SKIP_ENV", raising=False)
project = tox_project({"tox.ini": "[tox]\nenv_list = py3{10,9},mypy"})
outcome = project.run("l", "--no-desc", "-q", "--skip-env", "m[y]py")
outcome.assert_success()
outcome.assert_out_err("py310\npy39\n", "")
def test_tox_skip_env_logs(tox_project: ToxProjectCreator, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setenv("TOX_SKIP_ENV", "m[y]py")
project = tox_project({"tox.ini": "[tox]\nenv_list = py3{10,9},mypy"})
outcome = project.run("l", "--no-desc")
outcome.assert_success()
outcome.assert_out_err("ROOT: skip environment mypy, matches filter 'm[y]py'\npy310\npy39\n", "")
def test_cli_env_can_be_specified_in_default(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[tox]\nenv_list=exists"})
outcome = proj.run("r", "-e", "exists")
outcome.assert_success()
assert "exists" in outcome.out
assert not outcome.err
def test_cli_env_can_be_specified_in_additional_environments(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv:exists]"})
outcome = proj.run("r", "-e", "exists")
outcome.assert_success()
assert "exists" in outcome.out
assert not outcome.err
@pytest.mark.parametrize("env_name", ["py", CURRENT_PY_ENV, ".pkg"])
def test_allowed_implicit_cli_envs(env_name: str, tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": ""})
outcome = proj.run("r", "-e", env_name)
outcome.assert_success()
assert env_name in outcome.out
assert not outcome.err
@pytest.mark.parametrize("env_name", ["a", "b", "a-b", "b-a"])
def test_matches_hyphenated_env(env_name: str, tox_project: ToxProjectCreator) -> None:
tox_ini = """
[tox]
env_list=a-b
[testenv]
package=skip
commands_pre =
a: python -c 'print("a")'
b: python -c 'print("b")'
commands=python -c 'print("ok")'
"""
proj = tox_project({"tox.ini": tox_ini})
outcome = proj.run("r", "-e", env_name)
outcome.assert_success()
assert env_name in outcome.out
assert not outcome.err
_MINOR = sys.version_info.minor
@pytest.mark.parametrize(
"env_name",
[
f"3.{_MINOR}",
f"3.{_MINOR}-cov",
"3-cov",
"3",
f"py3.{_MINOR}",
f"py3{_MINOR}-cov",
f"py3.{_MINOR}-cov",
],
)
def test_matches_combined_env(env_name: str, tox_project: ToxProjectCreator) -> None:
tox_ini = """
[testenv]
package=skip
commands =
!cov: python -c 'print("without cov")'
cov: python -c 'print("with cov")'
"""
proj = tox_project({"tox.ini": tox_ini})
outcome = proj.run("r", "-e", env_name)
outcome.assert_success()
assert env_name in outcome.out
assert not outcome.err
@pytest.mark.parametrize(
"env",
[
"py",
"pypy",
"pypy3",
"pypy3.12",
"pypy312",
"py3",
"py3.12",
"py312",
"3",
"3.12",
"3.12.0",
],
)
def test_dynamic_env_factors_match(env: str) -> None:
assert _DYNAMIC_ENV_FACTORS.fullmatch(env)
@pytest.mark.parametrize(
"env",
[
"cy3",
"cov",
"py10.1",
],
)
def test_dynamic_env_factors_not_match(env: str) -> None:
assert not _DYNAMIC_ENV_FACTORS.fullmatch(env)
def test_suggest_env(tox_project: ToxProjectCreator) -> None:
tox_ini = f"[testenv:release]\n[testenv:py3{_MINOR}]\n[testenv:alpha-py3{_MINOR}]\n"
proj = tox_project({"tox.ini": tox_ini})
outcome = proj.run("r", "-e", f"releas,p3{_MINOR},magic,alph-p{_MINOR}")
outcome.assert_failed(code=-2)
assert not outcome.err
msg = (
"ROOT: HandledError| provided environments not found in configuration file:\n"
f"releas - did you mean release?\np3{_MINOR} - did you mean py3{_MINOR}?\nmagic\n"
f"alph-p{_MINOR} - did you mean alpha-py3{_MINOR}?\n"
)
assert outcome.out == msg
tox-4.13.0/tests/session/test_session_common.py 0000664 0000000 0000000 00000001261 14564001166 0021705 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import pytest
from tox.session.env_select import CliEnv
@pytest.mark.parametrize(
("val", "exp"),
[
(CliEnv(["a", "b"]), "CliEnv('a,b')"),
(CliEnv(["ALL", "b"]), "CliEnv('ALL')"),
(CliEnv([]), "CliEnv()"),
(CliEnv(), "CliEnv()"),
],
)
def test_cli_env_repr(val: CliEnv, exp: str) -> None:
assert repr(val) == exp
@pytest.mark.parametrize(
("val", "exp"),
[
(CliEnv(["a", "b"]), "a,b"),
(CliEnv(["ALL", "b"]), "ALL"),
(CliEnv([]), ""),
(CliEnv(), ""),
],
)
def test_cli_env_str(val: CliEnv, exp: str) -> None:
assert str(val) == exp
tox-4.13.0/tests/test_call_modes.py 0000664 0000000 0000000 00000000734 14564001166 0017275 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import subprocess
import sys
from pathlib import Path
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from tox.pytest import ToxProject
def test_call_as_module(empty_project: ToxProject) -> None: # noqa: ARG001
subprocess.check_output([sys.executable, "-m", "tox", "-h"])
def test_call_as_exe(empty_project: ToxProject) -> None: # noqa: ARG001
subprocess.check_output([str(Path(sys.executable).parent / "tox"), "-h"])
tox-4.13.0/tests/test_provision.py 0000664 0000000 0000000 00000022732 14564001166 0017225 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import json
import os
import sys
import time
from contextlib import contextmanager
from pathlib import Path
from subprocess import check_call
from typing import TYPE_CHECKING, Callable, Iterator
from unittest import mock
from zipfile import ZipFile
import pytest
from filelock import FileLock
from packaging.requirements import Requirement
if TYPE_CHECKING:
from devpi_process import Index, IndexServer
from tox.pytest import MonkeyPatch, TempPathFactory, ToxProjectCreator
from importlib.metadata import Distribution
ROOT = Path(__file__).parents[1]
@contextmanager
def elapsed(msg: str) -> Iterator[None]:
start = time.monotonic()
try:
yield
finally:
print(f"done in {time.monotonic() - start}s {msg}") # noqa: T201
@pytest.fixture(scope="session")
def tox_wheel(
tmp_path_factory: TempPathFactory,
worker_id: str,
pkg_builder: Callable[[Path, Path, list[str], bool], Path],
) -> Path:
if worker_id == "master": # if not running under xdist we can just return
return _make_tox_wheel(tmp_path_factory, pkg_builder) # pragma: no cover
# otherwise we need to ensure only one worker creates the wheel, and the rest reuses
root_tmp_dir = tmp_path_factory.getbasetemp().parent
cache_file = root_tmp_dir / "tox_wheel.json"
with FileLock(f"{cache_file}.lock"):
if cache_file.is_file():
data = Path(json.loads(cache_file.read_text())) # pragma: no cover
else:
data = _make_tox_wheel(tmp_path_factory, pkg_builder)
cache_file.write_text(json.dumps(str(data)))
return data
def _make_tox_wheel(
tmp_path_factory: TempPathFactory,
pkg_builder: Callable[[Path, Path, list[str], bool], Path],
) -> Path:
with elapsed("acquire current tox wheel"): # takes around 3.2s on build
into = tmp_path_factory.mktemp("dist") # pragma: no cover
from tox.version import version_tuple # noqa: PLC0415
version = f"{version_tuple[0]}.{version_tuple[1]}.{int(version_tuple[2]) + 1}"
with mock.patch.dict(os.environ, {"SETUPTOOLS_SCM_PRETEND_VERSION": version}):
return pkg_builder(into, Path(__file__).parents[1], ["wheel"], False) # pragma: no cover
@pytest.fixture(scope="session")
def tox_wheels(tox_wheel: Path, tmp_path_factory: TempPathFactory) -> list[Path]:
with elapsed("acquire dependencies for current tox"): # takes around 1.5s if already cached
result: list[Path] = [tox_wheel]
info = tmp_path_factory.mktemp("info")
with ZipFile(str(tox_wheel), "r") as zip_file:
zip_file.extractall(path=info)
dist_info = next((i for i in info.iterdir() if i.suffix == ".dist-info"), None)
if dist_info is None: # pragma: no cover
msg = f"no tox.dist-info inside {tox_wheel}"
raise RuntimeError(msg)
distribution = Distribution.at(dist_info)
wheel_cache = ROOT / ".wheel_cache" / f"{sys.version_info.major}.{sys.version_info.minor}"
wheel_cache.mkdir(parents=True, exist_ok=True)
cmd = [sys.executable, "-I", "-m", "pip", "download", "-d", str(wheel_cache)]
assert distribution.requires is not None
for req in distribution.requires:
requirement = Requirement(req)
if not requirement.extras: # pragma: no branch # we don't need to install any extras (tests/docs/etc)
cmd.append(req)
check_call(cmd)
result.extend(wheel_cache.iterdir())
return result
@pytest.fixture(scope="session")
def pypi_index_self(pypi_server: IndexServer, tox_wheels: list[Path], demo_pkg_inline_wheel: Path) -> Index:
with elapsed("start devpi and create index"): # takes around 1s
self_index = pypi_server.create_index("self", "volatile=False")
with elapsed("upload tox and its wheels to devpi"): # takes around 3.2s on build
self_index.upload(*tox_wheels, demo_pkg_inline_wheel)
return self_index
@pytest.fixture()
def _pypi_index_self(pypi_index_self: Index, monkeypatch: MonkeyPatch) -> None:
pypi_index_self.use()
monkeypatch.setenv("PIP_INDEX_URL", pypi_index_self.url)
monkeypatch.setenv("PIP_RETRIES", str(2))
monkeypatch.setenv("PIP_TIMEOUT", str(5))
def test_provision_requires_nok(tox_project: ToxProjectCreator) -> None:
ini = "[tox]\nrequires = pkg-does-not-exist\n setuptools==1\nskipsdist=true\n"
outcome = tox_project({"tox.ini": ini}).run("c", "-e", "py")
outcome.assert_failed()
outcome.assert_out_err(
r".*will run in automatically provisioned tox, host .* is missing \[requires \(has\)\]:"
r" pkg-does-not-exist, setuptools==1 \(.*\).*",
r".*",
regex=True,
)
@pytest.mark.integration()
@pytest.mark.usefixtures("_pypi_index_self")
def test_provision_requires_ok(tox_project: ToxProjectCreator, tmp_path: Path) -> None:
proj = tox_project({"tox.ini": "[tox]\nrequires=demo-pkg-inline\n[testenv]\npackage=skip"})
log = tmp_path / "out.log"
# initial run
result_first = proj.run("r", "--result-json", str(log))
result_first.assert_success()
prov_msg = (
f"ROOT: will run in automatically provisioned tox, host {sys.executable} is missing"
f" [requires (has)]: demo-pkg-inline"
)
assert prov_msg in result_first.out
with log.open("rt") as file_handler:
log_report = json.load(file_handler)
assert "py" in log_report["testenvs"]
# recreate without recreating the provisioned env
provision_env = result_first.env_conf(".tox")["env_dir"]
result_recreate_no_pr = proj.run("r", "--recreate", "--no-recreate-provision")
result_recreate_no_pr.assert_success()
assert prov_msg in result_recreate_no_pr.out
assert f"ROOT: remove tox env folder {provision_env}" not in result_recreate_no_pr.out, result_recreate_no_pr.out
# recreate with recreating the provisioned env
result_recreate = proj.run("r", "--recreate")
result_recreate.assert_success()
assert prov_msg in result_recreate.out
assert f"ROOT: remove tox env folder {provision_env}" in result_recreate.out, result_recreate.out
@pytest.mark.integration()
@pytest.mark.usefixtures("_pypi_index_self")
def test_provision_platform_check(tox_project: ToxProjectCreator) -> None:
ini = "[tox]\nrequires=demo-pkg-inline\n[testenv]\npackage=skip\n[testenv:.tox]\nplatform=wrong_platform"
proj = tox_project({"tox.ini": ini})
result = proj.run("r")
result.assert_failed(-2)
msg = f"cannot provision tox environment .tox because platform {sys.platform} does not match wrong_platform"
assert msg in result.out
def test_provision_no_recreate(tox_project: ToxProjectCreator) -> None:
ini = "[tox]\nrequires = p\nskipsdist=true\n"
result = tox_project({"tox.ini": ini}).run("c", "-e", "py", "--no-provision")
result.assert_failed()
assert f"provisioning explicitly disabled within {sys.executable}, but is missing [requires (has)]: p" in result.out
def test_provision_no_recreate_json(tox_project: ToxProjectCreator) -> None:
ini = "[tox]\nrequires = p\nskipsdist=true\n"
project = tox_project({"tox.ini": ini})
result = project.run("c", "-e", "py", "--no-provision", "out.json")
result.assert_failed()
msg = (
f"provisioning explicitly disabled within {sys.executable}, "
f"but is missing [requires (has)]: p and wrote to out.json"
)
assert msg in result.out
with (project.path / "out.json").open() as file_handler:
requires = json.load(file_handler)
assert requires == {"minversion": None, "requires": ["p", "tox"]}
@pytest.mark.integration()
@pytest.mark.usefixtures("_pypi_index_self")
@pytest.mark.parametrize("plugin_testenv", ["testenv", "testenv:a"])
def test_provision_plugin_runner(tox_project: ToxProjectCreator, tmp_path: Path, plugin_testenv: str) -> None:
"""Ensure that testenv runner doesn't affect the provision env."""
log = tmp_path / "out.log"
proj = tox_project(
{"tox.ini": f"[tox]\nrequires=demo-pkg-inline\nlabels=l=py\n[{plugin_testenv}]\nrunner=example"},
)
prov_msg = (
f"ROOT: will run in automatically provisioned tox, host {sys.executable} is missing"
f" [requires (has)]: demo-pkg-inline"
)
result_env = proj.run("r", "-e", "py", "--result-json", str(log))
result_env.assert_success()
assert prov_msg in result_env.out
result_label = proj.run("r", "-m", "l", "--result-json", str(log))
result_label.assert_success()
assert prov_msg in result_label.out
@pytest.mark.integration()
def test_provision_plugin_runner_in_provision(tox_project: ToxProjectCreator, tmp_path: Path) -> None:
"""Ensure that provision environment can be explicitly configured."""
log = tmp_path / "out.log"
proj = tox_project({"tox.ini": "[tox]\nrequires=somepkg123xyz\n[testenv:.tox]\nrunner=example"})
with pytest.raises(KeyError, match="example"):
proj.run("r", "-e", "py", "--result-json", str(log))
@pytest.mark.integration()
@pytest.mark.usefixtures("_pypi_index_self")
@pytest.mark.parametrize("relative_path", [True, False], ids=["relative", "absolute"])
def test_provision_conf_file(tox_project: ToxProjectCreator, tmp_path: Path, relative_path: bool) -> None:
ini = "[tox]\nrequires = demo-pkg-inline\nskipsdist=true\n"
project = tox_project({"tox.ini": ini}, prj_path=tmp_path / "sub")
conf_path = str(Path(project.path.name) / "tox.ini") if relative_path else str(project.path / "tox.ini")
result = project.run("c", "--conf", conf_path, "-e", "py", from_cwd=tmp_path)
result.assert_success()
tox-4.13.0/tests/test_report.py 0000664 0000000 0000000 00000004563 14564001166 0016512 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import logging
import os
from typing import TYPE_CHECKING
import pytest
from colorama import Style, deinit
from tox.report import setup_report
if TYPE_CHECKING:
from pytest_mock import MockerFixture
from tox.pytest import CaptureFixture
@pytest.mark.parametrize("color", [True, False], ids=["on", "off"])
@pytest.mark.parametrize("verbosity", range(7))
def test_setup_report(mocker: MockerFixture, capsys: CaptureFixture, verbosity: int, color: bool) -> None:
color_init = mocker.patch("tox.report.init")
setup_report(verbosity=verbosity, is_colored=color)
try:
logging.critical("critical")
logging.error("error")
# special warning line that should be auto-colored
logging.warning("%s%s> %s", "warning", "foo", "bar")
logging.info("info")
logging.debug("debug")
logging.log(logging.NOTSET, "not-set") # this should not be logged
disabled = "distlib.util", "filelock"
for name in disabled:
logger = logging.getLogger(name)
logger.warning("%s-warn", name)
logger.info("%s-info", name)
logger.debug("%s-debug", name)
logger.log(logging.NOTSET, "%s-notset", name)
finally:
deinit()
assert color_init.call_count == (1 if color else 0)
msg_count = min(verbosity + 1, 5)
is_debug_or_more = verbosity >= 4
if is_debug_or_more:
msg_count += 1 # we log at debug level setting up the logger
out, err = capsys.readouterr()
assert not err
assert out
assert "filelock" not in out
assert "distlib.util" not in out
lines = out.splitlines()
assert len(lines) == msg_count, out
if is_debug_or_more and lines: # assert we start with relative created, contain path
line = lines[0]
int(line.split(" ")[1]) # first element is an int number
assert f"[tox{os.sep}report.py" in line # relative file location
if color:
assert f"{Style.RESET_ALL}" in out
# check that our Warning line using special format was colored
expected_warning_text = "W\x1b[0m\x1b[36m warning\x1b[22mfoo\x1b[2m>\x1b[0m bar\x1b[0m\x1b[2m"
else:
assert f"{Style.RESET_ALL}" not in out
expected_warning_text = "warningfoo> bar"
if verbosity >= 4: # where warnings are logged
assert expected_warning_text in lines[3]
tox-4.13.0/tests/test_run.py 0000664 0000000 0000000 00000007516 14564001166 0016004 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
import pytest
from tox.report import HandledError
from tox.run import run
if TYPE_CHECKING:
from pathlib import Path
from pytest_mock import MockerFixture
from tox.pytest import ToxProjectCreator
@pytest.mark.parametrize("exception", [HandledError, KeyboardInterrupt])
def test_exit_code_minus_2_on_expected_exit(exception: Exception, mocker: MockerFixture) -> None:
mocker.patch("tox.run.main", side_effect=exception)
with pytest.raises(SystemExit) as system_exit:
run()
assert system_exit.value.code == -2
def test_re_raises_on_unexpected_exit(mocker: MockerFixture) -> None:
mocker.patch("tox.run.main", side_effect=ValueError)
with pytest.raises(ValueError, match=""): # noqa: PT011
run()
def test_custom_work_dir(tox_project: ToxProjectCreator, tmp_path: Path) -> None:
project = tox_project({})
expected_tox_root = project.path
expected_work_dir = tmp_path
outcome = project.run("c", "--workdir", str(expected_work_dir))
outcome.assert_success()
assert outcome.state.conf.options.work_dir == expected_work_dir, "should parse the --workdir argument"
assert outcome.state.conf.core["work_dir"], f"should set work_dir to {expected_work_dir}"
assert outcome.state.conf.core["tox_root"] == expected_tox_root, "should not update the value of tox_root"
assert outcome.state.conf.core["work_dir"] != (
expected_tox_root / ".tox"
), "should explicitly demonstrate that tox_root and work_dir are decoupled"
# should update config values that depend on work_dir
assert outcome.state.conf.core["temp_dir"] == expected_work_dir / ".tmp"
env_conf = outcome.state.conf.get_env("py")
assert env_conf["env_dir"] == expected_work_dir / "py"
assert env_conf["env_log_dir"] == expected_work_dir / "py" / "log"
assert env_conf["env_tmp_dir"] == expected_work_dir / "py" / "tmp"
def test_custom_root_dir(tox_project: ToxProjectCreator, tmp_path: Path) -> None:
project = tox_project({})
expected_tox_root = tmp_path
expected_work_dir = expected_tox_root / ".tox"
outcome = project.run("c", "--root", str(expected_tox_root))
outcome.assert_success()
assert outcome.state.conf.options.root_dir == expected_tox_root, "should parse the --root argument"
assert outcome.state.conf.core["tox_root"] == expected_tox_root, f"should set tox_root to {expected_tox_root}"
# values that depend on tox_root should also be updated
assert outcome.state.conf.core["work_dir"] == expected_work_dir
assert outcome.state.conf.core["temp_dir"] == expected_work_dir / ".tmp"
env_conf = outcome.state.conf.get_env("py")
assert env_conf["env_dir"] == expected_work_dir / "py"
assert env_conf["env_log_dir"] == expected_work_dir / "py" / "log"
assert env_conf["env_tmp_dir"] == expected_work_dir / "py" / "tmp"
def test_custom_root_dir_and_work_dir(tox_project: ToxProjectCreator, tmp_path: Path) -> None:
project = tox_project({})
expected_tox_root = tmp_path / "tox_root"
expected_work_dir = tmp_path / "work_dir"
outcome = project.run("c", "--root", str(expected_tox_root), "--workdir", str(expected_work_dir))
outcome.assert_success()
assert outcome.state.conf.core["tox_root"] == expected_tox_root, f"should set tox_root to {expected_tox_root}"
assert outcome.state.conf.core["work_dir"] == expected_work_dir, f"should set work_dir to {expected_work_dir}"
# values that depend on work_dir should also be updated
assert outcome.state.conf.core["temp_dir"] == expected_work_dir / ".tmp"
env_conf = outcome.state.conf.get_env("py")
assert env_conf["env_dir"] == expected_work_dir / "py"
assert env_conf["env_log_dir"] == expected_work_dir / "py" / "log"
assert env_conf["env_tmp_dir"] == expected_work_dir / "py" / "tmp"
tox-4.13.0/tests/test_version.py 0000664 0000000 0000000 00000002416 14564001166 0016657 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from types import SimpleNamespace
from typing import TYPE_CHECKING
from tox import __version__
from tox.plugin.manager import MANAGER
if TYPE_CHECKING:
from pytest_mock import MockFixture
from tox.pytest import ToxProjectCreator
def test_version() -> None:
assert __version__
def test_version_without_plugin(tox_project: ToxProjectCreator) -> None:
outcome = tox_project({"tox.ini": ""}).run("--version")
outcome.assert_success()
assert __version__ in outcome.out
assert "plugin" not in outcome.out
def test_version_with_plugin(tox_project: ToxProjectCreator, mocker: MockFixture) -> None:
dist = [
(
mocker.create_autospec("types.ModuleType", __file__=f"{i}-path"),
SimpleNamespace(project_name=i, version=v),
)
for i, v in (("B", "1.0"), ("A", "2.0"))
]
mocker.patch.object(MANAGER.manager, "list_plugin_distinfo", return_value=dist)
outcome = tox_project({"tox.ini": ""}).run("--version")
outcome.assert_success()
assert not outcome.err
lines = outcome.out.splitlines()
assert lines[0].startswith(__version__)
assert lines[1:] == [
"registered plugins:",
" B-1.0 at B-path",
" A-2.0 at A-path",
]
tox-4.13.0/tests/tox_env/ 0000775 0000000 0000000 00000000000 14564001166 0015240 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/tox_env/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0017337 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/tox_env/python/ 0000775 0000000 0000000 00000000000 14564001166 0016561 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/tox_env/python/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0020660 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/tox_env/python/pip/ 0000775 0000000 0000000 00000000000 14564001166 0017351 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/tox_env/python/pip/req/ 0000775 0000000 0000000 00000000000 14564001166 0020140 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/tox_env/python/pip/req/test_file.py 0000664 0000000 0000000 00000053233 14564001166 0022476 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
import sys
from contextlib import contextmanager
from io import BytesIO
from typing import IO, TYPE_CHECKING, Any, Iterator
import pytest
from tox.tox_env.python.pip.req.file import ParsedRequirement, RequirementsFile
if TYPE_CHECKING:
from pathlib import Path
from pytest_mock import MockerFixture
from tox.pytest import CaptureFixture, MonkeyPatch
_REQ_FILE_TEST_CASES = [
pytest.param("--pre", {"pre": True}, [], ["--pre"], id="pre"),
pytest.param("--no-index", {"index_url": []}, [], ["--no-index"], id="no-index"),
pytest.param("--no-index\n-i a\n--no-index", {"index_url": []}, [], ["--no-index"], id="no-index overwrites index"),
pytest.param("--prefer-binary", {"prefer_binary": True}, [], ["--prefer-binary"], id="prefer-binary"),
pytest.param("--require-hashes", {"require_hashes": True}, [], ["--require-hashes"], id="requires-hashes"),
pytest.param("--pre ", {"pre": True}, [], ["--pre"], id="space after"),
pytest.param(" --pre", {"pre": True}, [], ["--pre"], id="space before"),
pytest.param("--pre\\\n", {"pre": True}, [], ["--pre"], id="newline after"),
pytest.param("--pre # magic", {"pre": True}, [], ["--pre"], id="comment after space"),
pytest.param("--pre\t# magic", {"pre": True}, [], ["--pre"], id="comment after tab"),
pytest.param(
"--find-links /my/local/archives",
{"find_links": ["/my/local/archives"]},
[],
["-f", "/my/local/archives"],
id="find-links path",
),
pytest.param(
"--find-links /my/local/archives --find-links /my/local/archives",
{"find_links": ["/my/local/archives"]},
[],
["-f", "/my/local/archives"],
id="find-links duplicate same line",
),
pytest.param(
"--find-links /my/local/archives\n--find-links /my/local/archives",
{"find_links": ["/my/local/archives"]},
[],
["-f", "/my/local/archives"],
id="find-links duplicate different line",
),
pytest.param(
"--find-links \\\n/my/local/archives",
{"find_links": ["/my/local/archives"]},
[],
["-f", "/my/local/archives"],
id="find-links newline path",
),
pytest.param(
"--find-links http://some.archives.com/archives",
{"find_links": ["http://some.archives.com/archives"]},
[],
["-f", "http://some.archives.com/archives"],
id="find-links url",
),
pytest.param(
"--index-url a --find-links http://some.archives.com/archives",
{
"index_url": ["a"],
"find_links": ["http://some.archives.com/archives"],
},
[],
["-i", "a", "-f", "http://some.archives.com/archives"],
id="index and find",
),
pytest.param("-i a", {"index_url": ["a"]}, [], ["-i", "a"], id="index url short"),
pytest.param("--index-url a", {"index_url": ["a"]}, [], ["-i", "a"], id="index url long"),
pytest.param("-i a -i b\n-i c", {"index_url": ["c"]}, [], ["-i", "c"], id="index url multiple"),
pytest.param(
"--extra-index-url a",
{"index_url": ["https://pypi.org/simple", "a"]},
[],
["--extra-index-url", "a"],
id="extra-index-url",
),
pytest.param(
"--extra-index-url a --extra-index-url a",
{"index_url": ["https://pypi.org/simple", "a"]},
[],
["--extra-index-url", "a"],
id="extra-index-url dup same line",
),
pytest.param(
"--extra-index-url a\n--extra-index-url a",
{"index_url": ["https://pypi.org/simple", "a"]},
[],
["--extra-index-url", "a"],
id="extra-index-url dup different line",
),
pytest.param("-e a", {}, ["-e a"], ["-e", "a"], id="e"),
pytest.param("--editable a", {}, ["-e a"], ["-e", "a"], id="editable"),
pytest.param("--editable .[2,1]", {}, ["-e .[1,2]"], ["-e", ".[1,2]"], id="editable extra"),
pytest.param(".[\t, a1. , B2-\t, C3_, ]", {}, [".[B2-,C3_,a1.]"], [".[B2-,C3_,a1.]"], id="path with extra"),
pytest.param(".[a.1]", {}, [f".{os.sep}.[a.1]"], [f".{os.sep}.[a.1]"], id="path with invalid extra is path"),
pytest.param("-f a", {"find_links": ["a"]}, [], ["-f", "a"], id="f"),
pytest.param("--find-links a", {"find_links": ["a"]}, [], ["-f", "a"], id="find-links"),
pytest.param("--trusted-host a", {"trusted_hosts": ["a"]}, [], ["--trusted-host", "a"], id="trusted-host"),
pytest.param(
"--trusted-host a --trusted-host a",
{"trusted_hosts": ["a"]},
[],
["--trusted-host", "a"],
id="trusted-host dup same line",
),
pytest.param(
"--trusted-host a\n--trusted-host a",
{"trusted_hosts": ["a"]},
[],
["--trusted-host", "a"],
id="trusted-host dup different line",
),
pytest.param(
"--use-feature 2020-resolver",
{"features_enabled": ["2020-resolver"]},
[],
["--use-feature", "2020-resolver"],
id="use-feature space",
),
pytest.param(
"--use-feature=fast-deps",
{"features_enabled": ["fast-deps"]},
[],
["--use-feature", "fast-deps"],
id="use-feature equal",
),
pytest.param(
"--use-feature=fast-deps --use-feature 2020-resolver",
{"features_enabled": ["2020-resolver", "fast-deps"]},
[],
["--use-feature", "2020-resolver", "--use-feature", "fast-deps"],
id="use-feature multiple same line",
),
pytest.param(
"--use-feature=fast-deps\n--use-feature 2020-resolver",
{"features_enabled": ["2020-resolver", "fast-deps"]},
[],
["--use-feature", "2020-resolver", "--use-feature", "fast-deps"],
id="use-feature multiple different line",
),
pytest.param(
"--use-feature=fast-deps\n--use-feature 2020-resolver\n" * 2,
{"features_enabled": ["2020-resolver", "fast-deps"]},
[],
["--use-feature", "2020-resolver", "--use-feature", "fast-deps"],
id="use-feature multiple duplicate different line",
),
pytest.param("--no-binary :all:", {"no_binary": {":all:"}}, [], ["--no-binary", {":all:"}], id="no-binary all"),
pytest.param("--no-binary :none:", {"no_binary": {":none:"}}, [], [], id="no-binary none"),
pytest.param(
"--only-binary :all:",
{"only_binary": {":all:"}},
[],
["--only-binary", {":all:"}],
id="only-binary all",
),
pytest.param(
"--only-binary :none:",
{"only_binary": {":none:"}},
[],
[],
id="only-binary none",
),
pytest.param(
"--no-binary=foo --only-binary=foo",
{"only_binary": {"foo"}},
[],
["--only-binary", {"foo"}],
id="no-binary-and-only-binary",
),
pytest.param(
"--no-binary=foo --no-binary=:none:",
{},
[],
[],
id="no-binary-none-last",
),
pytest.param(
"--only-binary=:none: --no-binary=foo",
{"no_binary": {"foo"}},
[],
["--no-binary", {"foo"}],
id="no-binary-none-first",
),
pytest.param(
"--only-binary foo; sys_platform == 'aix'",
{"only_binary": {"foo;"}},
[],
["--only-binary", {"foo;"}],
id="only-binary-and-env-marker",
),
pytest.param("####### example-requirements.txt #######", {}, [], [], id="comment"),
pytest.param("\t##### Requirements without Version Specifiers ######", {}, [], [], id="tab and comment"),
pytest.param(" # start", {}, [], [], id="space and comment"),
pytest.param("nose", {}, ["nose"], ["nose"], id="req"),
pytest.param("nose\nnose", {}, ["nose"], ["nose"], id="req dup"),
pytest.param(
"numpy[2,1] @ file://./downloads/numpy-1.9.2-cp34-none-win32.whl",
{},
["numpy[1,2]@ file://./downloads/numpy-1.9.2-cp34-none-win32.whl"],
["numpy[1,2]@ file://./downloads/numpy-1.9.2-cp34-none-win32.whl"],
id="path with name-extra-protocol",
),
pytest.param(
"docopt == 0.6.1 # Version Matching. Must be version 0.6.1",
{},
["docopt==0.6.1"],
["docopt==0.6.1"],
id="req equal comment",
),
pytest.param(
"keyring >= 4.1.1 # Minimum version 4.1.1",
{},
["keyring>=4.1.1"],
["keyring>=4.1.1"],
id="req ge comment",
),
pytest.param(
"coverage != 3.5 # Version Exclusion. Anything except version 3.5",
{},
["coverage!=3.5"],
["coverage!=3.5"],
id="req ne comment",
),
pytest.param(
"Mopidy-Dirble ~= 1.1 # Compatible release. Same as >= 1.1, == 1.*",
{},
["Mopidy-Dirble~=1.1"],
["Mopidy-Dirble~=1.1"],
id="req approx comment",
),
pytest.param("b==1.3", {}, ["b==1.3"], ["b==1.3"], id="req eq"),
pytest.param("c >=1.2,<2.0", {}, ["c<2.0,>=1.2"], ["c<2.0,>=1.2"], id="req ge lt"),
pytest.param("d[bar,foo]", {}, ["d[bar,foo]"], ["d[bar,foo]"], id="req extras"),
pytest.param("d[foo, bar]", {}, ["d[bar,foo]"], ["d[bar,foo]"], id="req extras space"),
pytest.param("d[foo,\tbar]", {}, ["d[bar,foo]"], ["d[bar,foo]"], id="req extras tab"),
pytest.param("e~=1.4.2", {}, ["e~=1.4.2"], ["e~=1.4.2"], id="req approx"),
pytest.param(
"f ==5.4 ; python_version < '2.7'",
{},
['f==5.4; python_version < "2.7"'],
['f==5.4; python_version < "2.7"'],
id="python version filter",
),
pytest.param(
"g; sys_platform == 'win32'",
{},
['g; sys_platform == "win32"'],
['g; sys_platform == "win32"'],
id="platform filter",
),
pytest.param(
"http://w.org/w_P-3.0.3.dev1820+49a8884-cp34-none-win_amd64.whl",
{},
["http://w.org/w_P-3.0.3.dev1820+49a8884-cp34-none-win_amd64.whl"],
["http://w.org/w_P-3.0.3.dev1820+49a8884-cp34-none-win_amd64.whl"],
id="http URI",
),
pytest.param(
"git+https://git.example.com/MyProject#egg=MyProject",
{},
["git+https://git.example.com/MyProject#egg=MyProject"],
["git+https://git.example.com/MyProject#egg=MyProject"],
id="vcs with https",
),
pytest.param(
"git+ssh://git.example.com/MyProject#egg=MyProject",
{},
["git+ssh://git.example.com/MyProject#egg=MyProject"],
["git+ssh://git.example.com/MyProject#egg=MyProject"],
id="vcs with ssh",
),
pytest.param(
"git+https://git.example.com/MyProject.git@da39a3ee5e6b4b0d3255bfef95601890afd80709#egg=MyProject",
{},
["git+https://git.example.com/MyProject.git@da39a3ee5e6b4b0d3255bfef95601890afd80709#egg=MyProject"],
["git+https://git.example.com/MyProject.git@da39a3ee5e6b4b0d3255bfef95601890afd80709#egg=MyProject"],
id="vcs with commit hash pin",
),
pytest.param(
"attrs --hash sha384:142d9b02f3f4511ccabf6c14bd34d2b0a9ed043a898228b48343cfdf4eb10856ef7ad5e2ff2c528ecae04"
"912224782ab\t--hash=sha256:af957b369adcd07e5b3c64d2cdb76d6808c5e0b16c35ca41c79c8eee34808152 # ok",
{},
[
"attrs --hash sha256:af957b369adcd07e5b3c64d2cdb76d6808c5e0b16c35ca41c79c8eee34808152 --hash sha384:"
"142d9b02f3f4511ccabf6c14bd34d2b0a9ed043a898228b48343cfdf4eb10856ef7ad5e2ff2c528ecae04912224782ab",
],
["attrs"],
id="hash",
),
pytest.param(
"attrs --hash=sha256:af957b369adcd07e5b3c64d2cdb76d6808c5e0b16c35ca41c79c8eee34808152\\\n "
"--hash sha384:142d9b02f3f4511ccabf6c14bd34d2b0a9ed043a898228b48343cfdf4eb10856ef7ad5"
"e2ff2c528ecae04912224782ab\n",
{},
[
"attrs --hash sha256:af957b369adcd07e5b3c64d2cdb76d6808c5e0b16c35ca41c79c8eee34808152 --hash sha384:"
"142d9b02f3f4511ccabf6c14bd34d2b0a9ed043a898228b48343cfdf4eb10856ef7ad5e2ff2c528ecae04912224782ab",
],
["attrs"],
id="hash with escaped newline",
),
pytest.param(
"attrs --hash=sha512:7a91e5a3d1a1238525e477385ef5ee6cecdc8f8fcc2a79d1b35a9f57ad15c814"
"dada670026f41fdd62e5e10b3fd75d6112704a9521c3df105f0b6f3bb11b128a",
{},
[
"attrs --hash sha512:7a91e5a3d1a1238525e477385ef5ee6cecdc8f8fcc2a79d1b35a9f57ad15c814"
"dada670026f41fdd62e5e10b3fd75d6112704a9521c3df105f0b6f3bb11b128a",
],
["attrs"],
id="sha512 hash is supported",
),
pytest.param(
"\tp @ https://github.com/a/b/c/d.zip ",
{},
["p@ https://github.com/a/b/c/d.zip"],
["p@ https://github.com/a/b/c/d.zip"],
id="whitespace around",
),
]
@pytest.mark.parametrize(("req", "opts", "requirements", "as_args"), _REQ_FILE_TEST_CASES)
def test_req_file(tmp_path: Path, req: str, opts: dict[str, Any], requirements: list[str], as_args: list[str]) -> None:
requirements_txt = tmp_path / "req.txt"
requirements_txt.write_text(req)
req_file = RequirementsFile(requirements_txt, constraint=False)
assert req_file.as_root_args == as_args
assert str(req_file) == f"-r {requirements_txt}"
assert vars(req_file.options) == (opts if {":none:"} not in opts.values() else {})
found = [str(i) for i in req_file.requirements]
assert found == requirements
def test_requirements_env_var_present(monkeypatch: MonkeyPatch, tmp_path: Path) -> None:
monkeypatch.setenv("ENV_VAR", "beta")
requirements_file = tmp_path / "req.txt"
requirements_file.write_text("${ENV_VAR} >= 1")
req_file = RequirementsFile(requirements_file, constraint=False)
assert vars(req_file.options) == {}
found = [str(i) for i in req_file.requirements]
assert found == ["beta>=1"]
def test_requirements_env_var_missing(monkeypatch: MonkeyPatch, tmp_path: Path) -> None:
monkeypatch.delenv("ENV_VAR", raising=False)
requirements_file = tmp_path / "req.txt"
requirements_file.write_text("${ENV_VAR}")
req_file = RequirementsFile(requirements_file, constraint=False)
assert vars(req_file.options) == {}
found = [str(i) for i in req_file.requirements]
assert found == [f".{os.sep}${{ENV_VAR}}"]
@pytest.mark.parametrize("flag", ["-r", "--requirement"])
def test_requirements_txt_transitive(tmp_path: Path, flag: str) -> None:
other_req = tmp_path / "other-requirements.txt"
other_req.write_text("magic\nmagical")
requirements_file = tmp_path / "req.txt"
requirements_file.write_text(f"{flag} other-requirements.txt\n{flag} other-requirements.txt")
req_file = RequirementsFile(requirements_file, constraint=False)
assert req_file.as_root_args == ["-r", "other-requirements.txt"]
assert req_file.as_root_args is req_file.as_root_args # check it's cached
assert vars(req_file.options) == {}
found = [str(i) for i in req_file.requirements]
assert found == ["magic", "magical"]
@pytest.mark.parametrize(
("raw", "error"),
[
("--pre something", "unrecognized arguments: something"),
("--missing", "unrecognized arguments: --missing"),
("--index-url a b", "unrecognized arguments: b"),
("--index-url", "argument -i/--index-url/--pypi-url: expected one argument"),
("-k", "unrecognized arguments: -k"),
],
)
def test_bad_line(tmp_path: Path, raw: str, capfd: CaptureFixture, error: str) -> None:
requirements_file = tmp_path / "req.txt"
requirements_file.write_text(raw)
req_file = RequirementsFile(requirements_file, constraint=False)
with pytest.raises(ValueError, match=f"^{error}$"):
assert req_file.options
out, err = capfd.readouterr()
assert not out
assert not err
def test_requirements_file_missing(tmp_path: Path) -> None:
requirements_file = tmp_path / "req.txt"
requirements_file.write_text("-r one.txt")
req_file = RequirementsFile(requirements_file, constraint=False)
with pytest.raises(ValueError, match="No such file or directory: .*one.txt"):
assert req_file.options
@pytest.mark.parametrize("flag", ["-c", "--constraint"])
def test_constraint_txt_expanded(tmp_path: Path, flag: str) -> None:
other_req = tmp_path / "other.txt"
other_req.write_text("magic\nmagical\n-i a")
requirements_file = tmp_path / "req.txt"
requirements_file.write_text(f"{flag} other.txt\n{flag} other.txt")
req_file = RequirementsFile(requirements_file, constraint=True)
assert req_file.as_root_args == ["-c", "other.txt"]
assert vars(req_file.options) == {"index_url": ["a"]}
found = [str(i) for i in req_file.requirements]
assert found == ["-c magic", "-c magical"]
@pytest.mark.skipif(sys.platform == "win32", reason=r"on windows the escaped \ is overloaded by path separator")
def test_req_path_with_space_escape(tmp_path: Path) -> None:
dep_requirements_file = tmp_path / "a b"
dep_requirements_file.write_text("c")
path = f"-r {dep_requirements_file!s}"
path = f'{path[:-len("a b")]}a\\ b'
requirements_file = tmp_path / "req.txt"
requirements_file.write_text(path)
req_file = RequirementsFile(requirements_file, constraint=False)
assert vars(req_file.options) == {}
found = [str(i) for i in req_file.requirements]
assert found == ["c"]
@pytest.mark.parametrize(
"hash_value",
[
"sha256:a",
"sha256:xxxxxxxxxx123456789012345678901234567890123456789012345678901234",
"sha512:thisshouldfail8525e477385ef5ee6cecdc8f8fcc2a79d1b35a9f57ad15c814"
"dada670026f41fdd62e5e10b3fd75d6112704a9521c3df105f0b6f3bb11b128a",
],
)
def test_bad_hash(hash_value: str, tmp_path: Path) -> None:
requirements_txt = tmp_path / "req.txt"
requirements_txt.write_text(f"attrs --hash {hash_value}")
req_file = RequirementsFile(requirements_txt, constraint=False)
with pytest.raises(ValueError, match=f"^argument --hash: {hash_value}$"):
assert req_file.requirements
@pytest.mark.parametrize("codec", ["utf-8", "utf-16", "utf-32"])
def test_custom_file_encoding(codec: str, tmp_path: Path) -> None:
requirements_file = tmp_path / "r.txt"
raw = "art".encode(codec)
requirements_file.write_bytes(raw)
req_file = RequirementsFile(requirements_file, constraint=False)
assert [str(i) for i in req_file.requirements] == ["art"]
def test_parsed_requirement_properties(tmp_path: Path) -> None:
req = ParsedRequirement("a", {"b": 1}, str(tmp_path), 1)
assert req.options == {"b": 1}
assert str(req.requirement) == "a"
assert req.from_file == str(tmp_path)
assert req.lineno == 1
def test_parsed_requirement_repr_with_opt(tmp_path: Path) -> None:
req = ParsedRequirement("a", {"b": 1}, str(tmp_path), 1)
assert repr(req) == "ParsedRequirement(requirement=a, options={'b': 1})"
def test_parsed_requirement_repr_no_opt(tmp_path: Path) -> None:
assert repr(ParsedRequirement("a", {}, str(tmp_path), 2)) == "ParsedRequirement(requirement=a)"
@pytest.mark.parametrize("flag", ["-r", "--requirement", "-c", "--constraint"])
def test_req_over_http(tmp_path: Path, flag: str, mocker: MockerFixture) -> None:
is_constraint = flag in {"-c", "--constraint"}
url_open = mocker.patch("tox.tox_env.python.pip.req.file.urlopen", autospec=True)
url_open.return_value.__enter__.return_value = BytesIO(b"-i i\na")
requirements_txt = tmp_path / "req.txt"
requirements_txt.write_text(f"{flag} https://zopefoundation.github.io/Zope/releases/4.5.5/requirements-full.txt")
req_file = RequirementsFile(requirements_txt, constraint=is_constraint)
assert str(req_file) == f"-{'c' if is_constraint else 'r'} {requirements_txt}"
assert vars(req_file.options) == {"index_url": ["i"]}
found = [str(i) for i in req_file.requirements]
assert found == [f"{'-c ' if is_constraint else ''}a"]
def test_req_over_http_has_req(tmp_path: Path, mocker: MockerFixture) -> None:
@contextmanager
def enter(url: str) -> Iterator[IO[bytes]]:
if url == "https://root.org/a.txt":
yield BytesIO(b"-r b.txt")
elif url == "https://root.org/b.txt":
yield BytesIO(b"-i i\na")
else: # pragma: no cover
raise RuntimeError # pragma: no cover
mocker.patch("tox.tox_env.python.pip.req.file.urlopen", autospec=True, side_effect=enter)
requirements_txt = tmp_path / "req.txt"
requirements_txt.write_text("-r https://root.org/a.txt")
req_file = RequirementsFile(requirements_txt, constraint=False)
assert vars(req_file.options) == {"index_url": ["i"]}
found = [str(i) for i in req_file.requirements]
assert found == ["a"]
@pytest.mark.parametrize(
"loc",
["file://", "file://localhost"],
)
def test_requirement_via_file_protocol(tmp_path: Path, loc: str) -> None:
other_req = tmp_path / "other-requirements.txt"
other_req.write_text("-i i\na")
requirements_text = tmp_path / "req.txt"
requirements_text.write_text(f"-r {loc}{'/' if sys.platform == 'win32' else ''}{other_req}")
req_file = RequirementsFile(requirements_text, constraint=False)
assert vars(req_file.options) == {"index_url": ["i"]}
found = [str(i) for i in req_file.requirements]
assert found == ["a"]
def test_requirement_via_file_protocol_na(tmp_path: Path) -> None:
other_req = tmp_path / "other-requirements.txt"
other_req.write_text("-i i\na")
requirements_text = tmp_path / "req.txt"
requirements_text.write_text(f"-r file://magic.com{'/' if sys.platform == 'win32' else ''}{other_req}")
req_file = RequirementsFile(requirements_text, constraint=False)
pattern = r"non-local file URIs are not supported on this platform: 'file://magic\.com\.*"
with pytest.raises(ValueError, match=pattern):
assert req_file.options
def test_requirement_to_path_one_level_up(tmp_path: Path) -> None:
other_req = tmp_path / "other.txt"
other_req.write_text("-e ..")
req_file = RequirementsFile(other_req, constraint=False)
result = req_file.requirements
assert result[0].requirement == str(tmp_path.parent.resolve())
tox-4.13.0/tests/tox_env/python/pip/test_pip_install.py 0000664 0000000 0000000 00000041275 14564001166 0023311 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
from typing import TYPE_CHECKING, Any
from unittest.mock import Mock
import pytest
from packaging.requirements import Requirement
from tox.tox_env.errors import Fail
if TYPE_CHECKING:
from pathlib import Path
from tox.pytest import CaptureFixture, SubRequest, ToxProject, ToxProjectCreator
@pytest.mark.parametrize("arg", [object, [object]])
def test_pip_install_bad_type(tox_project: ToxProjectCreator, capfd: CaptureFixture, arg: Any) -> None:
proj = tox_project({"tox.ini": ""})
result = proj.run("l")
result.assert_success()
pip = result.state.envs["py"].installer
with pytest.raises(SystemExit, match="1"):
pip.install(arg, "section", "type")
out, err = capfd.readouterr()
assert not err
assert f"pip cannot install {object!r}" in out
def test_pip_install_empty_list(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": ""})
result = proj.run("l")
result.assert_success()
pip = result.state.envs["py"].installer
execute_calls = proj.patch_execute(Mock())
pip.install([], "section", "type")
assert execute_calls.call_count == 0
def test_pip_install_empty_command_error(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv]\ninstall_command="})
result = proj.run("l")
pip = result.state.envs["py"].installer
with pytest.raises(Fail, match="unable to determine pip install command"):
pip.install([Requirement("name")], "section", "type")
def test_pip_install_flags_only_error(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv:py]\ndeps=-i a"})
result = proj.run("r")
result.assert_failed()
assert "no dependencies for tox env py within deps" in result.out
def test_pip_install_new_flag_recreates(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv:py]\ndeps=a\nskip_install=true"})
proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r")
result.assert_success()
(proj.path / "tox.ini").write_text("[testenv:py]\ndeps=a\n -i i\nskip_install=true")
result_second = proj.run("r")
result_second.assert_success()
assert "recreate env because changed install flag(s) added index_url=['i']" in result_second.out
assert "install_deps> python -I -m pip install a -i i" in result_second.out
def test_pip_install_path(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv:py]\ndeps=.{/}a\nskip_install=true"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r")
result.assert_success()
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", f".{os.sep}a"]
@pytest.mark.parametrize(
("content", "args"),
[
pytest.param("-e .", ["-e", "."], id="short editable"),
pytest.param("--editable .", ["-e", "."], id="long editable"),
pytest.param(
"git+ssh://git.example.com/MyProject\\#egg=MyProject",
["git+ssh://git.example.com/MyProject#egg=MyProject"],
id="vcs with ssh",
),
pytest.param(
"git+https://git.example.com/MyProject.git@da39a3ee5e6b4b0d3255bfef95601890afd80709\\#egg=MyProject",
["git+https://git.example.com/MyProject.git@da39a3ee5e6b4b0d3255bfef95601890afd80709#egg=MyProject"],
id="vcs with commit hash pin",
),
],
)
def test_pip_install_req_file_req_like(tox_project: ToxProjectCreator, content: str, args: list[str]) -> None:
proj = tox_project({"tox.ini": f"[testenv:py]\ndeps={content}\nskip_install=true"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r")
result.assert_success()
assert execute_calls.call_count == 1
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", *args]
# check that adding a new dependency correctly finds the previous one
(proj.path / "tox.ini").write_text(f"[testenv:py]\ndeps={content}\n a\nskip_install=true")
execute_calls.reset_mock()
result_second = proj.run("r")
result_second.assert_success()
assert execute_calls.call_count == 1
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", "a", *args]
def test_pip_req_path(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv:py]\ndeps=.\nskip_install=true"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r")
result.assert_success()
assert execute_calls.call_count == 1
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", "."]
def test_deps_remove_recreate(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv]\npackage=skip\ndeps=wheel\n setuptools"})
execute_calls = proj.patch_execute(lambda request: 0) # noqa: ARG005
result_first = proj.run("r")
result_first.assert_success()
assert execute_calls.call_count == 1
(proj.path / "tox.ini").write_text("[testenv]\npackage=skip\ndeps=setuptools\n")
result_second = proj.run("r")
result_second.assert_success()
assert "py: recreate env because requirements removed: wheel" in result_second.out, result_second.out
assert execute_calls.call_count == 2
def test_pkg_dep_remove_recreate(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
build = (demo_pkg_inline / "build.py").read_text()
build_with_dep = build.replace("Summary: UNKNOWN\n", "Summary: UNKNOWN\n Requires-Dist: wheel\n")
proj = tox_project(
{
"tox.ini": "[testenv]\npackage=wheel",
"pyproject.toml": (demo_pkg_inline / "pyproject.toml").read_text(),
"build.py": build_with_dep,
},
)
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result_first = proj.run("r")
result_first.assert_success()
run_ids = [i[0][3].run_id for i in execute_calls.call_args_list]
assert run_ids == [
"_optional_hooks",
"get_requires_for_build_wheel",
"build_wheel",
"install_package_deps",
"install_package",
"_exit",
]
execute_calls.reset_mock()
(proj.path / "build.py").write_text(build)
result_second = proj.run("r")
result_second.assert_success()
assert "py: recreate env because dependencies removed: wheel" in result_second.out, result_second.out
run_ids = [i[0][3].run_id for i in execute_calls.call_args_list]
assert run_ids == ["_optional_hooks", "get_requires_for_build_wheel", "build_wheel", "install_package", "_exit"]
def test_pkg_env_dep_remove_recreate(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
toml = (demo_pkg_inline / "pyproject.toml").read_text()
proj = tox_project(
{
"tox.ini": "[testenv]\npackage=wheel",
"pyproject.toml": toml.replace("requires = [\n]", 'requires = ["setuptools"]'),
"build.py": (demo_pkg_inline / "build.py").read_text(),
},
)
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result_first = proj.run("r")
result_first.assert_success()
run_ids = [i[0][3].run_id for i in execute_calls.call_args_list]
assert run_ids == [
"install_requires",
"_optional_hooks",
"get_requires_for_build_wheel",
"build_wheel",
"install_package",
"_exit",
]
execute_calls.reset_mock()
(proj.path / "pyproject.toml").write_text(toml)
result_second = proj.run("r")
result_second.assert_success()
assert ".pkg: recreate env because dependencies removed: setuptools" in result_second.out, result_second.out
run_ids = [i[0][3].run_id for i in execute_calls.call_args_list]
assert run_ids == ["_optional_hooks", "get_requires_for_build_wheel", "build_wheel", "install_package", "_exit"]
def test_pip_install_requirements_file_deps(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv]\ndeps=-r r.txt\nskip_install=true", "r.txt": "a"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r")
result.assert_success()
assert execute_calls.call_count == 1
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", "-r", "r.txt"]
# check that adding a new dependency correctly finds the previous one
(proj.path / "tox.ini").write_text("[testenv]\ndeps=-r r.txt\n b\nskip_install=true")
execute_calls.reset_mock()
result_second = proj.run("r")
result_second.assert_success()
assert execute_calls.call_count == 1
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", "b", "-r", "r.txt"]
# if the requirement file changes recreate
(proj.path / "r.txt").write_text("c\nd")
execute_calls.reset_mock()
result_third = proj.run("r")
result_third.assert_success()
assert "py: recreate env because requirements removed: a" in result_third.out, result_third.out
assert execute_calls.call_count == 1
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", "b", "-r", "r.txt"]
def test_pip_install_constraint_file_create_change(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv]\ndeps=-c c.txt\n a\nskip_install=true", "c.txt": "b"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r")
result.assert_success()
assert execute_calls.call_count == 1
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", "a", "-c", "c.txt"]
# a new dependency triggers an install
(proj.path / "tox.ini").write_text("[testenv]\ndeps=-c c.txt\n a\n d\nskip_install=true")
execute_calls.reset_mock()
result_second = proj.run("r")
result_second.assert_success()
assert execute_calls.call_count == 1
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", "a", "d", "-c", "c.txt"]
# a new constraints triggers a recreate
(proj.path / "c.txt").write_text("")
execute_calls.reset_mock()
result_third = proj.run("r")
result_third.assert_success()
assert "py: recreate env because changed constraint(s) removed b" in result_third.out, result_third.out
assert execute_calls.call_count == 1
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", "a", "d", "-c", "c.txt"]
def test_pip_install_constraint_file_new(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv]\ndeps=a\nskip_install=true"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r")
result.assert_success()
assert execute_calls.call_count == 1
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", "a"]
(proj.path / "c.txt").write_text("a")
(proj.path / "tox.ini").write_text("[testenv]\ndeps=a\n -c c.txt\nskip_install=true")
execute_calls.reset_mock()
result_second = proj.run("r")
result_second.assert_success()
assert "py: recreate env because changed constraint(s) added a" in result_second.out, result_second.out
assert execute_calls.call_count == 1
assert execute_calls.call_args[0][3].cmd == ["python", "-I", "-m", "pip", "install", "a", "-c", "c.txt"]
@pytest.fixture(params=[True, False])
def constrain_package_deps(request: SubRequest) -> bool:
return bool(request.param)
@pytest.fixture(params=[True, False])
def use_frozen_constraints(request: SubRequest) -> bool:
return bool(request.param)
@pytest.fixture(
params=[
"explicit",
"requirements",
"constraints",
"explicit+requirements",
"requirements_indirect",
"requirements_constraints_indirect",
],
)
def constrained_mock_project(
request: SubRequest,
tox_project: ToxProjectCreator,
demo_pkg_inline: Path,
constrain_package_deps: bool,
use_frozen_constraints: bool,
) -> tuple[ToxProject, list[str]]:
toml = (demo_pkg_inline / "pyproject.toml").read_text()
files = {
"pyproject.toml": toml.replace("requires = [\n]", 'requires = ["setuptools"]')
+ '\n[project]\nname = "demo"\nversion = "0.1"\ndependencies = ["foo > 2"]',
"build.py": (demo_pkg_inline / "build.py").read_text(),
}
exp_constraints: list[str] = []
requirement = "foo==1.2.3"
constraint = "foo<2"
if request.param == "explicit":
deps = requirement
exp_constraints.append(requirement)
elif request.param == "requirements":
files["requirements.txt"] = f"--pre\n{requirement}"
deps = "-rrequirements.txt"
exp_constraints.append(requirement)
elif request.param == "constraints":
files["constraints.txt"] = constraint
deps = "-cconstraints.txt"
exp_constraints.append(constraint)
elif request.param == "explicit+requirements":
files["requirements.txt"] = f"--pre\n{requirement}"
deps = "\n\t-rrequirements.txt\n\tfoo"
exp_constraints.extend(["foo", requirement])
elif request.param == "requirements_indirect":
files["foo.requirements.txt"] = f"--pre\n{requirement}"
files["requirements.txt"] = "-r foo.requirements.txt"
deps = "-rrequirements.txt"
exp_constraints.append(requirement)
elif request.param == "requirements_constraints_indirect":
files["foo.requirements.txt"] = f"--pre\n{requirement}"
files["foo.constraints.txt"] = f"{constraint}"
files["requirements.txt"] = "-r foo.requirements.txt\n-c foo.constraints.txt"
deps = "-rrequirements.txt"
exp_constraints.extend([requirement, constraint])
else: # pragma: no cover
pytest.fail(f"Missing case: {request.param}")
files["tox.ini"] = (
"[testenv]\npackage=wheel\n"
f"constrain_package_deps = {constrain_package_deps}\n"
f"use_frozen_constraints = {use_frozen_constraints}\n"
f"deps = {deps}"
)
return tox_project(files), exp_constraints if constrain_package_deps else []
def test_constrain_package_deps(
constrained_mock_project: tuple[ToxProject, list[str]],
constrain_package_deps: bool,
use_frozen_constraints: bool,
) -> None:
proj, exp_constraints = constrained_mock_project
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result_first = proj.run("r")
result_first.assert_success()
exp_run_ids = ["install_deps"]
if constrain_package_deps and use_frozen_constraints:
exp_run_ids.append("freeze")
exp_run_ids.extend(
[
"install_requires",
"_optional_hooks",
"get_requires_for_build_wheel",
"build_wheel",
"install_package_deps",
"install_package",
"_exit",
],
)
run_ids = [i[0][3].run_id for i in execute_calls.call_args_list]
assert run_ids == exp_run_ids
constraints_file = proj.path / ".tox" / "py" / "constraints.txt"
if constrain_package_deps:
constraints = constraints_file.read_text().splitlines()
for call in execute_calls.call_args_list:
if call[0][3].run_id == "install_package_deps":
assert f"-c{constraints_file}" in call[0][3].cmd
if use_frozen_constraints:
for c in exp_constraints:
# when using frozen constraints with this mock, the mock package does NOT
# actually end up in the constraints, so assert it's not there
assert c not in constraints
for c in constraints:
assert c.partition("==")[0] in {"pip", "setuptools", "wheel"}
else:
for c in constraints:
assert c in exp_constraints
for c in exp_constraints:
assert c in constraints
else:
assert not constraints_file.exists()
@pytest.mark.parametrize("conf_key", ["constrain_package_deps", "use_frozen_constraints"])
def test_change_constraint_options_recreates(tox_project: ToxProjectCreator, conf_key: str) -> None:
tox_ini_content = "[testenv:py]\ndeps=a\nskip_install=true"
proj = tox_project({"tox.ini": f"{tox_ini_content}\n{conf_key} = true"})
proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r")
result.assert_success()
(proj.path / "tox.ini").write_text(f"{tox_ini_content}\n{conf_key} = false")
result_second = proj.run("r")
result_second.assert_success()
assert "recreate env because constraint options changed" in result_second.out
assert conf_key in result_second.out
tox-4.13.0/tests/tox_env/python/pip/test_req_file.py 0000664 0000000 0000000 00000005206 14564001166 0022553 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from argparse import Namespace
from typing import TYPE_CHECKING
import pytest
from tox.tox_env.python.pip.req_file import PythonDeps
if TYPE_CHECKING:
from pathlib import Path
@pytest.mark.parametrize("legacy_flag", ["-r", "-c"])
def test_legacy_requirement_file(tmp_path: Path, legacy_flag: str) -> None:
python_deps = PythonDeps(f"{legacy_flag}a.txt", tmp_path)
(tmp_path / "a.txt").write_text("b")
assert python_deps.as_root_args == [legacy_flag, "a.txt"]
assert vars(python_deps.options) == {}
assert [str(i) for i in python_deps.requirements] == ["b" if legacy_flag == "-r" else "-c b"]
def test_deps_with_hash(tmp_path: Path) -> None:
"""deps with --hash should raise an exception."""
python_deps = PythonDeps(
raw="foo==1 --hash sha256:97a702083b0d906517b79672d8501eee470d60ae55df0fa9d4cfba56c7f65a82",
root=tmp_path,
)
with pytest.raises(ValueError, match="Cannot use --hash in deps list"):
_ = python_deps.requirements
def test_deps_with_requirements_with_hash(tmp_path: Path) -> None:
"""deps can point to a requirements file that has --hash."""
exp_hash = "sha256:97a702083b0d906517b79672d8501eee470d60ae55df0fa9d4cfba56c7f65a82"
requirements = tmp_path / "requirements.txt"
requirements.write_text(f"foo==1 --hash {exp_hash}")
python_deps = PythonDeps(raw="-r requirements.txt", root=tmp_path)
assert len(python_deps.requirements) == 1
parsed_req = python_deps.requirements[0]
assert str(parsed_req.requirement) == "foo==1"
assert parsed_req.options == {"hash": [exp_hash]}
assert parsed_req.from_file == str(requirements)
def test_deps_with_no_deps(tmp_path: Path) -> None:
(tmp_path / "r.txt").write_text("urrlib3")
python_deps = PythonDeps(raw="-rr.txt\n--no-deps", root=tmp_path)
assert len(python_deps.requirements) == 1
parsed_req = python_deps.requirements[0]
assert str(parsed_req.requirement) == "urrlib3"
assert python_deps.options.no_deps is True
assert python_deps.as_root_args == ["-r", "r.txt", "--no-deps"]
def test_req_with_no_deps(tmp_path: Path) -> None:
(tmp_path / "r.txt").write_text("--no-deps")
python_deps = PythonDeps(raw="-rr.txt", root=tmp_path)
with pytest.raises(ValueError, match="unrecognized arguments: --no-deps"):
python_deps.requirements # noqa: B018
def test_opt_only_req_file(tmp_path: Path) -> None:
(tmp_path / "r.txt").write_text("--use-feature fast-deps")
python_deps = PythonDeps(raw="-rr.txt", root=tmp_path)
assert not python_deps.requirements
assert python_deps.options == Namespace(features_enabled=["fast-deps"])
tox-4.13.0/tests/tox_env/python/test-pkg/ 0000775 0000000 0000000 00000000000 14564001166 0020317 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/tox_env/python/test-pkg/pyproject.toml 0000664 0000000 0000000 00000000010 14564001166 0023222 0 ustar 00root root 0000000 0000000 # empty
tox-4.13.0/tests/tox_env/python/test_python_api.py 0000664 0000000 0000000 00000025716 14564001166 0022357 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from typing import TYPE_CHECKING, Callable
from unittest.mock import patch
import pytest
from tox.tox_env.errors import Fail
from tox.tox_env.python.api import Python
if TYPE_CHECKING:
from pathlib import Path
from pytest_mock import MockerFixture
from tox.pytest import ToxProjectCreator
def test_requirements_txt(tox_project: ToxProjectCreator) -> None:
prj = tox_project(
{
"tox.ini": "[testenv]\npackage=skip\ndeps=-rrequirements.txt",
"requirements.txt": "nose",
},
)
execute_calls = prj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = prj.run("r", "-e", "py")
result.assert_success()
assert execute_calls.call_count == 1
exp = ["python", "-I", "-m", "pip", "install", "-r", "requirements.txt"]
got_cmd = execute_calls.call_args[0][3].cmd
assert got_cmd == exp
def test_conflicting_base_python_factor() -> None:
major, minor = sys.version_info[0:2]
name = f"py{major}{minor}-py{major}{minor - 1}"
with pytest.raises(ValueError, match=f"conflicting factors py{major}{minor}, py{major}{minor - 1} in {name}"):
Python.extract_base_python(name)
def test_build_wheel_in_non_base_pkg_env(
tox_project: ToxProjectCreator,
patch_prev_py: Callable[[bool], tuple[str, str]],
demo_pkg_inline: Path,
mocker: MockerFixture,
) -> None:
mocker.patch("tox.tox_env.python.virtual_env.api.session_via_cli")
prev_ver, impl = patch_prev_py(True)
prev_py = f"py{prev_ver}"
prj = tox_project({"tox.ini": f"[tox]\nenv_list= {prev_py}\n[testenv]\npackage=wheel"})
execute_calls = prj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = prj.run("-r", "--root", str(demo_pkg_inline))
result.assert_success()
calls = [(i[0][0].conf.name, i[0][3].run_id) for i in execute_calls.call_args_list]
assert calls == [
(f".pkg-{impl}{prev_ver}", "_optional_hooks"),
(f".pkg-{impl}{prev_ver}", "get_requires_for_build_wheel"),
(f".pkg-{impl}{prev_ver}", "build_wheel"),
(f"py{prev_ver}", "install_package"),
(f".pkg-{impl}{prev_ver}", "_exit"),
]
def test_diff_msg_added_removed_changed() -> None:
before = {"A": "1", "F": "8", "C": "3", "D": "4", "E": "6"}
after = {"G": "9", "B": "2", "C": "3", "D": "5", "E": "7"}
expected = "python added A='1' | F='8', removed G='9' | B='2', changed D='5'->'4' | E='7'->'6'"
assert Python._diff_msg(before, after) == expected # noqa: SLF001
def test_diff_msg_no_diff() -> None:
assert Python._diff_msg({}, {}) == "python " # noqa: SLF001
@pytest.mark.parametrize(
("env", "base_python"),
[
("py3", "py3"),
("py311", "py311"),
("py3.12", "py3.12"),
("pypy2", "pypy2"),
("rustpython3", "rustpython3"),
("cpython3.8", "cpython3.8"),
("ironpython2.7", "ironpython2.7"),
("functional-py310", "py310"),
("bar-pypy2-foo", "pypy2"),
("py", None),
("django-32", None),
("eslint-8.3", None),
("py-310", None),
("py3000", None),
("4.foo", None),
("310", None),
("5", None),
("2000", None),
("4000", None),
],
ids=lambda a: "|".join(a) if isinstance(a, list) else str(a),
)
def test_extract_base_python(env: str, base_python: str | None) -> None:
result = Python.extract_base_python(env)
assert result == base_python
@pytest.mark.parametrize("ignore_conflict", [True, False])
@pytest.mark.parametrize(
("env", "base_python"),
[
("magic", ["pypy"]),
("magic", ["py39"]),
],
ids=lambda a: "|".join(a) if isinstance(a, list) else str(a),
)
def test_base_python_env_no_conflict(env: str, base_python: list[str], ignore_conflict: bool) -> None:
result = Python._validate_base_python(env, base_python, ignore_conflict) # noqa: SLF001
assert result is base_python
@pytest.mark.parametrize("ignore_conflict", [True, False])
@pytest.mark.parametrize(
("env", "base_python", "expected", "conflict"),
[
("pypy", ["cpython"], "pypy", ["cpython"]),
("pypy2", ["pypy3"], "pypy2", ["pypy3"]),
("py3", ["py2"], "py3", ["py2"]),
("py38", ["py39"], "py38", ["py39"]),
("py38", ["py38", "py39"], "py38", ["py39"]),
("py38", ["python3"], "py38", ["python3"]),
("py310", ["py38", "py39"], "py310", ["py38", "py39"]),
("py3.11", ["py310"], "py3.11", ["py310"]),
("py310-magic", ["py39"], "py310", ["py39"]),
],
ids=lambda a: "|".join(a) if isinstance(a, list) else str(a),
)
def test_base_python_env_conflict(
env: str,
base_python: list[str],
expected: str,
conflict: list[str],
ignore_conflict: bool,
) -> None:
if ignore_conflict:
result = Python._validate_base_python(env, base_python, ignore_conflict) # noqa: SLF001
assert result == [expected]
else:
msg = f"env name {env} conflicting with base python {conflict[0]}"
with pytest.raises(Fail, match=msg):
Python._validate_base_python(env, base_python, ignore_conflict) # noqa: SLF001
@pytest.mark.parametrize("ignore_conflict", [True, False, None])
def test_base_python_env_conflict_show_conf(tox_project: ToxProjectCreator, ignore_conflict: bool) -> None:
py_ver = "".join(str(i) for i in sys.version_info[0:2])
py_ver_next = "".join(str(i) for i in (sys.version_info[0], sys.version_info[1] + 2))
ini = f"[testenv]\npackage=skip\nbase_python=py{py_ver_next}"
if ignore_conflict is not None:
ini += f"\n[tox]\nignore_base_python_conflict={ignore_conflict}"
project = tox_project({"tox.ini": ini})
result = project.run("c", "-e", f"py{py_ver}", "-k", "base_python")
result.assert_success()
if ignore_conflict:
out = f"[testenv:py{py_ver}]\nbase_python = py{py_ver}\n"
else:
comma_in_exc = sys.version_info[0:2] <= (3, 6)
out = (
f"[testenv:py{py_ver}]\nbase_python = # Exception: Fail('env name py{py_ver} conflicting with"
f" base python py{py_ver_next}'{',' if comma_in_exc else ''})\n"
)
result.assert_out_err(out, "")
def test_python_set_hash_seed(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\npackage=skip\ncommands=python -c 'import os; print(os.environ[\"PYTHONHASHSEED\"])'"
prj = tox_project({"tox.ini": ini})
result = prj.run("r", "-e", "py", "--hashseed", "10")
result.assert_success()
assert result.out.splitlines()[1] == "10"
def test_python_generate_hash_seed(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\npackage=skip\ncommands=python -c 'import os; print(os.environ[\"PYTHONHASHSEED\"])'"
prj = tox_project({"tox.ini": ini})
result = prj.run("r", "-e", "py")
result.assert_success()
assert 1 <= int(result.out.splitlines()[1]) <= (1024 if sys.platform == "win32" else 4294967295)
def test_python_keep_hash_seed(tox_project: ToxProjectCreator) -> None:
ini = """
[testenv]
package=skip
set_env=PYTHONHASHSEED=12
commands=python -c 'import os; print(os.environ["PYTHONHASHSEED"])'
"""
result = tox_project({"tox.ini": ini}).run("r", "-e", "py")
result.assert_success()
assert result.out.splitlines()[1] == "12"
def test_python_disable_hash_seed(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\npackage=skip\ncommands=python -c 'import os; print(os.environ.get(\"PYTHONHASHSEED\"))'"
prj = tox_project({"tox.ini": ini})
result = prj.run("r", "-e", "py", "--hashseed", "notset")
result.assert_success()
assert result.out.splitlines()[1] == "None"
def test_python_set_hash_seed_negative(tox_project: ToxProjectCreator) -> None:
result = tox_project({"tox.ini": ""}).run("r", "-e", "py", "--hashseed", "-1")
result.assert_failed(2)
assert "tox run: error: argument --hashseed: must be greater than zero" in result.err
def test_python_set_hash_seed_incorrect(tox_project: ToxProjectCreator) -> None:
result = tox_project({"tox.ini": ""}).run("r", "-e", "py", "--hashseed", "ok")
result.assert_failed(2)
assert "tox run: error: argument --hashseed: invalid literal for int() with base 10: 'ok'" in result.err
def test_python_use_hash_seed_from_env(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\npackage=skip"
with patch.dict("os.environ", {"PYTHONHASHSEED": "13"}):
result = tox_project({"tox.ini": ini}).run("c", "-e", "py", "-k", "setenv")
result.assert_success()
assert "PYTHONHASHSEED=13" in result.out
def test_python_hash_seed_from_env_random(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\npackage=skip"
with patch.dict("os.environ", {"PYTHONHASHSEED": "random"}):
result = tox_project({"tox.ini": ini}).run("c", "-e", "py", "-k", "setenv")
result.assert_success()
assert "PYTHONHASHSEED=" in result.out
def test_python_hash_seed_from_env_and_override(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\npackage=skip\ncommands=python -c 'import os; print(os.environ.get(\"PYTHONHASHSEED\"))'"
with patch.dict("os.environ", {"PYTHONHASHSEED": "14"}):
result = tox_project({"tox.ini": ini}).run("r", "-e", "py", "--hashseed", "15")
result.assert_success()
assert result.out.splitlines()[1] == "15"
def test_python_hash_seed_from_env_and_disable(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\npackage=skip\ncommands=python -c 'import os; print(os.environ.get(\"PYTHONHASHSEED\"))'"
with patch.dict("os.environ", {"PYTHONHASHSEED": "16"}):
result = tox_project({"tox.ini": ini}).run("r", "-e", "py", "--hashseed", "notset")
result.assert_success()
assert result.out.splitlines()[1] == "None"
@pytest.mark.parametrize("in_ci", [True, False])
def test_list_installed_deps(in_ci: bool, tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
mocker.patch("tox.session.cmd.run.common.is_ci", return_value=in_ci)
result = tox_project({"tox.ini": "[testenv]\nskip_install = true"}).run("r", "-e", "py")
if in_ci:
assert "pip==" in result.out
else:
assert "pip==" not in result.out
@pytest.mark.parametrize("list_deps", ["--list-dependencies", "--no-list-dependencies"])
@pytest.mark.parametrize("in_ci", [True, False])
def test_list_installed_deps_explicit_cli(
list_deps: str,
in_ci: bool,
tox_project: ToxProjectCreator,
mocker: MockerFixture,
) -> None:
mocker.patch("tox.session.cmd.run.common.is_ci", return_value=in_ci)
result = tox_project({"tox.ini": "[testenv]\nskip_install = true"}).run(list_deps, "r", "-e", "py")
if list_deps == "--list-dependencies":
assert "pip==" in result.out
else:
assert "pip==" not in result.out
def test_usedevelop_with_nonexistent_basepython(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\nusedevelop = true\n[testenv:unused]\nbasepython = /nonexistent/bin/python"
project = tox_project({"tox.ini": ini})
result = project.run()
assert result.code == 0
tox-4.13.0/tests/tox_env/python/test_python_runner.py 0000664 0000000 0000000 00000012656 14564001166 0023116 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from pathlib import Path
from typing import TYPE_CHECKING
import pytest
from tox.journal import EnvJournal
from tox.tox_env.package import PathPackage
from tox.tox_env.python.runner import PythonRun
if TYPE_CHECKING:
from tox.pytest import ToxProjectCreator
def test_deps_config_path_req(tox_project: ToxProjectCreator) -> None:
project = tox_project(
{
"tox.ini": "[testenv:py]\ndeps =-rpath.txt\n -r {toxinidir}{/}path2.txt\n pytest",
"path.txt": "alpha",
"path2.txt": "beta",
},
)
result = project.run("c", "-e", "py")
result.assert_success()
deps = result.state.conf.get_env("py")["deps"]
assert deps.unroll() == ([], ["alpha", "beta", "pytest"])
assert deps.as_root_args == ["pytest", "-r", "path.txt", "-r", str(project.path / "path2.txt")]
assert str(deps) == f"-r {project.path / 'tox.ini'}"
def test_journal_package_empty() -> None:
journal = EnvJournal(enabled=True, name="a")
PythonRun._handle_journal_package(journal, []) # noqa: SLF001
content = journal.content
assert content == {}
def test_journal_one_wheel_file(tmp_path: Path) -> None:
wheel = tmp_path / "a.whl"
wheel.write_bytes(b"magical")
journal = EnvJournal(enabled=True, name="a")
PythonRun._handle_journal_package(journal, [PathPackage(wheel)]) # noqa: SLF001
content = journal.content
assert content == {
"installpkg": {
"basename": "a.whl",
"sha256": "0ce2d4c7087733c06b1087b28db95e114d7caeb515b841c6cdec8960cf884654",
"type": "file",
},
}
def test_journal_multiple_wheel_file(tmp_path: Path) -> None:
wheel_1 = tmp_path / "a.whl"
wheel_1.write_bytes(b"magical")
wheel_2 = tmp_path / "b.whl"
wheel_2.write_bytes(b"magic")
journal = EnvJournal(enabled=True, name="a")
PythonRun._handle_journal_package(journal, [PathPackage(wheel_1), PathPackage(wheel_2)]) # noqa: SLF001
content = journal.content
assert content == {
"installpkg": [
{
"basename": "a.whl",
"sha256": "0ce2d4c7087733c06b1087b28db95e114d7caeb515b841c6cdec8960cf884654",
"type": "file",
},
{
"basename": "b.whl",
"sha256": "3be7a505483c0050243c5cbad4700da13925aa4137a55e9e33efd8bc4d05850f",
"type": "file",
},
],
}
def test_journal_package_dir(tmp_path: Path) -> None:
journal = EnvJournal(enabled=True, name="a")
PythonRun._handle_journal_package(journal, [PathPackage(tmp_path)]) # noqa: SLF001
content = journal.content
assert content == {
"installpkg": {
"basename": tmp_path.name,
"type": "dir",
},
}
def test_package_temp_dir_view(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
project = tox_project({"tox.ini": "[testenv]\npackage=wheel"})
result = project.run(
"r",
"-vv",
"-e",
"py",
"--root",
str(demo_pkg_inline),
"--workdir",
str(project.path / ".tox"),
)
result.assert_success()
wheel_name = "demo_pkg_inline-1.0.0-py3-none-any.whl"
session_path = Path(".tmp") / "package" / "1" / wheel_name
msg = f" D package {session_path} links to {Path('.pkg') / 'dist' / wheel_name} ({project.path / '.tox'}) "
assert msg in result.out
assert f" D delete package {project.path / '.tox' / session_path}" in result.out
@pytest.mark.parametrize(
("extra", "used_extra"),
[
("d_oc", "d-oc"),
("d-oc", "d-oc"),
("d.oc", "d-oc"),
],
)
def test_extras_are_normalized(
tox_project: ToxProjectCreator,
demo_pkg_inline: Path,
extra: str,
used_extra: str,
) -> None:
project = tox_project({"tox.ini": f"[testenv]\nextras={extra}"})
result = project.run("c", "-e", "py", "--root", str(demo_pkg_inline), "-k", "extras")
result.assert_success()
assert result.out == f"[testenv:py]\nextras = {used_extra}\n"
@pytest.mark.parametrize(
("config", "cli", "expected"),
[("false", "true", True), ("true", "false", False), ("false", "config", False), ("true", "config", True)],
)
def test_config_skip_missing_interpreters(
tox_project: ToxProjectCreator,
config: str,
cli: str,
expected: bool,
) -> None:
py_ver = ".".join(str(i) for i in sys.version_info[0:2])
project = tox_project({"tox.ini": f"[tox]\nenvlist=py4,py{py_ver}\nskip_missing_interpreters={config}"})
result = project.run(f"--skip-missing-interpreters={cli}")
assert result.code == (0 if expected else -1)
@pytest.mark.parametrize(
("skip", "env", "retcode"),
[
("true", f"py{''.join(str(i) for i in sys.version_info[0:2])}", 0),
("false", f"py{''.join(str(i) for i in sys.version_info[0:2])}", 0),
("true", "py31", -1),
("false", "py31", 1),
("true", None, 0),
("false", None, -1),
],
)
def test_skip_missing_interpreters_specified_env(
tox_project: ToxProjectCreator,
skip: str,
env: str | None,
retcode: int,
) -> None:
py_ver = "".join(str(i) for i in sys.version_info[0:2])
project = tox_project({"tox.ini": f"[tox]\nenvlist=py31,py{py_ver}\n[testenv]\nusedevelop=true"})
args = [f"--skip-missing-interpreters={skip}"]
if env:
args += ["-e", env]
result = project.run(*args)
assert result.code == retcode
tox-4.13.0/tests/tox_env/python/virtual_env/ 0000775 0000000 0000000 00000000000 14564001166 0021117 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/tox_env/python/virtual_env/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0023216 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/tox_env/python/virtual_env/package/ 0000775 0000000 0000000 00000000000 14564001166 0022512 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/tox_env/python/virtual_env/package/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0024611 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/tox_env/python/virtual_env/package/conftest.py 0000664 0000000 0000000 00000002234 14564001166 0024712 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from textwrap import dedent
from typing import TYPE_CHECKING
import pytest
if TYPE_CHECKING:
from pathlib import Path
@pytest.fixture(scope="session")
def pkg_with_extras_project(tmp_path_factory: pytest.TempPathFactory) -> Path:
py_ver = ".".join(str(i) for i in sys.version_info[0:2])
setup_cfg = f"""
[metadata]
name = demo
version = 1.0.0
[options]
packages = find:
install_requires =
platformdirs>=2.1
colorama>=0.4.3
[options.extras_require]
testing =
covdefaults>=1.2; python_version == '2.7' or python_version == '{py_ver}'
pytest>=5.4.1; python_version == '{py_ver}'
docs =
sphinx>=3
sphinx-rtd-theme>=0.4.3,<1
format =
black>=3
flake8
"""
tmp_path = tmp_path_factory.mktemp("prj")
(tmp_path / "setup.cfg").write_text(dedent(setup_cfg))
(tmp_path / "setup.py").write_text("from setuptools import setup; setup()")
toml = '[build-system]\nrequires=["setuptools", "wheel"]\nbuild-backend = "setuptools.build_meta"'
(tmp_path / "pyproject.toml").write_text(toml)
return tmp_path
tox-4.13.0/tests/tox_env/python/virtual_env/package/test_package_cmd_builder.py 0000664 0000000 0000000 00000016017 14564001166 0030054 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING, Callable
from zipfile import ZipFile
import pytest
if TYPE_CHECKING:
from pathlib import Path
from tox.pytest import ToxProjectCreator
@pytest.fixture(scope="session")
def pkg_with_extras_project_wheel(
pkg_with_extras_project: Path,
pkg_builder: Callable[[Path, Path, list[str], bool], Path],
) -> Path:
dist = pkg_with_extras_project / "dist"
pkg_builder(dist, pkg_with_extras_project, ["wheel"], False)
return next(dist.iterdir())
def test_tox_install_pkg_wheel(tox_project: ToxProjectCreator, pkg_with_extras_project_wheel: Path) -> None:
proj = tox_project({"tox.ini": "[testenv]\nextras=docs,format"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "-e", "py", "--installpkg", str(pkg_with_extras_project_wheel))
result.assert_success()
calls = [(i[0][0].conf.name, i[0][3].run_id, i[0][3].cmd[5:]) for i in execute_calls.call_args_list]
deps = ["black>=3", "colorama>=0.4.3", "flake8", "platformdirs>=2.1", "sphinx-rtd-theme<1,>=0.4.3", "sphinx>=3"]
expected = [
("py", "install_package_deps", deps),
("py", "install_package", ["--force-reinstall", "--no-deps", str(pkg_with_extras_project_wheel)]),
]
assert calls == expected
@pytest.fixture(scope="session")
def pkg_with_sdist(
pkg_with_extras_project: Path,
pkg_builder: Callable[[Path, Path, list[str], bool], Path],
) -> Path:
dist = pkg_with_extras_project / "dist"
pkg_builder(dist, pkg_with_extras_project, ["sdist"], False)
return next(dist.iterdir())
@pytest.fixture()
def pkg_with_extras_project_sdist(
pkg_with_extras_project: Path,
pkg_builder: Callable[[Path, Path, list[str], bool], Path],
) -> Path:
dist = pkg_with_extras_project / "sdist"
pkg_builder(dist, pkg_with_extras_project, ["sdist"], False)
return next(dist.iterdir())
def test_tox_install_pkg_sdist(tox_project: ToxProjectCreator, pkg_with_extras_project_sdist: Path) -> None:
proj = tox_project({"tox.ini": "[testenv]\nextras=docs,format"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "-e", "py", "--installpkg", str(pkg_with_extras_project_sdist))
result.assert_success()
calls = [(i[0][0].conf.name, i[0][3].run_id, i[0][3].cmd[5:]) for i in execute_calls.call_args_list]
deps = ["black>=3", "colorama>=0.4.3", "flake8", "platformdirs>=2.1", "sphinx-rtd-theme<1,>=0.4.3", "sphinx>=3"]
assert calls == [
(".pkg_external_sdist_meta", "install_requires", ["setuptools", "wheel"]),
(".pkg_external_sdist_meta", "_optional_hooks", []),
(".pkg_external_sdist_meta", "get_requires_for_build_sdist", []),
(".pkg_external_sdist_meta", "get_requires_for_build_wheel", []), # required before prepare_metadata*
(".pkg_external_sdist_meta", "install_requires_for_build_wheel", ["wheel"]),
(".pkg_external_sdist_meta", "prepare_metadata_for_build_wheel", []),
("py", "install_package_deps", deps),
("py", "install_package", ["--force-reinstall", "--no-deps", str(pkg_with_extras_project_sdist)]),
(".pkg_external_sdist_meta", "_exit", []),
]
@pytest.mark.parametrize("mode", ["p", "le"]) # no need for r as is tested above
def test_install_pkg_via(tox_project: ToxProjectCreator, mode: str, pkg_with_extras_project_wheel: Path) -> None:
proj = tox_project({"tox.ini": "[testenv]\npackage=wheel"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run(mode, "--installpkg", str(pkg_with_extras_project_wheel))
result.assert_success()
calls = [(i[0][0].conf.name, i[0][3].run_id) for i in execute_calls.call_args_list]
assert calls == [("py", "install_package_deps"), ("py", "install_package")]
@pytest.mark.usefixtures("enable_pip_pypi_access")
def test_build_wheel_external(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
ini = """
[testenv]
package = external
package_env = .ext
commands =
python -c 'from demo_pkg_inline import do; do()'
[testenv:.ext]
deps = build
package_glob = {envtmpdir}{/}dist{/}*.whl
commands =
pyproject-build -w . -o {envtmpdir}{/}dist
"""
project = tox_project({"tox.ini": ini})
result = project.run("r", "--root", str(demo_pkg_inline), "--workdir", str(project.path))
result.assert_success()
assert "greetings from demo_pkg_inline" in result.out
def test_build_wheel_external_fail_build(tox_project: ToxProjectCreator) -> None:
ini = """
[testenv]
package = external
[testenv:.pkg_external]
commands = xyz
"""
project = tox_project({"tox.ini": ini})
result = project.run("r")
result.assert_failed()
assert "stopping as failed to build package" in result.out, result.out
def test_build_wheel_external_fail_no_pkg(tox_project: ToxProjectCreator) -> None:
ini = """
[testenv]
package = external
"""
project = tox_project({"tox.ini": ini})
result = project.run("r")
result.assert_failed()
assert "failed with no package found in " in result.out, result.out
def test_build_wheel_external_fail_many_pkg(tox_project: ToxProjectCreator) -> None:
ini = """
[testenv]
package = external
[testenv:.pkg_external]
commands =
python -c 'from pathlib import Path; (Path(r"{env_tmp_dir}") / "dist").mkdir()'
python -c 'from pathlib import Path; (Path(r"{env_tmp_dir}") / "dist" / "a").write_text("")'
python -c 'from pathlib import Path; (Path(r"{env_tmp_dir}") / "dist" / "b").write_text("")'
"""
project = tox_project({"tox.ini": ini})
result = project.run("r")
result.assert_failed()
assert "failed with found more than one package " in result.out, result.out
def test_tox_install_pkg_bad_wheel(tox_project: ToxProjectCreator, tmp_path: Path) -> None:
wheel = tmp_path / "w.whl"
with ZipFile(str(wheel), "w"):
pass
proj = tox_project({"tox.ini": "[testenv]"})
result = proj.run("r", "-e", "py", "--installpkg", str(wheel))
result.assert_failed()
assert "failed with no .dist-info inside " in result.out, result.out
def test_tox_install_pkg_with_skip_install(
tox_project: ToxProjectCreator,
demo_pkg_inline: Path,
demo_pkg_inline_wheel: Path,
) -> None:
ini = "[testenv:foo]\nskip_install = true"
project = tox_project({"tox.ini": ini, "pyproject.toml": (demo_pkg_inline / "pyproject.toml").read_text()})
result = project.run("-e", "py", "--installpkg", str(demo_pkg_inline_wheel))
result.assert_success()
def test_run_installpkg_targz(
tox_project: ToxProjectCreator,
pkg_with_sdist: Path,
enable_pip_pypi_access: str | None, # noqa: ARG001
) -> None:
project = tox_project({
"tox.ini": """
[tox]
envlist = base, flake8
[testenv]
package = sdist
[testenv:base]
[testenv:flake8]
"""
})
outcome = project.run(f"--installpkg={pkg_with_sdist}")
outcome.assert_success()
tox-4.13.0/tests/tox_env/python/virtual_env/package/test_package_pyproject.py 0000664 0000000 0000000 00000040163 14564001166 0027621 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import json
from textwrap import dedent
from typing import TYPE_CHECKING
import pytest
from tox.execute.local_sub_process import LocalSubprocessExecuteStatus
from tox.tox_env.python.virtual_env.package.pyproject import Pep517VirtualEnvFrontend
if TYPE_CHECKING:
from pathlib import Path
from pytest_mock import MockerFixture
from tox.pytest import ToxProjectCreator
@pytest.mark.parametrize(
"pkg_type",
["editable-legacy", "editable", "sdist", "wheel"],
)
def test_tox_ini_package_type_valid(tox_project: ToxProjectCreator, pkg_type: str) -> None:
proj = tox_project({"tox.ini": f"[testenv]\npackage={pkg_type}", "pyproject.toml": ""})
result = proj.run("c", "-k", "package_tox_env_type")
result.assert_success()
res = result.env_conf("py")["package"]
assert res == pkg_type
got_type = result.env_conf("py")["package_tox_env_type"]
assert got_type == "virtualenv-pep-517"
def test_tox_ini_package_type_invalid(tox_project: ToxProjectCreator) -> None:
proj = tox_project({"tox.ini": "[testenv]\npackage=bad", "pyproject.toml": ""})
result = proj.run("c", "-k", "package_tox_env_type")
result.assert_failed()
msg = " invalid package config type bad requested, must be one of wheel, sdist, editable, editable-legacy, skip"
assert msg in result.out
def test_get_package_deps_different_extras(pkg_with_extras_project: Path, tox_project: ToxProjectCreator) -> None:
ini = "[testenv:a]\npackage=editable-legacy\nextras=docs\n[testenv:b]\npackage=sdist\nextras=format"
proj = tox_project({"tox.ini": ini})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "--root", str(pkg_with_extras_project), "-e", "a,b")
result.assert_success()
installs = {
i[0][0].conf.name: i[0][3].cmd[5:]
for i in execute_calls.call_args_list
if i[0][3].run_id.startswith("install_package_deps")
}
assert installs == {
"a": ["colorama>=0.4.3", "platformdirs>=2.1", "setuptools", "sphinx-rtd-theme<1,>=0.4.3", "sphinx>=3", "wheel"],
"b": ["black>=3", "colorama>=0.4.3", "flake8", "platformdirs>=2.1"],
}
def test_package_root_via_root(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
ini = f"[tox]\npackage_root={demo_pkg_inline}\n[testenv]\npackage=wheel\nwheel_build_env=.pkg"
proj = tox_project({"tox.ini": ini, "pyproject.toml": ""})
proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "--notest")
result.assert_success()
def test_package_root_via_testenv(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
ini = f"[testenv]\npackage=wheel\nwheel_build_env=.pkg\npackage_root={demo_pkg_inline}"
proj = tox_project({"tox.ini": ini, "pyproject.toml": ""})
proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "--notest")
result.assert_success()
@pytest.mark.parametrize(
("conf", "extra", "deps"),
[
pytest.param("[project]", "", [], id="no_deps"),
pytest.param("[project]", "alpha", [], id="no_deps_with_extra"),
pytest.param("[project]\ndependencies=['B', 'A']", "", ["A", "B"], id="deps"),
pytest.param(
"[project]\ndependencies=['A']\noptional-dependencies.alpha=['B']\noptional-dependencies.beta=['C']",
"alpha",
["A", "B"],
id="deps_with_one_extra",
),
pytest.param(
"[project]\ndependencies=['A']\noptional-dependencies.alpha=['B']\noptional-dependencies.beta=['C']",
"alpha,beta",
["A", "B", "C"],
id="deps_with_two_extra",
),
pytest.param(
"[project]\ndependencies=['A']\noptional-dependencies.alpha=[]",
"alpha,beta",
["A"],
id="deps_with_one_empty_extra",
),
pytest.param(
"[project]\ndependencies=['A']\ndynamic=['optional-dependencies']",
"",
["A"],
id="deps_with_dynamic_optional_no_extra",
),
pytest.param(
dedent(
"""
[project]
name='foo'
dependencies=['foo[alpha]']
optional-dependencies.alpha=['A']""",
),
"",
["A"],
id="deps_reference_extra",
),
pytest.param(
dedent(
"""
[project]
name='foo'
dependencies=['A']
optional-dependencies.alpha=['B']
optional-dependencies.beta=['foo[alpha]']""",
),
"beta",
["A", "B"],
id="deps_with_recursive_extra",
),
pytest.param(
dedent(
"""
[project]
name='foo'
dependencies=['A']
optional-dependencies.alpha=['B']
optional-dependencies.beta=['foo[alpha]']
optional-dependencies.delta=['foo[beta]', 'D']""",
),
"delta",
["A", "B", "D"],
id="deps_with_two_recursive_extra",
),
pytest.param(
dedent(
"""
[project]
name='foo'
optional-dependencies.alpha=['foo[beta]', 'A']
optional-dependencies.beta=['foo[alpha]', 'B']""",
),
"alpha",
["A", "B"],
id="deps_with_circular_recursive_extra",
),
],
)
def test_pyproject_deps_from_static(
tox_project: ToxProjectCreator,
demo_pkg_inline: Path,
conf: str,
extra: str,
deps: list[str],
) -> None:
toml = f"{(demo_pkg_inline / 'pyproject.toml').read_text()}{conf}"
proj = tox_project({"tox.ini": f"[testenv]\nextras={extra}", "pyproject.toml": toml}, base=demo_pkg_inline)
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "--notest")
result.assert_success()
expected_calls = [(".pkg", "_optional_hooks"), (".pkg", "get_requires_for_build_sdist"), (".pkg", "build_sdist")]
if deps:
expected_calls.append(("py", "install_package_deps"))
expected_calls.extend((("py", "install_package"), (".pkg", "_exit")))
found_calls = [(i[0][0].conf.name, i[0][3].run_id) for i in execute_calls.call_args_list]
assert found_calls == expected_calls
if deps:
expected_args = ["python", "-I", "-m", "pip", "install", *deps]
args = execute_calls.call_args_list[-3][0][3].cmd
assert expected_args == args
@pytest.mark.parametrize(
("metadata", "dynamic", "deps"),
[
pytest.param("Requires-Dist: A", "['dependencies']", ["A"], id="deps"),
pytest.param(
"Requires-Dist: A\nRequires-Dist: B;extra=='alpha'",
"['dependencies']",
["A", "B"],
id="deps_extra",
),
pytest.param(
"Requires-Dist: A\nRequires-Dist: B;extra=='alpha'",
"['optional-dependencies']",
["A", "B"],
id="deps_extra_dynamic_opt",
),
],
)
def test_pyproject_deps_static_with_dynamic( # noqa: PLR0913
tox_project: ToxProjectCreator,
demo_pkg_inline: Path,
monkeypatch: pytest.MonkeyPatch,
metadata: str,
dynamic: str,
deps: list[str],
) -> None:
monkeypatch.setenv("METADATA_EXTRA", metadata)
toml = f"{(demo_pkg_inline / 'pyproject.toml').read_text()}[project]\ndynamic={dynamic}"
ini = "[testenv]\nextras=alpha\n[testenv:.pkg]\npass_env=METADATA_EXTRA"
proj = tox_project({"tox.ini": ini, "pyproject.toml": toml}, base=demo_pkg_inline)
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "--notest")
result.assert_success()
expected_calls = [
(".pkg", "_optional_hooks"),
(".pkg", "get_requires_for_build_sdist"),
(".pkg", "get_requires_for_build_wheel"),
(".pkg", "build_wheel"),
(".pkg", "build_sdist"),
("py", "install_package_deps"),
("py", "install_package"),
(".pkg", "_exit"),
]
found_calls = [(i[0][0].conf.name, i[0][3].run_id) for i in execute_calls.call_args_list]
assert found_calls == expected_calls
args = execute_calls.call_args_list[-3][0][3].cmd
assert args == ["python", "-I", "-m", "pip", "install", *deps]
def test_pyproject_no_build_editable_fallback(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
proj = tox_project({"tox.ini": "[tox]\nenv_list=a,b"}, base=demo_pkg_inline)
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "-e", "a,b", "--notest", "--develop")
result.assert_success()
warning = (
".pkg: package config for a, b is editable, however the build backend build does not support PEP-660, "
"falling back to editable-legacy - change your configuration to it"
)
assert warning in result.out.splitlines()
expected_calls = [
(".pkg", "_optional_hooks"),
(".pkg", "get_requires_for_build_wheel"),
(".pkg", "build_wheel"),
(".pkg", "get_requires_for_build_sdist"),
("a", "install_package"),
("b", "install_package"),
(".pkg", "_exit"),
]
found_calls = [(i[0][0].conf.name, i[0][3].run_id) for i in execute_calls.call_args_list]
assert found_calls == expected_calls
@pytest.mark.parametrize("package", ["sdist", "wheel", "editable", "editable-legacy", "skip"])
def test_project_package_with_deps(tox_project: ToxProjectCreator, demo_pkg_setuptools: Path, package: str) -> None:
ini = f"[testenv]\npackage={package}\n[pkgenv]\ndeps = A"
proj = tox_project({"tox.ini": ini}, base=demo_pkg_setuptools)
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "--notest")
result.assert_success()
found_calls = [(i[0][0].conf.name, i[0][3].run_id) for i in execute_calls.call_args_list]
if package == "skip":
assert (".pkg", "install_deps") not in found_calls
else:
assert found_calls[0] == (".pkg", "install_requires")
assert found_calls[1] == (".pkg", "install_deps")
def test_pyproject_build_editable_and_wheel(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
# test that build wheel and build editable are cached separately
ini = """
[testenv:.pkg]
set_env= BACKEND_HAS_EDITABLE=1
[testenv:a,b]
package = editable
[testenv:c,d]
package = wheel
"""
proj = tox_project({"tox.ini": ini}, base=demo_pkg_inline)
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "-e", "a,b,c,d", "--notest", "--workdir", str(proj.path / ".tox"))
result.assert_success()
found_calls = [(i[0][0].conf.name, i[0][3].run_id) for i in execute_calls.call_args_list]
assert found_calls == [
(".pkg", "_optional_hooks"),
(".pkg", "get_requires_for_build_wheel"),
(".pkg", "build_editable"),
("a", "install_package"),
("b", "install_package"),
(".pkg", "build_wheel"),
("c", "install_package"),
("d", "install_package"),
(".pkg", "_exit"),
]
def test_pyproject_config_settings_sdist(
tox_project: ToxProjectCreator,
demo_pkg_setuptools: Path,
mocker: MockerFixture,
) -> None:
ini = """
[tox]
env_list = sdist
[testenv]
wheel_build_env = .pkg
package = sdist
[testenv:.pkg]
config_settings_get_requires_for_build_sdist = A = 1
config_settings_build_sdist = B = 2
config_settings_get_requires_for_build_wheel = C = 3
config_settings_prepare_metadata_for_build_wheel = D = 4
"""
proj = tox_project({"tox.ini": ini}, base=demo_pkg_setuptools)
proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
write_stdin = mocker.spy(LocalSubprocessExecuteStatus, "write_stdin")
result = proj.run("r", "--notest", from_cwd=proj.path)
result.assert_success()
found = {
message["cmd"]: message["kwargs"]["config_settings"]
for message in [json.loads(call[0][1]) for call in write_stdin.call_args_list]
if not message["cmd"].startswith("_")
}
assert found == {
"build_sdist": {"B": "2"},
"get_requires_for_build_sdist": {"A": "1"},
"get_requires_for_build_wheel": {"C": "3"},
"prepare_metadata_for_build_wheel": {"D": "4"},
}
def test_pyproject_config_settings_wheel(
tox_project: ToxProjectCreator,
demo_pkg_setuptools: Path,
mocker: MockerFixture,
) -> None:
ini = """
[tox]
env_list = wheel
[testenv]
wheel_build_env = .pkg
package = wheel
[testenv:.pkg]
config_settings_get_requires_for_build_wheel = C = 3
config_settings_prepare_metadata_for_build_wheel = D = 4
config_settings_build_wheel = E = 5
"""
proj = tox_project({"tox.ini": ini}, base=demo_pkg_setuptools)
proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
write_stdin = mocker.spy(LocalSubprocessExecuteStatus, "write_stdin")
mocker.patch.object(Pep517VirtualEnvFrontend, "_can_skip_prepare", return_value=False)
result = proj.run("r", "--notest", from_cwd=proj.path)
result.assert_success()
found = {
message["cmd"]: message["kwargs"]["config_settings"]
for message in [json.loads(call[0][1]) for call in write_stdin.call_args_list]
if not message["cmd"].startswith("_")
}
assert found == {
"get_requires_for_build_wheel": {"C": "3"},
"prepare_metadata_for_build_wheel": {"D": "4"},
"build_wheel": {"E": "5"},
}
def test_pyproject_config_settings_editable(
tox_project: ToxProjectCreator,
demo_pkg_setuptools: Path,
mocker: MockerFixture,
) -> None:
ini = """
[tox]
env_list = editable
[testenv:.pkg]
config_settings_get_requires_for_build_editable = F = 6
config_settings_prepare_metadata_for_build_editable = G = 7
config_settings_build_editable = H = 8
[testenv]
wheel_build_env = .pkg
package = editable
"""
proj = tox_project({"tox.ini": ini}, base=demo_pkg_setuptools)
proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
write_stdin = mocker.spy(LocalSubprocessExecuteStatus, "write_stdin")
mocker.patch.object(Pep517VirtualEnvFrontend, "_can_skip_prepare", return_value=False)
result = proj.run("r", "--notest", from_cwd=proj.path)
result.assert_success()
found = {
message["cmd"]: message["kwargs"]["config_settings"]
for message in [json.loads(call[0][1]) for call in write_stdin.call_args_list]
if not message["cmd"].startswith("_")
}
assert found == {
"get_requires_for_build_editable": {"F": "6"},
"prepare_metadata_for_build_editable": {"G": "7"},
"build_editable": {"H": "8"},
}
def test_pyproject_config_settings_editable_legacy(
tox_project: ToxProjectCreator,
demo_pkg_setuptools: Path,
mocker: MockerFixture,
) -> None:
ini = """
[tox]
env_list = editable
[testenv:.pkg]
config_settings_get_requires_for_build_sdist = A = 1
config_settings_get_requires_for_build_wheel = C = 3
config_settings_prepare_metadata_for_build_wheel = D = 4
[testenv]
wheel_build_env = .pkg
package = editable-legacy
"""
proj = tox_project({"tox.ini": ini}, base=demo_pkg_setuptools)
proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
write_stdin = mocker.spy(LocalSubprocessExecuteStatus, "write_stdin")
mocker.patch.object(Pep517VirtualEnvFrontend, "_can_skip_prepare", return_value=False)
result = proj.run("r", "--notest", from_cwd=proj.path)
result.assert_success()
found = {
message["cmd"]: message["kwargs"]["config_settings"]
for message in [json.loads(call[0][1]) for call in write_stdin.call_args_list]
if not message["cmd"].startswith("_")
}
assert found == {
"get_requires_for_build_sdist": {"A": "1"},
"get_requires_for_build_wheel": {"C": "3"},
"prepare_metadata_for_build_wheel": {"D": "4"},
}
tox-4.13.0/tests/tox_env/python/virtual_env/package/test_python_package_util.py 0000664 0000000 0000000 00000006353 14564001166 0030163 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import sys
from itertools import zip_longest
from typing import TYPE_CHECKING
import pytest
from packaging.requirements import Requirement
from pyproject_api import SubprocessFrontend
from tox.tox_env.python.virtual_env.package.util import dependencies_with_extras
if TYPE_CHECKING:
from pathlib import Path
from importlib.metadata import Distribution, PathDistribution
@pytest.fixture(scope="session")
def pkg_with_extras(pkg_with_extras_project: Path) -> PathDistribution:
frontend = SubprocessFrontend(*SubprocessFrontend.create_args_from_folder(pkg_with_extras_project)[:-1])
meta = pkg_with_extras_project / "meta"
result = frontend.prepare_metadata_for_build_wheel(meta)
assert result is not None
return Distribution.at(result.metadata)
def test_load_dependency_no_extra(pkg_with_extras: PathDistribution) -> None:
requires = pkg_with_extras.requires
assert requires is not None
result = dependencies_with_extras([Requirement(i) for i in requires], set(), "")
for left, right in zip_longest(result, (Requirement("platformdirs>=2.1"), Requirement("colorama>=0.4.3"))):
assert isinstance(right, Requirement)
assert str(left) == str(right)
def test_load_dependency_many_extra(pkg_with_extras: PathDistribution) -> None:
py_ver = ".".join(str(i) for i in sys.version_info[0:2])
requires = pkg_with_extras.requires
assert requires is not None
result = dependencies_with_extras([Requirement(i) for i in requires], {"docs", "testing"}, "")
exp = [
Requirement("platformdirs>=2.1"),
Requirement("colorama>=0.4.3"),
Requirement("sphinx>=3"),
Requirement("sphinx-rtd-theme<1,>=0.4.3"),
Requirement(f'covdefaults>=1.2; python_version == "2.7" or python_version == "{py_ver}"'),
Requirement(f'pytest>=5.4.1; python_version == "{py_ver}"'),
]
for left, right in zip_longest(result, exp):
assert isinstance(right, Requirement)
assert str(left) == str(right)
def test_loads_deps_recursive_extras() -> None:
requires = [
Requirement("no-extra"),
Requirement('dep1[magic]; extra=="dev"'),
Requirement('dep1; extra=="test"'),
Requirement('dep2[a,b]; extra=="test"'),
Requirement('dep3; extra=="docs"'),
Requirement('name; extra=="dev"'),
Requirement('name[test]; extra=="dev"'),
]
result = dependencies_with_extras(requires, {"dev"}, "name")
assert [str(i) for i in result] == ["no-extra", "dep1[magic]", "dep1", "dep2[a,b]"]
def test_load_dependency_requirement_or_extras() -> None:
requires = [Requirement('filelock<4.0.0,>=3.9.0; extra == "extras1" or extra == "extras2"')]
for extras in ["extras1", "extras2"]:
result = dependencies_with_extras(requires, {extras}, "")
assert [str(r) for r in result] == ["filelock<4.0.0,>=3.9.0"]
@pytest.mark.parametrize("extra", ["extras1", "extras2", "extras3"])
def test_load_dependency_requirement_many_or_extras(extra: str) -> None:
requires = [Requirement('filelock<4.0.0,>=3.9.0; extra == "extras1" or extra == "extras2" or extra == "extras3"')]
result = dependencies_with_extras(requires, {extra}, "")
assert [str(r) for r in result] == ["filelock<4.0.0,>=3.9.0"]
tox-4.13.0/tests/tox_env/python/virtual_env/test_setuptools.py 0000664 0000000 0000000 00000003720 14564001166 0024753 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
import sys
from typing import TYPE_CHECKING, cast
import pytest
from tox.tox_env.python.package import WheelPackage
from tox.tox_env.python.virtual_env.package.pyproject import Pep517VirtualEnvPackager
from tox.tox_env.runner import RunToxEnv
if TYPE_CHECKING:
from pathlib import Path
from tox.pytest import ToxProjectCreator
@pytest.mark.integration()
def test_setuptools_package(
tox_project: ToxProjectCreator,
demo_pkg_setuptools: Path,
enable_pip_pypi_access: str | None, # noqa: ARG001
) -> None:
tox_ini = """
[testenv]
package = wheel
commands_pre = python -c 'import sys; print("start", sys.executable)'
commands = python -c 'from demo_pkg_setuptools import do; do()'
commands_post = python -c 'import sys; print("end", sys.executable)'
"""
project = tox_project({"tox.ini": tox_ini}, base=demo_pkg_setuptools)
outcome = project.run("r", "-e", "py")
outcome.assert_success()
assert f"\ngreetings from demo_pkg_setuptools{os.linesep}" in outcome.out
tox_env = cast(RunToxEnv, outcome.state.envs["py"])
(package_env,) = list(tox_env.package_envs)
assert isinstance(package_env, Pep517VirtualEnvPackager)
packages = package_env.perform_packaging(tox_env.conf)
assert len(packages) == 1
package = packages[0]
assert isinstance(package, WheelPackage)
assert str(package) == str(package.path)
assert package.path.name == f"demo_pkg_setuptools-1.2.3-py{sys.version_info.major}-none-any.whl"
result = outcome.out.split("\n")
py_messages = [i for i in result if "py: " in i]
assert len(py_messages) == 5, "\n".join(py_messages) # 1 install wheel + 3 command + 1 final report
package_messages = [i for i in result if ".pkg: " in i]
# 1 optional hooks + 1 install requires + 1 build requires + 1 build meta + 1 build isolated + 1 exit
assert len(package_messages) == 6, "\n".join(package_messages)
tox-4.13.0/tests/tox_env/python/virtual_env/test_virtualenv_api.py 0000664 0000000 0000000 00000014734 14564001166 0025571 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
import sys
from typing import TYPE_CHECKING
import pytest
from virtualenv import __version__ as virtualenv_version
from virtualenv import session_via_cli
from virtualenv.config.cli.parser import VirtualEnvOptions
if TYPE_CHECKING:
from pytest_mock import MockerFixture
from tox.execute import ExecuteRequest
from tox.pytest import MonkeyPatch, ToxProject, ToxProjectCreator
@pytest.fixture()
def virtualenv_opt(monkeypatch: MonkeyPatch, mocker: MockerFixture) -> VirtualEnvOptions:
for key in os.environ:
if key.startswith("VIRTUALENV_"): # pragma: no cover
monkeypatch.delenv(key) # pragma: no cover
opts = VirtualEnvOptions()
mocker.patch(
"tox.tox_env.python.virtual_env.api.session_via_cli",
side_effect=lambda args, options, setup_logging, env: session_via_cli( # noqa: ARG005
args,
opts,
setup_logging,
env,
),
)
return opts
def test_virtualenv_default_settings(tox_project: ToxProjectCreator, virtualenv_opt: VirtualEnvOptions) -> None:
proj = tox_project({"tox.ini": "[testenv]\npackage=skip"})
result = proj.run("r", "-e", "py3", "--discover", sys.executable, str(proj.path / "a"))
result.assert_success()
conf = result.env_conf("py3")
assert conf["system_site_packages"] is False
assert conf["always_copy"] is False
assert conf["download"] is False
assert virtualenv_opt.clear is False
assert virtualenv_opt.system_site is False
assert virtualenv_opt.download is False
assert virtualenv_opt.copies is False
assert virtualenv_opt.no_periodic_update is True
assert virtualenv_opt.python == ["py3"]
assert virtualenv_opt.try_first_with == [str(sys.executable), str(proj.path / "a")]
def test_virtualenv_flipped_settings(
tox_project: ToxProjectCreator,
virtualenv_opt: VirtualEnvOptions,
monkeypatch: MonkeyPatch,
) -> None:
proj = tox_project(
{"tox.ini": "[testenv]\npackage=skip\nsystem_site_packages=True\nalways_copy=True\ndownload=True"},
)
monkeypatch.setenv("VIRTUALENV_CLEAR", "0")
result = proj.run("r", "-e", "py3")
result.assert_success()
conf = result.env_conf("py3")
assert conf["system_site_packages"] is True
assert conf["always_copy"] is True
assert conf["download"] is True
assert virtualenv_opt.clear is False
assert virtualenv_opt.system_site is True
assert virtualenv_opt.download is True
assert virtualenv_opt.copies is True
assert virtualenv_opt.python == ["py3"]
def test_virtualenv_env_ignored_if_set(
tox_project: ToxProjectCreator,
virtualenv_opt: VirtualEnvOptions,
monkeypatch: MonkeyPatch,
) -> None:
ini = "[testenv]\npackage=skip\nsystem_site_packages=True\nalways_copy=True\ndownload=True"
proj = tox_project({"tox.ini": ini})
monkeypatch.setenv("VIRTUALENV_COPIES", "0")
monkeypatch.setenv("VIRTUALENV_DOWNLOAD", "0")
monkeypatch.setenv("VIRTUALENV_SYSTEM_SITE_PACKAGES", "0")
run_and_check_set(proj, virtualenv_opt)
def test_virtualenv_env_used_if_not_set(
tox_project: ToxProjectCreator,
virtualenv_opt: VirtualEnvOptions,
monkeypatch: MonkeyPatch,
) -> None:
proj = tox_project({"tox.ini": "[testenv]\npackage=skip"})
monkeypatch.setenv("VIRTUALENV_COPIES", "1")
monkeypatch.setenv("VIRTUALENV_DOWNLOAD", "1")
monkeypatch.setenv("VIRTUALENV_SYSTEM_SITE_PACKAGES", "1")
run_and_check_set(proj, virtualenv_opt)
def run_and_check_set(proj: ToxProject, virtualenv_opt: VirtualEnvOptions) -> None:
result = proj.run("r", "-e", "py")
result.assert_success()
conf = result.env_conf("py")
assert conf["system_site_packages"] is True
assert conf["always_copy"] is True
assert conf["download"] is True
assert virtualenv_opt.system_site is True
assert virtualenv_opt.download is True
assert virtualenv_opt.copies is True
def test_honor_set_env_for_clear_periodic_update(
tox_project: ToxProjectCreator,
virtualenv_opt: VirtualEnvOptions,
) -> None:
ini = "[testenv]\npackage=skip\nset_env=\n VIRTUALENV_CLEAR=0\n VIRTUALENV_NO_PERIODIC_UPDATE=0"
proj = tox_project({"tox.ini": ini})
result = proj.run("r", "-e", "py")
result.assert_success()
assert virtualenv_opt.clear is False
assert virtualenv_opt.no_periodic_update is False
def test_recreate_when_virtualenv_changes(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
proj = tox_project({"tox.ini": "[testenv]\npackage=skip"})
proj.run("r")
from tox.tox_env.python.virtual_env import api # noqa: PLC0415
mocker.patch.object(api, "virtualenv_version", "1.0")
result = proj.run("r")
assert f"recreate env because python changed virtualenv version='{virtualenv_version}'->'1.0'" in result.out
assert "remove tox env folder" in result.out
@pytest.mark.parametrize("on", [True, False])
def test_pip_pre(tox_project: ToxProjectCreator, on: bool) -> None:
proj = tox_project({"tox.ini": f"[testenv]\npackage=skip\npip_pre={on}\ndeps=magic"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "-e", "py")
result.assert_success()
if on:
assert "--pre" in execute_calls.call_args[0][3].cmd
else:
assert "--pre" not in execute_calls.call_args[0][3].cmd
def test_install_command_no_packages(tox_project: ToxProjectCreator, disable_pip_pypi_access: tuple[str, str]) -> None:
install_cmd = "python -m pip install -i {env:PIP_INDEX_URL}"
proj = tox_project({"tox.ini": f"[testenv]\npackage=skip\ninstall_command={install_cmd}\npip_pre=true\ndeps=magic"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r")
result.assert_success()
request: ExecuteRequest = execute_calls.call_args[0][3]
found_cmd = request.cmd
assert found_cmd == ["python", "-m", "pip", "install", "-i", disable_pip_pypi_access[0], "--pre", "magic"]
def test_list_dependencies_command(tox_project: ToxProjectCreator) -> None:
install_cmd = "python -m pip freeze"
proj = tox_project({"tox.ini": f"[testenv]\npackage=skip\nlist_dependencies_command={install_cmd}"})
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "--result-json", str(proj.path / "out.json"))
result.assert_success()
request: ExecuteRequest = execute_calls.call_args[0][3]
assert request.cmd == ["python", "-m", "pip", "freeze"]
tox-4.13.0/tests/tox_env/test_api.py 0000664 0000000 0000000 00000001331 14564001166 0017420 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from pathlib import Path
from tox.pytest import ToxProjectCreator
def test_ensure_temp_dir_exists(tox_project: ToxProjectCreator) -> None:
ini = "[testenv]\ncommands=python -c 'import os; os.path.exists(r\"{temp_dir}\")'"
project = tox_project({"tox.ini": ini})
result = project.run()
result.assert_success()
def test_dont_cleanup_temp_dir(tox_project: ToxProjectCreator, tmp_path: Path) -> None:
(tmp_path / "foo" / "bar").mkdir(parents=True)
project = tox_project({"tox.ini": "[tox]\ntemp_dir=foo"})
result = project.run()
result.assert_success()
assert (tmp_path / "foo" / "bar").exists()
tox-4.13.0/tests/tox_env/test_info.py 0000664 0000000 0000000 00000000412 14564001166 0017601 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from pathlib import Path
from tox.tox_env.info import Info
def test_info_repr() -> None:
at_loc = Path().absolute()
info_object = Info(at_loc)
assert repr(info_object) == f"Info(path={ at_loc / '.tox-info.json' })"
tox-4.13.0/tests/tox_env/test_register.py 0000664 0000000 0000000 00000001567 14564001166 0020506 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import pytest
from tox.tox_env.python.virtual_env.runner import VirtualEnvRunner
from tox.tox_env.register import ToxEnvRegister
def test_register_set_new_default_no_register() -> None:
register = ToxEnvRegister()
with pytest.raises(ValueError, match="run env must be registered before setting it as default"):
register.default_env_runner = "new-env"
def test_register_set_new_default_with_register() -> None:
class B(VirtualEnvRunner):
@staticmethod
def id() -> str:
return "B"
register = ToxEnvRegister()
register.add_run_env(VirtualEnvRunner)
assert register.default_env_runner == VirtualEnvRunner.id()
register.add_run_env(B)
assert register.default_env_runner == VirtualEnvRunner.id()
register.default_env_runner = B.id()
assert register.default_env_runner == "B"
tox-4.13.0/tests/tox_env/test_tox_env_api.py 0000664 0000000 0000000 00000010761 14564001166 0021171 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from textwrap import dedent
from typing import TYPE_CHECKING
from unittest.mock import patch
import pytest
from tox.tox_env.api import ToxEnv
if TYPE_CHECKING:
from pathlib import Path
from tox.pytest import ToxProjectCreator
def test_recreate(tox_project: ToxProjectCreator) -> None:
prj = tox_project({"tox.ini": "[testenv]\npackage=skip\nrecreate=True"})
result_first = prj.run("r")
result_first.assert_success()
result_second = prj.run("r")
result_second.assert_success()
assert "remove tox env folder" in result_second.out
def test_allow_list_external_fail(tox_project: ToxProjectCreator, fake_exe_on_path: Path) -> None:
prj = tox_project({"tox.ini": f"[testenv]\npackage=skip\ncommands={fake_exe_on_path.stem}"})
execute_calls = prj.patch_execute(lambda r: 0 if "cmd" in r.run_id else None)
result = prj.run("r")
result.assert_failed(1)
out = rf".*py: failed with {fake_exe_on_path.stem} is not allowed, use allowlist_externals to allow it.*"
result.assert_out_err(out=out, err="", regex=True)
execute_calls.assert_called()
def test_env_log(tox_project: ToxProjectCreator) -> None:
cmd = "commands=python -c 'import sys; print(1); print(2); print(3, file=sys.stderr); print(4, file=sys.stderr)'"
env_vars = " UNPREDICTABLE = 🪟"
prj = tox_project({"tox.ini": f"[testenv]\npackage=skip\nset_env =\n{env_vars}\n{cmd}"})
result_first = prj.run("r")
result_first.assert_success()
log_dir = prj.path / ".tox" / "py" / "log"
assert log_dir.exists(), result_first.out
filename = {i.name for i in log_dir.iterdir()}
assert filename == {"1-commands[0].log"}
content = (log_dir / "1-commands[0].log").read_text()
assert f"cwd: {prj.path}" in content
assert f"allow: {prj.path}" in content
assert "metadata " in content
assert "env PATH: " in content
assert content.startswith("name: py\nrun_id: commands[0]")
assert "cmd: python -c" in content
ending = """
exit_code: 0
1
2
standard error:
3
4
"""
assert content.endswith(dedent(ending).lstrip()), content
result_second = prj.run("r") # second run overwrites, so no new files
result_second.assert_success()
filename = {i.name for i in log_dir.iterdir()}
assert filename == {"1-commands[0].log"}
def test_tox_env_pass_env_literal_exist() -> None:
with patch("os.environ", {"A": "1"}):
env = ToxEnv._load_pass_env(["A"]) # noqa: SLF001
assert env == {"A": "1"}
def test_tox_env_pass_env_literal_miss() -> None:
with patch("os.environ", {}):
env = ToxEnv._load_pass_env(["A"]) # noqa: SLF001
assert not env
def test_tox_env_pass_env_fails_on_whitespace(tox_project: ToxProjectCreator) -> None:
first, second = "A B", "C D"
prj = tox_project({"tox.ini": f"[testenv]\npackage=skip\npass_env = {first}\n {second}\n E"})
result = prj.run("c", "-k", "pass_env")
result.assert_success()
msg = (
'[testenv:py]\npass_env = # Exception: Fail("pass_env values cannot contain whitespace, use comma to have '
f'multiple values in a single line, invalid values found {first!r}, {second!r}")\n'
)
assert result.out == msg
result = prj.run("r")
result.assert_failed(1)
msg = (
"py: failed with pass_env values cannot contain whitespace, use comma to have multiple values in a single line,"
" invalid values found 'A B', 'C D'"
)
assert msg in result.out
@pytest.mark.parametrize("glob", ["*", "?"])
@pytest.mark.parametrize("char", ["a", "A"])
def test_tox_env_pass_env_match_ignore_case(char: str, glob: str) -> None:
with patch("os.environ", {"A1": "1", "a2": "2", "A2": "3", "B": "4"}):
env = ToxEnv._load_pass_env([f"{char}{glob}"]) # noqa: SLF001
assert env == {"A1": "1", "a2": "2", "A2": "3"}
def test_change_dir_is_created_if_not_exist(tox_project: ToxProjectCreator) -> None:
prj = tox_project({"tox.ini": "[testenv]\npackage=skip\nchange_dir=a{/}b\ncommands=python --version"})
result_first = prj.run("r")
result_first.assert_success()
assert (prj.path / "a" / "b").exists()
def test_change_dir_is_relative_to_conf(tox_project: ToxProjectCreator) -> None:
prj = tox_project({"tox.ini": "[testenv]\npackage=skip\nchange_dir=a"})
result = prj.run("c", "-e", "py", "-k", "change_dir", "-c", prj.path.name, from_cwd=prj.path.parent)
result.assert_success()
lines = result.out.splitlines()
assert lines[1] == f"change_dir = {prj.path / 'a'}"
tox-4.13.0/tests/tox_env/test_tox_env_runner.py 0000664 0000000 0000000 00000002003 14564001166 0021717 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from pathlib import Path
from tox.pytest import ToxProjectCreator
def test_package_only(
tox_project: ToxProjectCreator,
demo_pkg_inline: Path,
) -> None:
ini = "[testenv]\ncommands = python -c 'print('foo')'"
proj = tox_project(
{"tox.ini": ini, "pyproject.toml": (demo_pkg_inline / "pyproject.toml").read_text()},
base=demo_pkg_inline,
)
execute_calls = proj.patch_execute(lambda r: 0 if "install" in r.run_id else None)
result = proj.run("r", "--sdistonly")
result.assert_success()
expected_calls = [
(".pkg", "_optional_hooks"),
(".pkg", "get_requires_for_build_sdist"),
(".pkg", "get_requires_for_build_wheel"),
(".pkg", "build_wheel"),
(".pkg", "build_sdist"),
(".pkg", "_exit"),
]
found_calls = [(i[0][0].conf.name, i[0][3].run_id) for i in execute_calls.call_args_list]
assert found_calls == expected_calls
tox-4.13.0/tests/type_check/ 0000775 0000000 0000000 00000000000 14564001166 0015674 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/type_check/add_config_container_factory.py 0000664 0000000 0000000 00000000764 14564001166 0024123 0 ustar 00root root 0000000 0000000 """check that factory for a container works"""
from __future__ import annotations
from typing import List
from tox.config.sets import ConfigSet
class EnvDockerConfigSet(ConfigSet):
def register_config(self) -> None:
def factory(container_name: object) -> str: # noqa: ARG001
raise NotImplementedError
self.add_config(
keys=["k"],
of_type=List[str],
default=[],
desc="desc",
factory=factory,
)
tox-4.13.0/tests/util/ 0000775 0000000 0000000 00000000000 14564001166 0014533 5 ustar 00root root 0000000 0000000 tox-4.13.0/tests/util/__init__.py 0000664 0000000 0000000 00000000000 14564001166 0016632 0 ustar 00root root 0000000 0000000 tox-4.13.0/tests/util/test_ci.py 0000664 0000000 0000000 00000003661 14564001166 0016545 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import pytest
from tox.util.ci import _ENV_VARS, is_ci # noqa: PLC2701
@pytest.mark.parametrize(
"env_var",
{
"CI": None, # generic flag
"TF_BUILD": "true", # Azure Pipelines
"bamboo.buildKey": None, # Bamboo
"BUILDKITE": "true", # Buildkite
"CIRCLECI": "true", # Circle CI
"CIRRUS_CI": "true", # Cirrus CI
"CODEBUILD_BUILD_ID": None, # CodeBuild
"GITHUB_ACTIONS": "true", # GitHub Actions
"GITLAB_CI": None, # GitLab CI
"HEROKU_TEST_RUN_ID": None, # Heroku CI
"BUILD_ID": None, # Hudson
"TEAMCITY_VERSION": None, # TeamCity
"TRAVIS": "true", # Travis CI
}.items(),
ids=lambda v: v[0],
)
def test_is_ci(env_var: tuple[str, str | None], monkeypatch: pytest.MonkeyPatch) -> None:
for var in _ENV_VARS:
monkeypatch.delenv(var, raising=False)
monkeypatch.setenv(env_var[0], env_var[1] or "")
assert is_ci()
@pytest.mark.parametrize(
"env_var",
{
"TF_BUILD": "", # Azure Pipelines
"BUILDKITE": "", # Buildkite
"CIRCLECI": "", # Circle CI
"CIRRUS_CI": "", # Cirrus CI
"GITHUB_ACTIONS": "", # GitHub Actions
"TRAVIS": "", # Travis CI
}.items(),
ids=lambda v: v[0],
)
def test_is_ci_bad_set(env_var: tuple[str, str], monkeypatch: pytest.MonkeyPatch) -> None:
for var in _ENV_VARS:
monkeypatch.delenv(var, raising=False)
monkeypatch.setenv(env_var[0], env_var[1])
assert not is_ci()
def test_is_ci_not(monkeypatch: pytest.MonkeyPatch) -> None:
for var in _ENV_VARS:
monkeypatch.delenv(var, raising=False)
assert not is_ci()
def test_is_ci_not_teamcity_local(monkeypatch: pytest.MonkeyPatch) -> None:
# pycharm sets this
for var in _ENV_VARS:
monkeypatch.delenv(var, raising=False)
monkeypatch.setenv("TEAMCITY_VERSION", "LOCAL")
assert not is_ci()
tox-4.13.0/tests/util/test_cpu.py 0000664 0000000 0000000 00000001046 14564001166 0016734 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import multiprocessing
from typing import TYPE_CHECKING
from tox.util.cpu import auto_detect_cpus
if TYPE_CHECKING:
from pytest_mock import MockerFixture
def test_auto_detect_cpus() -> None:
num_cpus_actual = multiprocessing.cpu_count()
assert auto_detect_cpus() == num_cpus_actual
def test_auto_detect_cpus_returns_one_when_cpu_count_throws(mocker: MockerFixture) -> None:
mocker.patch.object(multiprocessing, "cpu_count", side_effect=NotImplementedError)
assert auto_detect_cpus() == 1
tox-4.13.0/tests/util/test_graph.py 0000664 0000000 0000000 00000003576 14564001166 0017260 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from collections import OrderedDict
import pytest
from tox.util.graph import stable_topological_sort
def test_topological_order_empty() -> None:
graph: dict[str, set[str]] = OrderedDict()
result = stable_topological_sort(graph)
assert result == []
def test_topological_order_specified_only() -> None:
graph: dict[str, set[str]] = OrderedDict()
graph["A"] = {"B", "C"}
result = stable_topological_sort(graph)
assert result == ["A"]
def test_topological_order() -> None:
graph: dict[str, set[str]] = OrderedDict()
graph["A"] = {"B", "C"}
graph["B"] = set()
graph["C"] = set()
result = stable_topological_sort(graph)
assert result == ["B", "C", "A"]
def test_topological_order_cycle() -> None:
graph: dict[str, set[str]] = OrderedDict()
graph["A"] = {"B", "C"}
graph["B"] = {"A"}
with pytest.raises(ValueError, match=r"^A \| B$"):
stable_topological_sort(graph)
def test_topological_complex() -> None:
graph: dict[str, set[str]] = OrderedDict()
graph["A"] = {"B", "C"}
graph["B"] = {"C", "D"}
graph["C"] = {"D"}
graph["D"] = set()
result = stable_topological_sort(graph)
assert result == ["D", "C", "B", "A"]
def test_two_sub_graph() -> None:
graph: dict[str, set[str]] = OrderedDict()
graph["F"] = set()
graph["E"] = set()
graph["D"] = {"E", "F"}
graph["A"] = {"B", "C"}
graph["B"] = set()
graph["C"] = set()
result = stable_topological_sort(graph)
assert result == ["F", "E", "D", "B", "C", "A"]
def test_two_sub_graph_circle() -> None:
graph: dict[str, set[str]] = OrderedDict()
graph["F"] = set()
graph["E"] = set()
graph["D"] = {"E", "F"}
graph["A"] = {"B", "C"}
graph["B"] = {"A"}
graph["C"] = set()
with pytest.raises(ValueError, match=r"^A \| B$"):
stable_topological_sort(graph)
tox-4.13.0/tests/util/test_path.py 0000664 0000000 0000000 00000000545 14564001166 0017104 0 ustar 00root root 0000000 0000000 from __future__ import annotations
from typing import TYPE_CHECKING
from tox.util.path import ensure_empty_dir
if TYPE_CHECKING:
from pathlib import Path
def test_ensure_empty_dir_file(tmp_path: Path) -> None:
dest = tmp_path / "a"
dest.write_text("")
ensure_empty_dir(dest)
assert dest.is_dir()
assert not list(dest.iterdir())
tox-4.13.0/tests/util/test_spinner.py 0000664 0000000 0000000 00000012040 14564001166 0017617 0 ustar 00root root 0000000 0000000 from __future__ import annotations
import os
import sys
import time
from typing import TYPE_CHECKING
import pytest
import time_machine
from colorama import Fore
from tox.util import spinner
if TYPE_CHECKING:
from pytest_mock import MockerFixture
from tox.pytest import CaptureFixture, MonkeyPatch
@time_machine.travel("2012-01-14", tick=False)
def test_spinner(capfd: CaptureFixture, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setattr(sys.stdout, "isatty", lambda: False)
with spinner.Spinner(refresh_rate=100) as spin:
for _ in range(len(spin.frames)):
spin.stream.write("\n")
spin.render_frame()
spin.stream.write("\n")
out, _err = capfd.readouterr()
lines = out.split("\n")
expected = [f"\r{spin.CLEAR_LINE}\r{i} [0]" for i in spin.frames] + [
f"\r{spin.CLEAR_LINE}\r{spin.frames[0]} [0]",
f"\r{spin.CLEAR_LINE}",
]
assert lines == expected
@time_machine.travel("2012-01-14", tick=False)
def test_spinner_disabled(capfd: CaptureFixture) -> None:
with spinner.Spinner(refresh_rate=100, enabled=False) as spin:
spin.add("x")
for _ in range(len(spin.frames)):
spin.render_frame()
spin.finalize("x", "done", Fore.GREEN)
spin.clear()
out, err = capfd.readouterr()
assert out == f"{Fore.GREEN}x: done in 0 seconds{Fore.RESET}{os.linesep}", out
assert not err
@time_machine.travel("2012-01-14", tick=False)
def test_spinner_progress(capfd: CaptureFixture, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setattr(sys.stdout, "isatty", lambda: False)
with spinner.Spinner() as spin:
for _ in range(len(spin.frames)): # pragma: no branch
spin.stream.write("\n")
time.sleep(spin.refresh_rate)
out, err = capfd.readouterr()
assert not err
assert len({i.strip() for i in out.split("[0]")}) > len(spin.frames) / 2
@time_machine.travel("2012-01-14", tick=False)
def test_spinner_atty(capfd: CaptureFixture, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setattr(sys.stdout, "isatty", lambda: True)
with spinner.Spinner(refresh_rate=100) as spin:
spin.stream.write("\n")
out, _err = capfd.readouterr()
lines = out.split("\n")
posix = os.name == "posix"
expected = [
"{}\r{}\r{} [0]".format("\x1b[?25l" if posix else "", spin.CLEAR_LINE, spin.frames[0]),
"\r\x1b[K{}".format("\x1b[?25h" if posix else ""),
]
assert lines == expected
@time_machine.travel("2012-01-14", tick=False)
@pytest.mark.flaky(max_runs=3, min_passes=1)
def test_spinner_report(capfd: CaptureFixture, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setattr(sys.stdout, "isatty", lambda: False)
with spinner.Spinner(refresh_rate=100) as spin:
spin.stream.write(os.linesep)
spin.add("ok")
spin.add("fail")
spin.add("skip")
spin.succeed("ok")
spin.fail("fail")
spin.skip("skip")
out, err = capfd.readouterr()
lines = out.split(os.linesep)
del lines[0]
expected = [
f"\r{spin.CLEAR_LINE}{Fore.GREEN}ok: OK ✔ in 0 seconds{Fore.RESET}",
f"\r{spin.CLEAR_LINE}{Fore.RED}fail: FAIL ✖ in 0 seconds{Fore.RESET}",
f"\r{spin.CLEAR_LINE}{Fore.YELLOW}skip: SKIP ⚠ in 0 seconds{Fore.RESET}",
f"\r{spin.CLEAR_LINE}",
]
assert lines == expected
assert not err
def test_spinner_long_text(capfd: CaptureFixture, monkeypatch: MonkeyPatch) -> None:
monkeypatch.setattr(sys.stdout, "isatty", lambda: False)
with spinner.Spinner(refresh_rate=100) as spin:
spin.stream.write("\n")
spin.add("a" * 60)
spin.add("b" * 60)
spin.render_frame()
spin.stream.write("\n")
out, err = capfd.readouterr()
assert not err
expected = [
f"\r{spin.CLEAR_LINE}\r{spin.frames[1]} [2] {'a' * 60} |...",
f"\r{spin.CLEAR_LINE}",
]
lines = out.split("\n")
del lines[0]
assert lines == expected
def test_spinner_stdout_not_unicode(capfd: CaptureFixture, mocker: MockerFixture) -> None:
stdout = mocker.patch("tox.util.spinner.sys.stdout")
stdout.encoding = "ascii"
with spinner.Spinner(refresh_rate=100) as spin:
for _ in range(len(spin.frames)): # pragma: no branch
spin.render_frame()
out, err = capfd.readouterr()
assert not err
assert not out
written = "".join({i[0][0] for i in stdout.write.call_args_list})
assert all(f in written for f in spin.frames)
@pytest.mark.parametrize(
("seconds", "expected"),
[
(0, "0 seconds"),
(1.0, "1 second"),
(4.0, "4 seconds"),
(4.13, "4.13 seconds"),
(4.137, "4.14 seconds"),
(42.12345, "42.12 seconds"),
(60, "1 minute"),
(61, "1 minute 1 second"),
(120, "2 minutes"),
(40 * 24 * 60 * 60 + 5 * 60, "40 days 5 minutes"),
(40 * 24 * 60 * 60 + 4 * 60 * 60 + 5 * 60 + 1.5, "40 days 4 hours 5 minutes 1.5 seconds"),
],
)
def test_td_human_readable(seconds: float, expected: str) -> None:
assert spinner.td_human_readable(seconds) == expected
tox-4.13.0/tox.ini 0000664 0000000 0000000 00000005410 14564001166 0013727 0 ustar 00root root 0000000 0000000 [tox]
requires =
tox>=4.2
env_list =
fix
py312
py311
py310
py39
py38
cov
type
docs
pkg_meta
skip_missing_interpreters = true
[testenv]
description = run the tests with pytest under {envname}
package = wheel
wheel_build_env = .pkg
extras =
testing
pass_env =
PYTEST_*
SSL_CERT_FILE
set_env =
COVERAGE_FILE = {env:COVERAGE_FILE:{toxworkdir}{/}.coverage.{envname}}
COVERAGE_PROCESS_START = {toxinidir}{/}pyproject.toml
commands =
pytest {posargs: \
--junitxml {toxworkdir}{/}junit.{envname}.xml --cov {envsitepackagesdir}{/}tox --cov {toxinidir}{/}tests \
--cov-config={toxinidir}{/}pyproject.toml --no-cov-on-fail --cov-report term-missing:skip-covered --cov-context=test \
--cov-report html:{envtmpdir}{/}htmlcov \
--cov-report xml:{toxworkdir}{/}coverage.{envname}.xml \
-n={env:PYTEST_XDIST_AUTO_NUM_WORKERS:auto} \
tests --durations 5 --run-integration}
diff-cover --compare-branch {env:DIFF_AGAINST:origin/main} {toxworkdir}{/}coverage.{envname}.xml
[testenv:fix]
description = format the code base to adhere to our styles, and complain about what we cannot do automatically
skip_install = true
deps =
pre-commit>=3.6
pass_env =
{[testenv]passenv}
PROGRAMDATA
commands =
pre-commit run --all-files --show-diff-on-failure {posargs}
python -c 'print(r"hint: run {envbindir}{/}pre-commit install to add checks as pre-commit hook")'
[testenv:type]
description = run type check on code base
deps =
mypy==1.8
types-cachetools>=5.3.0.7
types-chardet>=5.0.4.6
commands =
mypy src/tox
mypy tests
[testenv:docs]
description = build documentation
extras =
docs
commands =
{posargs: sphinx-build -d "{envtmpdir}{/}doctree" docs "{toxworkdir}{/}docs_out" --color -b linkcheck}
sphinx-build -d "{envtmpdir}{/}doctree" docs "{toxworkdir}{/}docs_out" --color -b html -W
python -c 'print(r"documentation available under file://{toxworkdir}{/}docs_out{/}index.html")'
[testenv:pkg_meta]
description = check that the long description is valid
skip_install = true
deps =
build[virtualenv]>=1.0.3
check-wheel-contents>=0.6
twine>=4.0.2
commands =
python -m build -o {envtmpdir} -s -w .
twine check {envtmpdir}{/}*
check-wheel-contents --no-config {envtmpdir}
[testenv:release]
description = do a release, required posarg of the version number
skip_install = true
deps =
gitpython>=3.1.41
packaging>=23.2
towncrier>=23.11
commands =
python {toxinidir}/tasks/release.py --version {posargs}
[testenv:dev]
description = dev environment with all deps at {envdir}
package = editable
deps =
{[testenv:release]deps}
extras =
docs
testing
commands =
python -m pip list --format=columns
python -c "print(r'{envpython}')"