�
���Xc@�s�dZd
dl
mZ
d
dlmZ
d
dlZd
dlmZmZ
d
dl	Z	d
dl
Z
e
je�
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlmZmZ
d
dlmZmZ
d
dlZd
dlmZ
d
d	lmZ
d
d
lmZ
d
dl j!Z!d
dl"m#Z$m%Z%m&Z&m'Z'm(Z(
d
dl)m*Z*m+Z+m,Z,m-Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4
d
d
lm5Z5m6Z6m7Z7m8Z8m9Z9
d
dl:m;Z;
d
dl<j=j>Z?dddddgZ@yd
dlAZBWneCk
r0


eDZEnXeFZEd�ZGd�ZHeHe3�
ZIdddgZJeJjKejLjMdd�jN�jO��
ZPeQeQd�ZRd�ZSeQd�
ZTd�ZUeQeDd�ZVd�ZWd �ZXd!�ZYejZd"��
Z[d#�Z\d$�Z]d%�Z^d&�Z_d'�Z`d(�ZaeQd)d*d+�Zbd,d-d.�Zcde$f
d/��YZ#d0dgZdde#f
d1��YZed2eef
d3��YZfd4eef
d5��YZgd6eef
d7��YZhd8ejif
d9��YZjdS(:shelpers for passlib unittestsi����(
twith_statement(
t	unhexlifyN(twrapstpartial(tPasslibHashWarningtPasslibConfigWarning(tPY3tJYTHON(
twarn(
texc(
tMissingBackendError(tTestCasetskiptskipIft
skipUnlesstSkipTest(
thas_rounds_infot
has_salt_infotrounds_cost_valuestrngt
getrandstrt
is_ascii_safet
to_native_strt
repeat_stringtticktbatch(t	iteritemstiranget
utunicodetPY2(
t
classpropertyt	TEST_MODEtset_filetget_fileRtHandlerCasec
C�sRtj
j|�
}
x9tj
j|�
|
krMtjd
�

tj|d�
qWdS(sensure file's mtime has changedg�������?N(tostpathtgetmtimettimetsleeptutimetNone(R%tlast((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytensure_mtime_changed;s



c

�s/�
f
d
��t�f
d�t
d�
D�
�
S(Nc�s1��}}
x||
kr(��}
qW|
|S(
N((tstarttcur(
ttimer(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytsampleEs





c
3�s|]}
��V
qdS(
N((t.0t
_(
R0(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pys	<genexpr>Jsi(tmintrange(
R/((R0R/s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt_get_timer_resolutionDs
tquicktdefaulttfulltPASSLIB_TEST_MODEcC�sB|rtt
j|�
krtS|
r>tt
j|
�
kr>tStS(
s�check if test for specified mode should be enabled.

    ``"quick"``
        run the bare minimum tests to ensure functionality.
        variable-cost hashes are tested at their lowest setting.
        hash algorithms are only tested against the backend that will
        be used on the current host. no fuzz testing is done.

    ``"default"``
        same as ``"quick"``, except: hash algorithms are tested
        at default levels, and a brief round of fuzz testing is done
        for each hash.

    ``"full"``
        extra regression and internal tests are enabled, hash algorithms are tested
        against all available backends, unavailable ones are mocked whre possible,
        additional time is devoted to fuzz testing.
    (t
_test_modet_TEST_MODEStindextFalsetTrue(R3tmax((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR Ts




c

C�s2t|d
�rt
Sd|jkp1t|tj�S(s'check if handler supports 'relaxed' kwdtorig_prefixtrelaxed(thasattrR=tsetting_kwdst
issubclasstuhtGenericHandler(
thandler((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pythas_relaxed_settingps

cC�s"t|�
}|d
|
dt
�jS(s'get effective rounds value from handlertroundstuse_defaults(tunwrap_handlerR>RI(RGRI((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytget_effective_rounds|s
cC�s[y|j�}Wnt
k
r$


tSXz!|jd
�

|j�|
kSWd|j|�

XdS(s*check if backend is the default for sourceR7N(tget_backendR
R=tset_backend(RGtbackendtorig((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytis_default_backend�s







cc�s|
dkr|j
�}
n|j}|r=|j|
�
d
nd}x5||D])}||
krN|j|�
rN|V
qNqNWdS(s�
    iterate over alternate backends available to handler.

    .. warning::
        not thread-safe due to has_backend() call
    i
iN(R*RMtbackendsR<thas_backend(RGtcurrenttfallbackRRtidxRO((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytiter_alt_backends�s

	



cO�sxt||
�D]}|SWdS(
N(RWR*(targstkwdsRO((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytget_alt_backend�s


c

C�s#xt|d
�r|j
}qW|S(s5return original handler, removing any wrapper objectstwrapped(RBR[(
RG((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRK�s


cC�s�||
krtSt
|tj�rLx#|rG||
kr;tS|j}q%WtSt
|t�rzt|tj�rzt||
�St	d
|f
�
�
dS(sG
    test if <handler> was derived from <base> via <base.using()>.
    s%don't know how to inspect handler: %rN(
R>t
isinstanceREt
PrefixWrappert
_derived_fromR=ttypeRDtMinimalHandlertNotImplementedError(RGtbase((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pythandler_derived_from�s


	




!

c
#�s�t|t
�r[t|tj�r[|j��f
d
�}
|
|_z	dV
Wd�|_Xn9t|tj�r�t|j�
�

dV
WdQXn	dV
dSdS(s

    internal helper for do_config_encrypt() --
    context manager which temporarily replaces handler's _calc_checksum()
    with one that uses min_rounds; useful when trying to generate config
    with high rounds value, but don't care if output is correct.
    c
�s:|j}z |j
|_�||
|�
SWd||_XdS(
N(RIt
min_rounds(tselfRXRYRI(
R[(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytwrapper�s

	


N(	R\R_RDREt	HasRoundst_calc_checksumR]tpatch_calc_min_roundsR[(RGRf((
R[s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRi�s!	
	

	




cC�sJt|
t
�r!|
jd
�
}
nt|d��}|j|
�

WdQXdS(sset file to specified bytessutf-8twbN(R\Rtencodetopentwrite(R%tcontenttfh((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR!�s


c
C�s&t|d
��}
|
j
�SWdQXdS(sread file as bytestrbN(Rltread(R%Ro((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR"�s
c

C�sYt|t
�s|Str&|jd
�
Sy|jd
�
SWntk
rT


|jd�
SXdS(s*convert native string to non-native stringsutf-8slatin-1N(R\tstrRRktdecodetUnicodeDecodeError(
tsource((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttonn�s







c

C�stt
jd
d|��
S(sT
    helper for represent byte strings in hex.

    usage: ``hb("deadbeef23")``
    s\st(R
tretsub(
Ru((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pythb�scC�s$||
kr|
S||kr |S|S(
N((tvaluetlowertupper((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytlimit�s





c
C�s't�}
xt�|
|kr"qWd
S(sAbecause time.sleep() doesn't even have 10ms accuracy on some OSesN(
R(tdelayR-((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt
quicksleep
s	

i
i
c
C�s�d
dlm
}
d
dlm}
||d|
p2d�

}d}t�|}xXtr�t|j||��
}	t�|kr�|	|t||d��
fS|d9}qNWdS(	s�
    timeit() wrapper which tries to get as accurate a measurement as possible w/in maxtime seconds.

    :returns:
        ``(avg_seconds_per_call, log10_number_of_repetitions)``
    i����(
tTimer(
tlogtsetupRwi
i
N(	ttimeitR�tmathR�RR>R3trepeattint(
tfuncR�tmaxtimetbestofR�R�R/tnumbertendtdelta((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt	time_call	
s





	



i�I����j?$c�s��
fd
�}|S(s<
    decorator run test method w/ multiple fixed seeds.
    c
�s%t��
�
��fd
��
}
|
S(Nc�sJtj
��
}x4t��
D]&}|jd
�
|
d<�
||
�
qWdS(Ni tseed(trandomtRandomRtgetrandbits(RXRYRR2(tcountR�tmaster_seed(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRf 
s


(
R(R�Rf(R�R�(
R�s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytbuilder
s
!((R�R�R�((R�R�s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytrun_with_fixed_seeds
scB�sN
eZ
dZdZd
�Zed��
Zed��
Ze	Z
e	Zd�Zd�Z
e	Zd�Zdd�
Zd�ZeZZdddddddd	�Zd
ejf
d��YZdddd�Zdd
�
Zd�Zd�Zd�Zd�Zd�Zej �Z!dZ"dZ#ddd�Z$dZ%d�Z&e	e'd�Z(RS(sR
passlib-specific test case class

    this class adds a number of features to the standard TestCase...
    * common prefix for all test descriptions
    * resets warnings filter & registry for every test
    * tweaks to message formatting
    * __msg__ kwd added to assertRaises()
    * suite of methods for matching against warnings
    c
C�sGtt
|�j�}
|j}|rCd
||
p9t|�
f}
n|
S(s;wrap shortDescription() method to prepend descriptionPrefixs%s: %s(tsuperRtshortDescriptiontdescriptionPrefixRr(Retdesctprefix((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�B
s

	


c
C�s,|j}
|
j
d
�
p+t|d|
t�S(NR2s_%s__unittest_skip(t__name__t
startswithtgetattrR=(tclstname((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt__unittest_skip__N
s	

c


C�s|jS(
N(
R�(
R�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt__test__U
sc

C�s!tt
|�j�
|j�
dS(
N(R�RtsetUpt
setUpWarnings(
Re((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�d
s

c
C�sS|jrOt
�}
|
j�
|j|
j�

tjd
d�
tjd
d�
ndS(s6helper to init warning filters before subclass setUp()tignores<the method .*\.(encrypt|genconfig|genhash)\(\) is deprecateds&the 'vary_rounds' option is deprecatedN(tresetWarningStatetreset_warningst	__enter__t
addCleanupt__exit__twarningstfilterwarnings(Retctx((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�h
s	
	



cC�sF|jr8|
r8|
j
�jd
�
r8d|
j
�|fS|
pA|SdS(Nt
:s%s %s(tlongMessagetrstriptendswith(Retmsgtstd((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt_formatMessage{
s
$
c	O�s�|jd
d�}|dkr=tt|�j|
d||�Sy|||�}Wn|
k
rf
}
|SXd||
f}|j|j||��
�
dS(Nt__msg__s-function returned %r, expected it to raise %r(tpopR*R�RtassertRaisestfailureExceptionR�(	Ret	_exc_typet	_callableRXRYR�tresultterrR�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��
s











c
O�std
�
�
dS(Ns%this alias is deprecated by unittest2(
tAssertionError(Ret
at
k((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytassertEquals�
s
c	C�sO
t|
d
�r!|
}	|
j
}
nd}	|rI|jt|
�
||�
n|rk|jt|
�
||�
n|r�|j|
||�
n|s�|r
|	s�td�
�
n|	j}
|
j	d�
s�|
j	d�
r�|
d }
n|r�|j|
||�
n|r
|j|
||�
q
n|rK
|	s2
td�
�
n|j|	j
||�
ndS(s�check if warning matches specified parameters.
        'warning' is the instance of Warning to match against;
        can also be instance of WarningMessage (as returned by catch_warnings).
        tcategorys7matching on filename requires a WarningMessage instances.pycs.pyoi����s5matching on lineno requires a WarningMessage instanceN(RBtmessageR*tassertEqualRrtassertRegextassertIsInstancet	TypeErrortfilenameR�tlineno(Retwarningt
message_reR�R�tfilename_reR�R�R�twmsgtreal((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt
assertWarning�
s0







	








t_AssertWarningListc
B�s)eZ
dZd
�Zd�Zd�ZRS(s'context manager for assertWarningList()cK�s>|
|_||_
ttj|�|_|jjd
t�

dS(Ntrecord(tcaseRYR�RR�t_AssertWarningList__supert__init__R>(ReR�RY((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��
s
	
	

c

C�s|jj
�|_dS(
N(R�R�R�(
Re((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��
s
c
G�s@|jj
|
�
|
d
dkr<|jj|j|j�

ndS(Ni(R�R�R*R�tassertWarningListR�RY(Retexc_info((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��
s


(R�t
__module__t__doc__R�R�R�(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��
s

		cC�s�
|dkr7|
dk	st
�
|j|d
|
d|�
S|dk	sIt
�
t|ttf�sj|g
}nx�t|�
D]�\}}t|t�r�td|�
}nNt|t	�r�t
|t�r�td|�
}nt|t�s�td�
�
ny|
|}Wnt
k
r



Pn
X|j|d||�


qwWt|
�
t|�
krK
dSdt|�
t|
�
|j|
�
|f}|j|j||��
�
dS(sBcheck that warning list (e.g. from catch_warnings) matches patternR�R�R�R�s#entry must be str, warning, or dictNs0expected %d warnings, found %d: wlist=%s desc=%r(R*R�R�R\tlistttuplet	enumerateRrtdictR_RDtWarningR�t
IndexErrorR�tlent_formatWarningListR�R�(RetwlistR�R�RVtentrytdataR�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��
s.



















(
cO�s3|d
krg}n|j
|
|||�
|
2d
S(sD[deprecated] assertWarningList() variant that clears list afterwardsN(R*R�(ReR�R�RXRY((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytconsumeWarningList�
s
	

cC�s�d
}t|
d�rWd|
j
|
jf}|
jrK|d|
jf
7}n|
j}
nt|
�
}d|j|jt|
�
|fS(NRwR�s filename=%r lineno=%rs line=%rs<%s.%s message=%r%s>(	RBR�R�tlineR�R_R�R�Rr(ReR�ttailR�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt_formatWarnings


	




c�s!d
dj�f
d�|
D�
�
S(Ns[%s]s, c
3�s|]}
�j|
�
V
qdS(
N(
R�(R1R�(
Re(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pys	<genexpr>
s(
tjoin(ReR�((
Res7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�s
c
C�s@d
dlm
}

|
s<d
dlm}
|jd|�
�
ndS(s,helper to skip test if stringprep is missingi����(
t
stringprep(
t_stringprep_missing_reasons%not available - stringprep module is N(t
passlib.utilsR�R�tskipTest(ReR�R�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytrequire_stringpreps



	
cC�s&t|
�
s"|j
d
|
�
�
ndS(s8skip test for all PASSLIB_TEST_MODE values below <level>srequires >= %r test modeN(R R�(Retlevel((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytrequire_TEST_MODEs
c

C�str|j
d
�
SdS(s'skip test if writeable FS not availables.GAE doesn't offer read/write filesystem accessN(tGAER�(
Re((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytrequire_writeable_filesystems
R7c	C�sc
|j}|r#|
|kr#||
S|j
�1

|j}|rP|
|krP||
S|sfi}|_n|prtj}|dkr�ttjjd
�
p�tjjd�
p�t	j
d�
�
}t_tjd|�
nt
|�
}djt|�
|j|j|j|
g�
}tj|jd�
�
j�}t|d d�}tj|�
}||
<|SWdQXdS(	sU
        Return a :class:`random.Random` object for current test method to use.
        Within an instance, multiple calls with the same name will return
        the same object.

        When first created, each RNG will be seeded with value derived from
        a global seed, the test class module & name, the current test method name,
        and the **name** parameter.

        The global seed taken from the $RANDOM_TEST_SEED env var,
        the $PYTHONHASHSEED env var, or a randomly generated the
        first time this method is called. In all cases, the value
        is logged for reproducibility.

        :param name:
            name to uniquely identify separate RNGs w/in a test
            (e.g. for threaded tests).

        :param seed:
            override global seed when initialzing rng.

        :rtype: random.Random
        tRANDOM_TEST_SEEDtPYTHONHASHSEEDi susing RANDOM_TEST_SEED=%ds

sutf-8iN(t
_random_cachet_random_global_lockRt_random_global_seedR*R�R$tenvirontgettsys_rngR�R�tinfoR_R�RrR�R�t_testMethodNamethashlibtsha256Rkt	hexdigestR�R�(	ReR�R�tcachetglobal_seedR�RutdigestR{((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt	getRandom2s,	


	











c
�s�|j�
t
j|
|�\}}tj|�

|j��dkrpg�|_�f
d
�}|j|�

n�j|�

|S(s1create temp file that's cleaned up at end of testc
�s;x0�D](}tj
j|�
rtj|�

qqW�2dS(
N(R$R%texiststremove(
R%(
tqueue(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytcleaner|s




N(	R�ttempfiletmkstempR$tcloset
_mktemp_queueR*R�tappend(ReRXRYtfdR%R
((
R
s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytmktempts




	






c�s�yt�
��}Wn<t
k
rQ


|r/�n��
fd
�}|j|�

nX|jt�
�|�
|r�t||�}t|�
|�

nt�
�|�
dS(s=monkeypatch object value, restoring original value on cleanupc�s)yt�
��
Wnt
k
r$


n
XdS(
N(tdelattrtAttributeError((tattrtobj(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytcleanup�s




N(R�R
R�tsetattrRR(ReR
R
R{trequire_existingtwrapRPR
((R
R
s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt	patchAttr�s









N()R�R�R�R*R�R�RR�R�R>t_TestCase__unittest_skipR�R�R�R�R�R�R�tassertNotEqualstassertRegexMatchesR�R�tcatch_warningsR�R�R�R�R�R�R�R�t	threadingtLockR�R�R�R

R	
R
R=R
(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR-
sD	
				
	




+					@	tanycB�s�eZ
dZdYZdYZgZgZgZgZ	gZ
dZd[d\gZed�
ed�
d	gZ
eZeZeZeZed
��
ZeZed��
Zed��
Zd
�ZdYed�Zd�Zd�Zd�ZedYdYd�Z dYd�
Z!d�Z"d�Z#d�Z$dYdYd�Z%dZ&ed��
Z'ed��
Z(d�Z)d�Z*d�Z+d�Z,ed�
Z-d �Z.d!�Z/d"�Z0d#�Z1d$�Z2d%�Z3ed&��
Z4d'�Z5d(�Z6d)�Z7eZ8d*�Z9d+�Z:ed,��
Z;d-�Z<d.�Z=d/�Z>d0�Z?d1�Z@d2�ZAd3�ZBd4�ZCd5�ZDd6�ZEd7�ZFd8�ZGd9�ZHd:�ZId;�ZJd<�ZKd=�ZLd>�ZMd?�ZNd@�ZOdA�ZPdB�ZQdC�ZRdD�ZSdE�ZTdF�ZUdG�ZVdH�ZWdI�ZXdJ�ZYdK�ZZdL�Z[dM�Z\dN�Z]edO�
Z^dP�Z_edQ��
Z`edR��
Zad]ZbedT�
ZcdU�ZddVeef
dW��YZfdX�ZgRS(^s�
base class for testing password hash handlers (esp passlib.utils.handlers subclasses)

    In order to use this to test a handler,
    create a subclass will all the appropriate attributes
    filled as listed in the example below,
    and run the subclass via unittest.

    .. todo::

        Document all of the options HandlerCase offers.

    .. note::

        This is subclass of :class:`unittest.TestCase`
        (or :class:`unittest2.TestCase` if available).
    t	des_cryptt
6f8c114b58f2ct	md5_crypts"$1$dOHYPKoP$tnxS1T8Q6VVn3kpV8cN6o.tsha512_cryptsx$6$rounds=123456$asaltof16chars..$BtCwjqMJGx5hrJhZywWvt0RLE8uZ4oPwcelCjmw2kSYu.Ec6ycULevoBK25fs2xXgMNrCzIMVcgEJAstJeonj1ttests
\u20AC\u00A5$s€¥$c

C�s#d
t|j
dd�krdSdS(Ntos_cryptRRt
((R�RGR*(
R�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytforbidden_characters�s

c
C�s?|j}
|
j
}t|
d
�r;|d|
j�f
7}n|S(NRMs
 (%s backend)(RGR�RBRM(ReRGR�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�
s
	
	


c
c�syx"|jD]\}
}|
|fV
q
Wx%|j
D]\}}
}|
|fV
q/Wx%|jD]\}}
}|
|fV
qWWd
S(s*iterate through known (secret, hash) pairsN(tknown_correct_hashestknown_correct_configstknown_alternate_hashes(R�tsecretthashtconfigtalt((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytiter_known_hashess




c
C�s%t|j
��
}
|j�j|
�
S(
s#test random sample secret/hash pair(R�R,
R

tchoice(Retknown((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytget_sample_hash#s
cC�s�|j|
|�}|j
|tkp-|tkd
|f
�
|jjsM|r�|sWdS|spd|
|f}n|j|�
�
n2|r�dS|s�d|
|f}n|j|�
�
dS(s>helper to check verify() outcome, honoring is_disabled_handlers'verify() returned non-boolean value: %rNs4verify incorrectly returned True: secret=%r, hash=%rs!verify failed: secret=%r, hash=%r(t	do_verifyt
assertTrueR>R=RGtis_disabledR�(ReR(
R)
R�tnegateR�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytcheck_verify+s












cC�s!|j|
t
d
||
f�
dS(Ns'%s() failed to return native string: %r(R�Rr(ReR�t	func_name((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytcheck_returned_native_str>s

cC�s�|j}d
|j
kr�d
|
kr�|j}|j}tdd�
r[td|�|
d
<q�d}t|dd�dkr�||8}n|d|>}td||�|
d
<ndS(	s0subclassable method to populate default settingsRIR?R6itrounds_costtlog2i
N(RGRCRdtdefault_roundsR R?R�R*(ReRYRGtmntdftfactor((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytpopulate_settingsFs	

	
	




c
C�s|
S(
s?subclassable method allowing 'secret' to be encode context kwds((ReR(
RY((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytpopulate_contextYscK�s�|j|�

|dkr"i}n|j|
|�}
|r�g}|rc|j|�
|jd
�

n|j|�
�
|p|jj|
|�
SWdQXn"|p�|jj|�j	|
|�
SdS(s3call handler's hash() method with specified optionss"passing settings to.*is deprecatedN(
R=
R*R>
tupdateR

R�RGtencrypttusingR)
(ReR(
tuse_encryptRGtcontexttsettingsR�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt
do_encrypt^s


	







"cK�s.|j|
|�}
|p|j
j|
||�S(
scall handler's verify method(R>
RGtverify(ReR(
R)
RGRY((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR0
ps
cC�s|jj
|
�
S(
scall handler's identify method(RGtidentify(ReR)
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytdo_identifyusc
K�s|j|
�

|j
j|
�S(
s6call handler's genconfig method with specified options(R=
RGt	genconfig(ReRY((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytdo_genconfigys

cK�s(|j|
|�}
|j
j|
||�S(
s4call handler's genhash method with specified options(R>
RGtgenhash(ReR(
R*
RY((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt
do_genhash~s
cK�sf|
p|jj
|�}
|dkr-i}n|jd
|�}t|
�
�
|
j||�
SWdQXdS(s�
        return sample hash for handler, w/o caring if digest is valid
        (uses some monkeypatching to minimize digest calculation cost)
        RwN(RGRA
R*R>
RiR)
(ReRGRC
RD
R(
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytdo_stub_encrypt�s

	



sbackend not availablecC�sD|j}t
||
�r*td
�
r*dS|j|
�
r=dS|jS(s�
        helper for create_backend_case() --
        returns reason to skip backend, or None if backend should be tested
        R8s$only default backend is being testedN(RGRQR RSR*tBACKEND_NOT_AVAILABLE(R�RORG((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt_get_skip_backend_reason�s	




c
C�s�|j}|j
}t|d
�s-td�
�
|
|jksOtd|
f
�
�
|f
}|
dkrt|tf
7}ntd||
f|tdd||
fd|
d	|j��}|j	|
�
}|r�t
|�
|�
}n|S(
NRRs0handler must support uh.HasManyBackends protocolsunknown backend: %rR"
s
%s_%s_testR�s%s (%s backend)ROR�(RGR�RBR�RRtOsCryptMixinR_R�R�RO
R(R�RORGR�tbasestsubclstskip_reason((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytcreate_backend_case�s$	
	

"
	












c
C�s�tt
|�j�
|j}
|j}|rrt|
d
�sItd�
�
n|j|
j|
j	��
|
j|�

nddl
m}
|j|d|j
d�
�
dS(NRNs)handler doesn't support multiple backendsi����(
thandlersRssalt generator(R�R#R�RGRORBtRuntimeErrorR�RNRMR�RU
R
R

(ReRGRORU
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��s
	
	





c
�s�|j��f
d
�}
|
d�
}|j
|d�
|j|td�
|j
|j�|kd�
|j
tjd|�d|f
�
|
d�
}|j
|dk	d	�
|j|td
�
|
d�
}|j
|dk	d�
|j|td
�
dS(svalidate required attributesc

�st�|d�S(
N(R�R*(
R�(
RG(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytga�s
R�sname not defined:sname must be native strsname not lower-case:s^[a-z0-9_]+$s&name must be alphanum + underscore: %rRCssetting_kwds must be defined:ssetting_kwds must be a tuple:tcontext_kwdsscontext_kwds must be defined:scontext_kwds must be a tuple:N(	RGR1
R�RrR|RxtmatchR*R�(ReRW
R�RD
RC
((
RGs7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_01_required_attributes�s	









c
C�sr|j�}
|j
|
d
�
|jd|
�}|j
|d�
|jd|
�
|j|j|
�
d|
f
�
dS(s�test basic config-string workflow

        this tests that genconfig() returns the expected types,
        and that identify() and genhash() handle the result correctly.
        RI
tstubRK
Rws4identify() failed to identify genconfig() output: %rN(RJ
R6
RL
R0
R1
RH
(ReR*
R�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_02_config_workflow�s




c
C�s?|j}
|
j
�}|j||
�
|j|j|
j�
d
S(stest basic using() workflowN(RGRA
tassertIsNotR�R�(ReRGRR
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_02_using_workflows	


cC�sz
d
}xm
|jD]b
}|j
|d|
�

}|j|d�
|j||�
|j||dt�

|j||�}|j|d�
|jjr�|jr�|j	||d|||f�
n |j
||d|||f�
|j||�}|j|d�
|jjr9
|jr9
|j
||d||||f�
n#|j	||d	||||f�
|j|j|�
�

qWd
S(s�test basic hash-string workflow.

        this tests that hash()'s hashes are accepted
        by verify() and identify(), and regenerated correctly by genhash().
        the test is run against a couple of different stock passwords.
        R[
RB
R)
R3
RK
sBgenhash() failed to salt result hash: secret=%r hash=%r: result=%rs@genhash() failed to reproduce hash: secret=%r hash=%r: result=%rsYgenhash() failed to reproduce disabled-hash: secret=%r hash=%r other_secret=%r: result=%rsGgenhash() duplicated hash: secret=%r hash=%r wrong_secret=%r: result=%rN(
tstock_passwordsRE
R6
R4
R>RL
RGR2
tdisabled_contains_salttassertNotEqualR�R1
RH
(Ret
use_16_legacytwrong_secretR(
R�tother((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_03_hash_workflow"s*








c

C�s|jd
t
�

dS(sEtest hash-string workflow with legacy .encrypt() & .genhash() methodsRb
N(Re
R>(
Re((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_03_legacy_hash_workflowYsc
C�s=
|jt
d
�
�
}
|j|
d�
|jd
t
|
�
�
|jt
d
�
t
|
�
�
|jd
t
|
�
�}|j|d�
|jjr�|jr�|j||
�
n|j	||
�
|jt
d
�
t
|
�
�}|j|d�
|jjr

|jr

|j||
�
n|j	||
�
|j
|jt
|
�
�
�

dS(s#test hashes can be unicode or bytesR[
R)
RK
N(RE
RvR6
R4
RL
RGR2
R`
Ra
R�R1
RH
(ReR�Rd
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_04_hash_types]s






c
C�s

|j}
t
|
d
�s*|jd�
�
n|j|
j|
j��
x�|
jD]�}|j|t�
|j	|t
d|f
�
|
j|�
}|tkr�|
j|�

|j
|
j�|�
qM|tkr�|jt|
j|�
qMtd||f�
�
qMWdS(stest multi-backend supportRNshandler only has one backendsinvalid backend name: %rs*has_backend(%r) returned invalid value: %rN(RGRBR�R�RNRMRRR�RrtassertNotIntRESERVED_BACKEND_NAMESRSR>R�R=R�R
R�(ReRGROtret((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_05_backends�s"	









c

C�s(d
|jj
kr$|jd�
�
ndS(Ntsaltshandler doesn't have salt(RGRCR�(
Re((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytrequire_salt�s

c

C�s/|j�
t
|j�
s+|jd
�
�
ndS(Ns!handler doesn't provide salt info(Rm
RRGR�(
Re((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytrequire_salt_info�s



c
	C�s�
|j�
|j
}
|j}|jd
k	}|rO|jd
krO|
d�
�
n|jdkrm|
d�
�
n|r�|j|jkr�|
d�
�
n|j|jkr�|
d�
�
n|r�|j|jkr�|
d�
�
nd|jkr
|s
|j|jkr
td	|j	f
�

n|j
rx
|js<
|
d
�
�
nxQ|jD]+}||j
krF
|
d|f
�
�
qF
qF
Wn|js�
|
d�
�
nd
S(s!validate optional salt attributesi
smax_salt_chars must be >= 1ismin_salt_chars must be >= 0s(min_salt_chars must be <= max_salt_charss*default_salt_size must be >= min_salt_sizes*default_salt_size must be <= max_salt_sizet	salt_sizesT%s: hash handler supports range of salt sizes, but doesn't offer 'salt_size' settings$default_salt_chars must not be emptysEdefault_salt_chars must be subset of salt_chars: %r not in salt_charss;default_salt_chars MUST be specified if salt_chars is emptyN(Rn
R�RGt
max_salt_sizeR*t
min_salt_sizetdefault_salt_sizeRCRR�t
salt_charstdefault_salt_chars(ReR�R�tmx_sett
c((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt test_10_optional_salt_attributes�s2

	
	







(

	
	



	
c
C�s[|j}
t
|
�
s(td
|
j�
�
ddlm}
t|
j|t|
j	�
d��
S(s%calculate number of salt bits in hashsneed explicit bit-size for i����(
R�i(
RGRR�R�R�R�R�Rr
R�Rt
(ReRGR�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt	salt_bits�s
	

	
c
�sV�
j�
t
d
d�
j����
fd�}
|
�
j�

|
�
f
d��

dS(s4test hash() / genconfig() creates new salt each timei
iic
�sS|�}
x-t��
D]}|�}|
|krdSqW�
j
d
�f
�
�
dS(Ns.failed to find different salt after %d samples(RR�(R�tvalue1R2tvalue2(tsamplesRe(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytsampler�s
	

	


	
c�s
�jd
�
S(NR[
(
RE
((
Re(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt<lambda>�sNi(Rm
R?Rx
RJ
(ReR|
((R{
Res7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_11_unique_salt�s



c
C�s�|j�
|j
}
|
jd
d!}|
j}||}|jd|�

|jdd|�


|d
kr�|jt|jd|d �

n|jt|jdd|d�

dS(s.test hash() / genconfig() honors min_salt_sizeii
Rl
R[
Ro
i����N(Rn
RGRs
Rq
RJ
RE
R�t
ValueError(ReRGt	salt_chartmin_sizets1((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_12_min_salt_size�s
	

	




c
	
C�s�
|j�
|j
}
|
j}|
jd
d!}|d	ksD|dkr�|d}|jd|�
}|jd||�
}|j||�
|jdd�

n�||}|jd|�
}|jd|�

||}|jt|jd|�

|jt|jd|d�

t	|
�
rU
t
jdt�
�
|jd|dt�}Wd	QX|j
||�
n|
j|kr�
|jd|d
 �
}|j||�
nd	S(s.test hash() / genconfig() honors max_salt_sizeii
iiRl
Ro
R�RANi����i(Rn
RGRp
Rs
R*RM
Ra
R�R
RHR�R
R>R�Rq
(	ReRGtmax_sizeR�
R�
tc1tc2ts2tc3((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_13_max_salt_sizes.
	
	













cC�s/|jr+d
dl
m}
|j|
�
}
n|
S(sprepare generated salti����(
tbcrypt64(tfuzz_salts_need_bcrypt_repairtpasslib.utils.binaryR�
t
repair_unused(ReRl
R�
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytprepare_saltQs	


c


C�s!
|j�
|j
}
|
j}|
j}|
j}t|t�}x`t||pOd
�D]I}t|�
|kr}t	||�}n|j
|�
}|jd|�

qSWtd�
}|r�|j
d�
}nt|d�}xG|D]?}	|	|kr�|jt|jd|	|dd|	f
�
q�q�WdS(	stest hash() honors salt_charsi Rl
t�slatin-1i
R�sinvalid salt char %r:N(Rn
RGRp
Rq
Rs
R\tbytesRR�RR�
RM
RRkR?R�R
(
ReRGtmxR:
tcstrawRl
RutchunkRv
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_14_salt_charsXs&
	
	
	
	












c

C�s!t|j
d
t�rtStSdS(s)hack to determine salt keyword's datatypet_salt_is_bytesN(R�RGR=R�
R(
Re((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt	salt_typess
c

C�s�|j�
|j
}
t|jd
d�p+d}dtf
d��Y}|jt|jdd|��

|
tk	r�|jt|jddt	d�
|�

n|
t
kp�to�|
tks�|jt|jddd|�

nd	S(
stest non-string salt valuesRq
iitfakec
B�seZ
RS((R�R�(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�
�s
R[
Rl
t
xN(Rm
R�
R�RGtobjectR�R�RE
RRR�
R(ReR�
Ro
R�
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_15_salt_type|s

	

)
c

C�s|j�
|j
}
|
j}|
j}|
j}|jt|
jd
d�

|jt	g
�
�
|
jd
ddt
�}WdQX|j|j|�
|r�|jt|
jd
|d�

|jt	g
�
�!
|
jd
|ddt
�}WdQX|j|j|�
n||kr�
|
jd
|d�
}|j|j|d�
|j|
j|�
|
jd
|d�
}|j|j|d�
|j|
j|�
n||kr�
|}n
|d}|
jd
t|�
�
}|j|j|�
|jt|
jd
t|�
d�

|
jd|�
}|j|j|�
dS(	s$Handler.using() -- default_salt_sizeRr
i����RANi
itxxxRo
(
Rn
RGRq
Rp
Rr
R�R
RA
R�RR>R�Rr(ReRGR:
R�
R;
ttemptref((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_using_salt_size�s:
	
	
	
	





"






	


#
c

C�s%t|j
�
s!|jd
�
�
ndS(Nshandler lacks rounds attributes(RRGR�(
Re((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytrequire_rounds_info�s

c
C�s
|j�
|j
}
|j}|
jd
kr:|d
�
�
n|
jdkrX|d�
�
n|
jdkrv|d�
�
n|
j|
jkr�|d�
�
n|
jd
k	r�|
j|
jkr�|d�
�
n|
j|
jkr�|d�
�
q�n|
jtkr
|d	|
jf
�
�
nd
S(s#validate optional rounds attributessmax_rounds not specifiedi
smax_rounds must be >= 1ismin_rounds must be >= 0s min_rounds must be <= max_roundss$default_rounds must be >= min_roundss$default_rounds must be <= max_roundss unknown rounds cost constant: %rN(	R�
RGR�t
max_roundsR*RdR9
R7
R(ReR�R�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt"test_20_optional_rounds_attributes�s$
	
	










c
C�s�|j�
|j
}
|
j}|jd
|�

|jdd
|�


|jt|jd
|d�

|jt|jdd
|d�

dS(s+test hash() / genconfig() honors min_roundsRIR[
i
N(R�
RGRdRJ
RE
R�R
(ReRGRd((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_21_min_rounds�s

	
	

c
C�s�|j�
|j
}
|
j}|dk	rh|jt|jd
|d�

|jt|jdd
|d�

n|dkr�|jd
d�

n|jd
|�

dS(s+test hash() / genconfig() honors max_roundsRIi
R[
iNI�i���(	R�
RGR�
R*R�R
RJ
RE
RM
(ReRGR�
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_21b_max_rounds�s

	
	
#
c


�s?
|j�
|j
}
|
jd
krO|
�|
j�}
t�f
d��
|
_n|
j}|
j}|
j}|psd|d}||kr�|d7}n||d}|p�d|d}|
jd
kr�|dO}|dO}|dO}d}nd}|j	g�
�#
|
jd|d|d|�}	Wd	QX|
|	||||fS(
sU
        setup test helpers for testing handler.using()'s rounds parameters.
        t
bsdi_cryptc

�st�|�j
�S(
N(R�t_generate_rounds(
R�(
torig_handler(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR}
si'ii
tmin_desired_roundstmax_desired_roundsR9
N(
R�
RGR�RA
tclassmethodR�
RdR�
R9
R�(
ReRGtorig_min_roundstorig_max_roundstorig_default_roundstmediumtsmalltlargetadjRR
((
R�
s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt_create_using_rounds_helper
s4

	

	
	
	











	
	


c

C�s
|j�
|j
}
|
j}|
j}|
j}|j�\}
}}}}}	|j|
j|�
|j|
j|�
|j|
jd
�
|j|
j	d
�
|j|
j|�
|j|j|�
|j|j|�
|j|j|�
|j|j|�
|j|j	|�
d
S(s@
        HasRounds.using() -- sanity check test harness
        N(
R�
RGRdR�
R9
R�
R�R�
R*R�
(
ReRGR�
R�
R�
RR
R�
R�
R�
R�
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_has_rounds_using_harness5s 

	
	
	
	








c

C�s�|j�\}
}}}}}|
j
}|
j}|
j}	|d
kr�|jt|
jd||�

|jtg
�
�!
|
jd||dt	�}
WdQX|j
|
j|�
n|r
|jt|
jd||�

|jtg
�
�!
|
jd||dt	�}
WdQX|j
|
j|�
n|jg�
�
|jd||�
}
WdQX|j
|
j||�
|jd|d|�
}
|j
|
j|d|�
|jg�
�
|jd||�
}
WdQX|j
|
j||�
|j
t|||�||�
|j
t||�|�
|jg�
�&
|j
t|||�||�
WdQX|
jd|�
}
|j
|
j|�
|
jdt
|�
�
}
|j
|
j|�
|jt|
jdt
|�
d�

dS(sF
        HasRounds.using() -- min_rounds / min_desired_rounds
        iR�
RANiRdR�
(R�
RdR�
R9
R�R
RA
R�RR>R�R�
RLRr(ReRGRR
R�
R�
R�
R�
R�
R�
R�
R�
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt"test_has_rounds_using_w_min_roundsOs>
	
	
	


"



"





!


'

c


C�s�|j�\}
}}}}}|
j
}|
j}|d
kr�|jt|
jd||�

|jtg
�
�!
|
jd||dt�}	WdQX|j	|	j
|�
n|r
|jt|
jd||�

|jtg
�
�!
|
jd||dt�}	WdQX|j	|	j
|�
n|jtg
�
�
|jd||�
}	WdQX|j	|	j
|�
|jt|jd||d||�
|jd|d|�
}	|j	|	j|d|�
|jg�
�
|jd||�
}	WdQX|j	|	j
||�
|j	t
|||�||�
|j	t
||�|�
|jg�
�&
|j	t
|||�||�
WdQX|
jd|�
}	|j	|	j
|�
|
jdt|�
�
}	|j	|	j
|�
|jt|
jdt|�
d�

dS(	sF
        HasRounds.using() -- max_rounds / max_desired_rounds
        iR�
RANR�
iR�
R�
(R�
RdR�
R�R
RA
R�RR>R�R�
RR�
RLRr(
ReRGRR
R�
R�
R�
R�
R�
R�
R�
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt$test_has_rounds_replace_w_max_rounds�sB
	
	


"



"








!


'

c
	C�sM
|j�\}
}}}}}|
j
}|jd
||�
}|j|j||�
|jd||�
}|j|j||�
|jt|jd||�

|r�|jt|jd||�

n|jt|�
|�
|jt|||�||�
|
jdt|�
�
}|j|j|�
|jt|
jdt|�
d�

dS(s5
        HasRounds.using() -- default_rounds
        RdR�
R9
R�
N(	R�
R�
RA
R�R9
R�R
RLRr(	ReRGRR
R�
R�
R�
R�
R�
R�
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt&test_has_rounds_using_w_default_rounds�s
	


 
!
c
	
C�s�|j�\}
}}}}}|
j
}|jd
||�
}|j|j||�
|j|j||�
|j|j||�
|jd
|dd||d|d||�}|j|j||�
|j|j|�
|j|j||�
dS(s-
        HasRounds.using() -- rounds
        RIi
RdR9
R�
N(R�
R�
RA
R�R�
R9
R�
(	ReRGRR
R�
R�
R�
R�
R�
R�
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_has_rounds_using_w_rounds�s
	






c
�s�|j�\}
�}}}}�f
d
�}|j
|d�
d�
|j
|d�
d�
|j
|d�
d�
|j
|d�
d�
|j
|d�
d�
|jt|d�
|jt|d�
d	S(
s:
        HasRounds.using() -- vary_rounds parsing
        c

�s�jd
|�
j
S(Ntvary_rounds(RA
R�
(
R{(
RR
(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytparses
g�������?s0.1s10%i�t1000g��������g�������?N(R�
R�R�R
(ReRGR�
R�
R�
R�
R�
((
RR
s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt+test_has_rounds_using_w_vary_rounds_parsing�s


c
	�sz
�
j�\}
�}}}}d
����
�fd�}|d||�
|d||�
||||||�
|dt
||d�t||d��
|
jdkr�|d||�
|d||�
|d	|||�
n���jd
d	�
�
\}}�
j|t
||d��
�
j|t
||d��
�
j|t||d
��
�
j|t||d��
dS(s=
        HasRounds.using() -- vary_rounds generation
        c
�s8t�f
d
�t
d�
D�
�
}
t|
�
t|
�
fS(Nc
3�s|]}
t��
V
qdS(
N(
RL(R1R2(
R�(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pys	<genexpr>si�(tsetRR3R?(R�tseen((
R�s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytget_effective_ranges
"
c�sN�jd
|�
}�|�
\}}�
j
||
d�
�
j
||d�
dS(NR�
s"vary_rounds had wrong lower limit:s"vary_rounds had wrong upper limit:(RA
R�(R�
R|R}R�
t
seen_lowert
seen_upper(R�
ReRR
(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytassert_rounds_range!s



is0%i2R8
s1%s49%s50%R�
g�?g�������?g333333�?g�?N(R�
R?R3R7
RA
tassertGreaterEqualtassertLessEqual(	ReRGR�
R�
R�
R�
R�
R|R}((R�
ReRR
s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt.test_has_rounds_using_w_vary_rounds_generations 	

*



c
C�s
|j�\}
}}}}}|j
d
|dd|d�}|j|d|�

}|j|d|�

}	|j|d|�

}
|j|j|�
�

|j|j|	�
�

|j|j|
�
�

|j|j|�
�

|j|j|	�
�

|j|j|
�
�

dS(sF
        HasRounds.using() -- desired_rounds + needs_update()
        R�
iR�
RIN(R�
RA
RM
tassertFalsetneeds_updateR1
(ReRGRR
R�
R�
R�
R�
R�
t
small_hashtmedium_hasht
large_hash((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt&test_has_rounds_using_and_needs_update@s 





c
C�sB|j}
t
|
t�s,t|
tj�r>|jd
�
�
ndS(Ns)handler doesn't derive from HasManyIdents(RGR\R_RDREt
HasManyIdentsR�(ReRG((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytrequire_many_identsZs
	
#
c
C�s�
|j}
|j
�
|jd
|
jk�

x$|
jD]}|j|td�
q3W|jt|
j�
dkd�
|j|
jtd�
|j|
j|
jkd�
|
j	r
xft
|
j	�
D]R\}}|j|td�
|j|td�
|j||
jkd	|f
�
q�Wn|
}|j�d}|j|�
}|d
=|d
|
j|�

|j
t||�
|d
t|�

|j
t|d
d|�

dS(
s$validate HasManyIdents configurationtidents!cls.ident_values must be unicode:i
s'cls.ident_values must have 2+ elements:s"cls.default_ident must be unicode:s9cls.default_ident must specify member of cls.ident_valuess'cls.ident_aliases keys must be unicode:s)cls.ident_aliases values must be unicode:s:cls.ident_aliases must map to cls.ident_values members: %rRJtxXxN(RGR�
R1
RCtident_valuesR�RR�t
default_identt
ident_aliasesRR/
t	parsehashR�R�R>R
(ReR�R{taliasR�
RGR)
RY((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_30_HasManyIdents_s8	








	









c
C�s�
|j�
|j
}
|
j}x:|
jD]}||kr&Pq&q&Wtd
||
jf�
�
d�}|
j�}|j|j|�
|
jd|�
}|j|j|�
|j|
j|�
|j||�
|�
|j||
�
|�
|jt|
jdd�

|
jd|�
}|j|j|�
|j|
j|�
|jt	|
jd|d|�
|
j
r�
xO|
j
j�D];\}}|
jd|�
}|j|j|dd|�

qn
WndS(	s=HasManyIdents.using() -- 'default_ident' and 'ident' keywordss6expected to find alternate ident: default=%r values=%rc

S�st|�
}|d
t
�
jS(NRJ(RKR>R�
(
R�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyteffective_ident�s

R�
R�
R�
R�s	alias %r:N(R�
RGR�
R�
R�RA
R�R�R
R�R�
titems(ReRGt
orig_identt	alt_identR�
RR
R�
R�
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_has_many_idents_using�s2
	
	



	





	


c
�s
|j��j
dkr/|jd
�j�
dS�jsK|j�j�

nd
�jkrn|j�j�

dS�f
d�}
|j	|
d�
�j�
|j	|
t
�
t
�
|j	|
d�
t
�
|j	|
t�
t�
|j	|
d�
t�
|jt
|
d�
dS(sH
        validate 'truncate_error' setting & related attributes
        ttruncate_errorNc

�s�jd
|�
j
S(NR�
(RA
R�
(
R{(
thasher(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytparse_value�s
ttruetfalseR�
(RGt
truncate_sizeR*Rh
RCR�
R�
ttruncate_verify_rejectR1
R�R>R=R�R
(ReR�
((
R�
s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_truncate_error_setting�s 	


	







c
C�s�|j}
|
j
d
k	r=|j|
j
d
�
|jd�
�
ndd}d}|j|�
}|
j}|j|j||�|dd�

|d |}|j	|j||�d	�
d
S(sO
        test no password size limits enforced (if truncate_size=None)
        i
struncate_size is setstoo many secretsiR�
R�sverify rejected correct secreti����s full password not used in digestN(
RGR�
R*R�
R�RE
R2
R�R0
R�
(ReR�
R(
R+
R)
tverify_successt
alt_secret((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_secret_wo_truncate_size�s	


	







c
	C�sX|j}
|
j
}|s*|jd
�
�
ntj}d|
jkrr|
jdt�
}|
jdt�
}tj	}n$|
j
r�d	}|
}n|
}d	}d}d}t||d�}|d }	|d |}
|	d |}|
j
}|o�|
j}
|s
|s
t�
x�||gD]�}|j|	d|�

}|j|j|	|d|�
|�
|j|j||d|�
d�
|j|j||d|�
|
�
q
W|r|j|d|�

}|j|j||d|�
|�
|j|j|
|d|�
|�
|j|j|	|d|�
�

n|rT|j||j|d|�
}|j|j|�
nd	S(
sQ
        test password size limits raise truncate_error (if appropriate)
        struncate_size not setR�
stoo many secretsR�
i
i����RGs truncate_size value is too largeN(RGR�
R�R	tPasswordSizeErrorRCRA
R=R>tPasswordTruncateErrorR�
R*RR2
R�
R�RE
R�R0
R�
R1
R�R�
(ReRGR�
tsize_error_typet
without_errort
with_errorRbR+
tlong_secrettshort_secrettalt_long_secrettalt_short_secrettshort_verify_successtlong_verify_successtcand_hashert
short_hasht	long_hashR�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_secret_w_truncate_sizesb	
	

	




	

	

























c
C�sE
|jt
k}
|jt
d
gk}d}d}|j|�
}|rq|jjrq|j|j||�d�
n|j|j||�d�
|j|�
}|r�|jjr�|j|j||�d�
n|j|j||�d�
|j||�}|
s
|jjr.
|j	r.
|j
||d�
n|j||d�
dS(	stest password case sensitivitysverify-onlyR!
tTESTs%verify() should not be case sensitives!verify() should be case sensitives&genhash() should not be case sensitives"genhash() should be case sensitiveN(tsecret_case_insensitiveR>RE
RGR2
R1
R0
R�
RL
R`
R�Ra
(Rethash_insensitivetverify_insensitiveR|R}th1th2((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_61_secret_case_sensitivets.
	

















c
C�s�|j�d
}
|j
t|jd�
|j
t|jd|
�
|j
t|jd|
�
|j
t|jd
�
|j
t|jd
|
�
|j
t|jd
|
�
dS(s&test non-string passwords are rejectedi
N(R/
R�R�RE
R*RL
R0
(ReR)
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_62_secret_border�s



c
C�s�d
dlm
}

d
dlm}
dd|}|j�d}|j|
|j||�}|j|j|�
|j|
|j	|�
|j|
|j
||�
dS(s"test MAX_PASSWORD_SIZE is enforcedi����(
R�
(
tMAX_PASSWORD_SIZEt
.i
N(tpasslib.excR�
R�R�
R/
R�RL
R�R�
RE
R0
(ReR�
R�
R(
R)
R�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_63_large_secret�s






c
C�s�|j}
|
s!|j
d
�
�
ntd�
}t|
t�rjddlm}
||
�
}
|jd�
}nx,|
D]$}|jt	|j
|||�
qqWdS(s1test forbidden characters not allowed in passwordsnone listedR[
i����(
titer_byte_charstasciiN(R$
R�RR\R�
tpasslib.utils.compatRRkR�R
RE
(RetcharsRbRRv
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_64_forbidden_chars�s	









cC�s|j|
i�}
t
|
�
S(
N(R>
R(ReR(
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytis_secret_8bit�s

cC�sQtrM|j
d
krMt|
t�rMy|
jd�

WqMtk
rI


tSXntS(sl
        check if we're expecting potential verify failure due to crypt.crypt() encoding limitation
        R"
sutf-8(RROR\R�
RsRtR>R=(ReR(
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytexpect_os_crypt_failure�s$





c

C�sL
|j|j
p|jd
�
t}
x	
|j�D]�\}}|j|�
rSt}
n|j|j|�
d|f
�
|j|�
}y�|j	||d||f�
|j
||�}|j|td|f
�
|j
jr�|jr�w/n|j||d|||f�
Wq/tk
r)



|s*
�q*
q/Xq/W|
sH
td|j�

ndS(stest known hashessOtest must set at least one of 'known_correct_hashes' or 'known_correct_configs's&identify() failed to identify hash: %rs1verify() of known hash failed: secret=%r, hash=%rs,genhash() failed to return native string: %rsGgenhash() failed to reproduce known hash: secret=%r, hash=%r: result=%rs%s: no 8-bit secrets testedN(R1
R%
R&
R=R,
RR>RH
RR4
RL
R�RrRGR2
R`
R�R
Rt	__class__(Retsaw8bitR(
R)
RR�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_70_hashes�s0



	











c

C�s�|js|j
d
�
�
nx�|jD]�\}
}}|j|j|�
d|f
�
|j||
d||
f�
|j||
�}|j|td|f
�
|jj	r�|j
r�q%n|j||d||
||f�
q%WdS(stest known alternate hashessno alternate hashes provideds0identify() failed to identify alternate hash: %rs;verify() of known alternate hash failed: secret=%r, hash=%rs,genhash() failed to return native string: %rsYgenhash() failed to normalize known alternate hash: secret=%r, alt=%r, hash=%r: result=%rN(R'
R�R1
RH
R4
RL
R�RrRGR2
R`
R�(ReR+
R(
R)
R�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_71_alternates�s	









c
	C�s!
|jj
s1|j|jd
�
|jd�
�
n|jsL|jd�
�
n|jrktjddt�


nx�|jD]�\}
}}|j	|j
|
�
d|
f
�
|jt|j
||
dd|
f
�

|j||
�}|j|td	|f
�
|j||d
||
||f�
quWdS(stest known config stringss&handler should not have config stringsshash has no settingssno config strings providedR�R�s5identify() failed to identify known config string: %rR�s+verify() failed to reject config string: %rs,genhash() failed to return native string: %rs^genhash() failed to reproduce known hash from config: secret=%r, config=%r, hash=%r: result=%rN(RGRCR�
R&
R�tfilter_config_warningsR�R�RR1
RH
R�R
R0
RL
R�RrR�(ReR*
R(
R)
R�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_72_configs	s(


		








c
	C�s�|js|j
d
�
�
nx}|jD]r}
|j|j|
�
d|
f
�
|jt|jd|
dd|
f
�

|jt|jd|
dd|
f
�

q%WdS(s)test known unidentifiably-mangled stringssno unidentified hashes provideds?identify() incorrectly identified known unidentifiable hash: %rR[
R�s:verify() failed to throw error for unidentifiable hash: %rs;genhash() failed to throw error for unidentifiable hash: %rN(tknown_unidentified_hashesR�R�
RH
R�R
R0
RL
(ReR)
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_73_unidentified;	s	







c
	C�s�|js|j
d
�
�
nx}|jD]r}
|j|j|
�
d|
f
�
|jt|jd|
dd|
f
�

|jt|jd|
dd|
f
�

q%WdS(s-test known identifiable-but-malformed stringssno malformed hashes provideds6identify() failed to identify known malformed hash: %rR[
R�s5verify() failed to throw error for malformed hash: %rs6genhash() failed to throw error for malformed hash: %rN(tknown_malformed_hashesR�R1
RH
R�R
R0
RL
(ReR)
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_74_malformedP	s	







c

C�s:
|jr|j
d
�
�
n|js6|j
d�
�
nx�|jD]�\}
}|
|jjkr�|j|j|�
d|f
�
|jd|�
|jd|�}|j	|t
d|f
�
q@|j|j|�
d|
|f�
|jt
|jd|dd|
|f�

|jt
|jd|dd	|
|f�

q@Wd
S(stest known foreign hashessnot applicablesno foreign hashes provideds,identify() failed to identify known hash: %rR[
s,genhash() failed to return native string: %rs:identify() incorrectly identified hash belonging to %s: %rR�s;verify() failed to throw error for hash belonging to %s: %rs<genhash() failed to throw error for hash belonging to %s: %rN(taccepts_all_hashesR�tknown_other_hashesRGR�R1
RH
R0
RL
R�RrR�
R�R
(ReR�R)
R�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_75_foreigne	s*	

	











c
C�sv
|jt
|jd�
|jt
|jd
d�
|jt
|jd
d�
|jt
|jd�
|jt
|jd
d�
|jt
|jd
d�
x�td�
dgD]�}
|jr�|j|j|
�
�

|jd
|
�
|jd
|
�}|j	|d�
q�|j
|j|
�
d�
|jt|jd
|
dd�

|jt|jd
|
dd�

q�W|jd	�

|jd
�

dS(s#test non-string hashes are rejectedR[
i
RwRK
s,identify() incorrectly identified empty hashR�s$verify() failed to reject empty hashs%genhash() failed to reject empty hashs€¥$sabc�N(R�R�RH
R*R0
RL
RRR1
R6
R�
R
(ReR)
R�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_76_hash_border�	s(



	









c
�s�|jj
r|jd
�
�
nddlm}
|j}|dk
rU|jd�
�
n|jd|
�
}d��|
r�tj�j	}nd}|j
d	|�
}|j||�}tj
d
|j||t|�
dj�f
d�|D�
�
�
|�}||}	d}
x[
|�|	k
rf|j�}|d
}|d}
|d}|d}|rb
||d<n|j||�
}x�|D]�}�|�
}||||�}|dkr�
q{
n|tks�
|tks�
t�
|s�
|jd||||f�
�
n|j�dkr{
||
||�}|rU|dkrU|jd||
|||f�
�
qUq{
q{
W|
d7}
q
Wtj
d|j||�||
�
dS(sfuzz testing -- random passwords and options

        This test attempts to perform some basic fuzz testing of the hash,
        based on whatever information can be found about it.
        It does as much as it can within a fixed amount of time
        (defaults to 1 second, but can be overridden via $PASSLIB_TEST_FUZZ_TIME).
        It tests the following:

        * randomly generated passwords including extended unicode chars
        * randomly selected rounds values (if rounds supported)
        * randomly selected salt sizes (if salts supported)
        * randomly selected identifiers (if multiple found)
        * runs output of selected backend against other available backends
          (if any) to detect errors occurring between different backends.
        * runs output against other "external" verifiers such as OS crypt()

        :param report_thread_state:
            if true, writes state of loop to current_thread().passlib_fuzz_state.
            used to help debug multi-threaded fuzz test issues (below)
        snot applicablei����(
Risdisabled by test modetthreadedc

S�s|jp|j
j�d
S(Ni(R�R�t
splitlines(
t
v((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytvname�	s
s	fuzz testR�s.%s: %s: started; max_time=%r verifiers=%d (%s)s, c
3�s|]}
�|
�
V
qdS(
N((R1R(
R(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pys	<genexpr>�	sR(
Rd
RD
RC
RsAfailed to verify against %r verifier: secret=%r config=%r hash=%rg�������?s\was able to verify wrong password using %s: wrong_secret=%r real_secret=%r config=%r hash=%ri
s!%s: %s: done; elapsed=%r count=%rN(RGR2
R�R�Rt
max_fuzz_timetget_fuzz_verifiersR
tcurrent_threadR�R

tFuzzHashGeneratorR�tdebugR�R�R�tgenerateRE
R>R=R�R�R�(ReRRtmax_timet	verifierstthread_nameRt	generatorR-tstopR�toptsR(
Rd
RD
R�R)
RF
R�R�((
Rs7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_77_fuzz_input�	sZ

	



	


	

 
	






















	


	#
	
c
�s�
�jd
�

ddl
��jjr7�jd�
�
n�j}
|
dks[�jdk
rm�jd�
�
n�j��
dg
���
�fd����fd	�}gt|
�
D]}||�
^q�}�j|
d
}d}xM|D]E}|j	|�

|j
�s
q�ntjd|j
|�
|d7}q�W�dr_
�jd�d|
f�
�
n|r�
�jd
||
f�
�
ndS(s�multithreaded fuzz testing -- random password & options using multiple threads

        run test_77 simultaneously in multiple threads
        in an attempt to detect any concurrency issues
        (e.g. the bug fixed by pybcrypt 0.3)
        R8i����Nsnot applicablei
isdisabled by test modec�sRy�jd
t
�

Wn7tk
r'


n'


�
�
�dcd7<WdQX�n
XdS(NRii
(R%R>R((tfailedtfailed_lockRe(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRf*
s








c
�s@d
|f
}
�jd�
d|
�}|j
t�

|j�
|S(NsFuzz-Thread-%dttargetR�(tThreadt	setDaemonR>R-(t
nR�tthread(R
Rf(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytlaunch3
s








is%s timed out after %f secondssH%d/%d threads failed concurrent fuzz testing (see error log for details)sP%d/%d threads stalled during concurrent fuzz testing (see error log for details)(R�R
RGR2
R�tfuzz_thread_countRR
RR�tis_aliveR�terrorR�tfail(Retthread_countR-R+tthreadsttimeouttstalledR,((R&R'ReR
Rfs7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_78_fuzz_threading
s4



	


		%









	


	
c
C�sVtt
jjd
�
pd�
}
|
r(|
Stdd�
r;dStdd�
rNdSdSdS(	s'amount of time to spend on fuzz testingtPASSLIB_TEST_FUZZ_TIMEiR?R6R7i
iN(tfloatR$R�R�R (ReR{((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRR
s





c
C�sCtt
jjd
�
pd�
}
|
r(|
Stdd�
r;dSdSdS(s+number of threads for threaded fuzz testingtPASSLIB_TEST_FUZZ_THREADSiR?R6i
N(R�R$R�R�R (ReR{((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR._
s



tfuzz_verifier_defaultc�s�|j�g}x?|j
D]4}t||��}|dk	r|j|�

qqWt�d
�r�td�
r�|
r��f
d�}x*t��
D]}|j||�
�

q�Wn|S(s�return list of password verifiers (including external libs)

        used by fuzz testing.
        verifiers should be callable with signature
        ``func(password: unicode, hash: ascii str) -> ok: bool``.
        RRR8c
�s4��
fd
�}
d�d|
_�d|
_
|
S(Nc�sB�
j�}z!�
j
��

�
j||
�SWd�
j
|�

XdS(
N(RMRNRF
(R(
R)
torig_backend(RORG(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��
s





tcheck_t_backends-backend(R�R�(ROR�(
RG(
ROs7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytmaker�
s



N(RGtfuzz_verifiersR�R*R

RBR RW(ReRR tmethod_nameR�R>RO((
RGs7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRs
s	



"

c
�s8�f
d
�}
�jr+�jd|
_
n	d|
_
|
S(Nc�s�j||
|�S(
N(
R0
(R(
R)
R�(
Re(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt
check_default�
s
s-backendRe(ROR�(ReRA((
Res7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR:�
s
	
	
RcB�s�eZ
dZed
�
ZdZedddddd�ZiZd	�Z	d
�Z
d�Zd�Zd
�Z
d�Zd�Zd�Zd�ZRS(s�
        helper which takes care of generating random
        passwords & configuration options to test hash with.
        separate from test class so we can create one per thread.
        s.qwertyASDF1234<>.@*#! \u00E1\u0259\u0411\u2113sutf-8RIt
random_roundsRo
trandom_salt_sizeR�
trandom_identcC�s"|
|_|
j
|_
||_dS(
N(R!
RGR(ReR!
R((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��
s
	

c

�sR�f
d
�}
�j�\}}t
d|d|d|
�j�
d|
�j�
�S(s�
            generate random password and options for fuzz testing.
            :returns:
                `(secret, other_secret, settings_kwds, context_kwds)`
            c
�sai}
xT|j�D]F\}}t
�|�}t
�|��}|dk	r||
|<qqW|
S(
N(R�
R�R*(tmaptouttkeytmethR�R{(
Re(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytgendict�
s






R(
Rd
RD
RC
(trandom_password_pairR�tsettings_maptcontext_map(ReRIR(
Rd
((
Res7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�
s



cC�s+|jj
||�}tt||
|��
S(
s)generate random int w/ gauss distirbution(Rt
normalvariateR�R~(ReR|R}tmutsigmaR{((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytrandintgauss�
s
c
C�s||j}
t
|
�
sdS|
jp(|
j}|
j}|
jd
krL|}nt|d|
j�}|j||||d�S(NR8
ig�?(	RGRR*R9
RdR7
R3R�
RP(ReRGR7R|R}((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRB�
s
	



	

	
c
C�sg|j}
t
|
�
o!d
|
jks(dS|
j}|
j}|
jpJ|d}|j||||d�S(NRo
ig�?(RGRRCR*Rr
Rq
Rp
RP(ReRGR7R|R}((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRC�
s
	


	
	

c
C�sm|j}
|j
}d
|jks1t|d�r5dS|
j�dkrKdSt|d|�}|
j|j�
S(NR�
R�
g�?R[(	RRGRCRBR*R�R�R-
R�
(ReRRG((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRD�
s
	
	




c
C�s�|j�}
x,t
r:|j�}|j|
|�rPqqW|j}|jd
d�rk|
j|j�
}
n|jd
d�r�|j|j�
}n|
|fS(s=generate random password, and non-matching alternate passwordii
(trandom_passwordR>taccept_password_pairRtrandintRktpassword_encoding(ReR(
Rd
R((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRJs
	



	




c
C�s
|j}
|
j
�d
kr%td�
S|j}|jo=|j}|pId}|dksj|
j
�dkr�|jdt|d�dd�}n!|jdt|d�d	d
�}t|
|j	|�}|r
t
|t�r
x,t|j
d�
�
|kr
|d }q�Wn|S(
s*generate random passwords for fuzz testingg-C��6?Rwi?Bi2g�?i
iiciFisutf-8i����(RR�RRGR�
R�
RPR3Rtpassword_alphabetR\RR�Rk(ReRRGR�
R�
tsizeR�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRQs	


	

$!

cC�s
|
|kS(
s-verify fuzz pair contains different passwords((ReR(
Rd
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRR7s(R�R�R�RRURTR�RKRLR�RRPRBRCRDRJRQRR(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�
s 

											c
C�s�|j}
|
j
s`|jt|
d
��

|jt|
d��

|j|j�

|jd�
�
n|
j�}|j|tdd�

|j	|
j
|�
dd|�


|j�j|j
�
d}|
j|�
}|j|tdd�

|j	|
j
|�
dd|�


|jtd|
j|�
y|
j|�
}d}Wntk
rV

}
d}|}n
X|dkr�
|j|tdd	�

|j||�
n&|j|t�
|jdt|�
�
|
j�}|jr�
|j||�
n|dkr�
|j||�
n|
j|�
}	|jr$|j|	|�
n|j|	|�
|
j|d
�
}
|js\|dkro|j|
|�
n|j|
|�
dS(s.disable() / .enable() methodstdisabletenablesnot applicableR�s#disable() must return native strings0identify() didn't recognize disable() result: %ri
scannot restore original hashs"enable() must return native stringR�
N(RGR2
R�
RBR`
R�RWR�RrR1
RG
R

R-
RtassertRaisesRegexR
RXR*R�R�Ra
(ReRGtdisabled_defaultR[
t
disabled_stubR�R0t
etdisabled_default2tdisabled_stub2tdisabled_other((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_disable_and_enableCsX	
	

























	

	
N(R
R
(R
s"$1$dOHYPKoP$tnxS1T8Q6VVn3kpV8cN6o.(R 
sx$6$rounds=123456$asaltof16chars..$BtCwjqMJGx5hrJhZywWvt0RLE8uZ4oPwcelCjmw2kSYu.Ec6ycULevoBK25fs2xXgMNrCzIMVcgEJAstJeonj1(
sfuzz_verifier_default(hR�R�R�R*RGROR%
R&
R'
R
RRRR_
R=R�
RR`
RRR$
R>t_HandlerCase__unittest_skiptpropertyR�R�
R,
R/
R4
R6
R=
R>
RE
R0
RH
RJ
RL
RM
RN
RO
RT
R�RZ
R\
R^
Re
Rf
Rg
Rk
Rm
Rn
Rw
Rx
R~
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
R�
RRRR	R
RRRRRR%R6RR.R?RR:R�
RR`(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR#�s�


		
	
	

							
		 	)		7		#	,			)			6					2					+		8	<	&			)			3	4	!	 	m	&						,		#			&	.Y	@
$	
�RP
cB�s�eZ
dZgZeZdZeZd
Z	e
Zd�Ze
d��
Zd�Ze
d��
Zd�Zd�Zd�Zd	�Zd
�Zd�ZRS(
s�
helper used by create_backend_case() which adds additional features
    to test the os_crypt backend.

    * if crypt support is missing, inserts fake crypt support to simulate
      a working safe_crypt, to test passlib's codepath as fully as possible.

    * extra tests to verify non-conformant crypt implementations are handled
      correctly.

    * check that native crypt support is detected correctly for known platforms.
    R"
c

C�sK|jd
kst
�
|jjd
�
s4|j�
ntt|�j�
dS(NR"
(ROR�RGRSt_patch_safe_cryptR�RP
R�(
Re((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��s




c
C�sD|j}
|
s!t
|j�
}
n|
j�
t|
d
�}|
|fS(s�
        return (handler, backend) pair to use for faking crypt.crypt() support for hash.
        backend will be None if none availabe.
        R"
(talt_safe_crypt_handlerRKRGRMRZ(R�RGtalt_backend((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt_get_safe_crypt_handler_backend�s	



c
�s~|j�\}
}|s't
d
�
�
n|
j���j|�

�f
d�}ddlj}|j|d|�
t|_dS(s�if crypt() doesn't support current hash alg, this patches
        safe_crypt() so that it transparently uses another one of the handler's
        backends, so that we can go ahead and test as much of code path
        as possible.
        s,handler has no available alternate backends!c�s+�j||
�}
t
|
t�s't�
|
S(
N(RK
R\RrR�(R(
R)
(
talt_handler(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt
crypt_stub�s


i����Nt_crypt(	RfR�RA
RNR�tutilsR
R>tusing_patched_crypt(ReRGReRhtmod((
Rgs7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRc�s





cC�sz|
d
kst�
t
t|�j|
�
}ddlm}
||jkrv|rvtd�
ro|j�drodSdSn|S(s|
        make sure os_crypt backend is tested
        when it's known os_crypt will be faked by _patch_safe_crypt()
        R"
i����(
t	has_cryptR8i
s hash not supported by os crypt()N(
R�R�RP
RO
R�RmRN
R RfR*(R�ROtreasonRm((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRO
�s


c
�sJd
dlj
}
�f
d��|
j�_d�_|j|
d��
�S(s�
        patch passlib.utils.safe_crypt() so it returns mock value for duration of test.
        returns function whose .return_value controls what's returned.
        this defaults to None.
        i����Nc�s'|d
kr�j||
�S�j
SdS(NR!
(t__wrapped__treturn_value(R(
R*
(
t
mock_crypt(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRqs
Ri(R�RjRiRoR*RpR
(ReRl((
Rqs7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt_use_mock_crypts
	c
�so�j�d
�
t
f
��j����
��fd�}
|
d�
d�

|
�
d �

|
�
d�

dS(stest with faulty crypt()i
c

�sU|�_�j
��jd
�
�
�j
��jd
�
�j
��jd
�
�
dS(NR[
(RpR�RL
RE
R0
(
R{(t	exc_typesR)
RqRe(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR!
/s	


s$xii����R�
N(R/
R�Rr(ReR!
((RsR)
RqRes7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_80_faulty_crypt)s
	


c
C�s�|j�}
d|
_|jrk|jd
�
}|jd
|�}|j||�
|j|jd
|��

nhddl	m
}
|j�d}|j||jd
�
|j||jd
|�
|j||jd
|�
dS(stest per-call crypt() fallbackR[
i����(
R
i
N(
RrR*Rpthas_os_crypt_fallbackRE
RL
R�R1
R0
R�
R
R/
R�(ReRqR�
R�
R
R)
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_81_crypt_fallback;s
		






c
C�s�t|j
d
�r$|jd�
�
ntj}
x@|jD]"\}}tj||
�r7Pq7q7W|jd|
�
�
|dkr�|jd|
�
�
nV||j	kr�dS|r�|j
d|
|j
jf�

n|j
d|
|j
jf�

dS(s0test platform-specific crypt() support detectionR@snot applicable to wrapperssno data for %r platformsvaried support on %r platformNs5expected %r platform would have native support for %rs;did not expect %r platform would have native support for %r(RBRGR�tsystplatformtplatform_crypt_supportRxRY
R*RkR1R�(ReRxtpatterntstate((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_82_crypt_supportPs 

	







	
	
c
�sZ�j}
�j
s!t|
d
�r%dSddlm�
�jj�
��
�fd�}|S(stest results against OS crypt()R[i����(
tcryptc�s5�j|
�
sd
St
|�
�}�||
�|
kS(sstdlib-cryptR(tcrypt_supports_variantR(R(
R)
(R}tencodingRe(s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytcheck_cryptys


N(RGRkRBR*R}RRT(ReRGR�((R}RRes7/usr/lib/python2.7/site-packages/passlib/tests/utils.pytfuzz_verifier_cryptls	


c
C�stS(
s~
        fuzzy_verified_crypt() helper --
        used to determine if os crypt() supports a particular hash variant.
        (
R>(ReR)
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR~�sN(R�R�R�RyR>RuR*Rdt_OsCryptMixin__unittest_skipROR=RkR�R�
RfRcRO
RrRtRvR|R�R~(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyRP
�s"							tUserHandlerMixincB�sceZ
dZd
ZeZeZeZd�Z	d�Z
d�Zd�Zde
jf
d��YZRS(s(
helper for handlers w/ 'user' context kwd; mixin for HandlerCase

    this overrides the HandlerCase test harness methods
    so that a username is automatically inserted to hash/verify
    calls. as well, passing in a pair of strings as the password
    will be interpreted as (secret,user)
    tuserc
C�s�|j}
d
}|
j
|d|j�

}|jr{|jt|
j
|�
|jt|
j||�
|jt|
j||�
n-|
j
|�

|
j||�
|
j||�
dS(stest user context keywordR[
R�N(RGR)
tdefault_usert
requires_userR�R�RK
RF
(ReRGtpasswordR)
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_80_user�s	

	





c
C�s�|jj
�}
|
j�}|jd
dtd|
�
�

}|jrg|j|jd
|d|�
d�
n"|j|jd
|d|�
d�
dS(stest user case sensitivityR[
RC
R�s!user should not be case sensitivesuser should be case sensitiveN(	R�R|R}RE
R�tuser_case_insensitiveR1
R0
R�
(ReR|R}R)
((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_81_user_case�s


	



c
C�sx|j�}
|j
d
|
dd�
}|j
d
|
dd�
}|j||�
|j
d
|
dd�
}|j||�
dS(stest user used as saltR[
R�tadmintrootN(RM
RL
R�Ra
(ReR*
R�
R�
th3((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyttest_82_user_salt�s




cC�sQt|
t
�r|
\}
}n|js+|
S|j}d
|krM||d
<n|
S(sinsert username into kwdsR�(R\R�R�R�(ReR(
RYR�((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR>
�s

	
	



RcB�s?eZ
ejjj�Zejdd
�

ed�
Zd�Z	RS(R�trandom_usert	asdQWE123c
C�sK|j}
|j
jr,|
j�d
kr,dSt|
|j|
jdd��S(Ng�������?ii
(RR!
R�R�R*Rt
user_alphabetRS(ReR((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��s
	


(
R�R�R#RRLtcopyR?
RR�R�(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�s
(R�R�R�R�R>R�R=R�t _UserHandlerMixin__unittest_skipR�R�R�R>
R#R(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��s

				tEncodingHandlerMixincB�sQeZ
dZeZed
�
d
ed�
gZdejf
d��YZd�Z	RS(s 
helper for handlers w/ 'encoding' context kwd; mixin for HandlerCase

    this overrides the HandlerCase test harness methods
    so that an encoding can be inserted to hash/verify
    calls by passing in a pair of strings as the password
    will be interpreted as (secret,encoding)
    R!
s\u00AC\u00BARcB�seZ
ed�
ZRS(
sqwerty1234<>.@*#! \u00AC(R�R�RRU(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR
scC�s2t|
t
�r.|
\}
}|jd
|�
n|
S(sinsert encoding into kwdsR(R\R�t
setdefault(ReR(
RYR((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR>

s


(
R�R�R�R>t$_EncodingHandlerMixin__unittest_skipRR_
R#RR>
(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR��s	

R�cB�s/eZ
dZd
dd�Zd�Zd�ZRS(s@catch_warnings() wrapper which clears warning registry & filterstalwayss.*cK�sAtt
|�j|�
|
|_|r4tj|�
nd|_dS(
N(R�R�R�t
_reset_filterRxtcompileR*t_reset_registry(Retreset_filtertreset_registryRY((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�
s

	
c
C�s�tt
|�j�}
|jr;tj�
tj|j�

n|j}|r�i}|_x}t	t
jj��
D]c\}}|dksm|j|�
r�qmnt|d
d�}|rm|j�||<|j�
qmqmWn|
S(Nt__warningregistry__(R�R�R�R�R�t
resetwarningstsimplefilterR�t_orig_registryR�RwtmodulesR�
R*RY
R�R�tclear(ReRj
RztbackupR�Rltreg((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�
s	


	



"






c
G�s�|j}|r�|j
}x�ttjj��
D]�\}}|dks.|j|�
r\q.nt|d
d�}|r�|j	�
n|j
|�
}|r.|dkr�t|d
|�
q�|j|�

q.q.Wnt
t|�j|
�
dS(NR�(R�R�R�RwR�R�
R*RY
R�R�R�R
R?
R�R�R�(ReR�RzR�R�RlR�RP((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�3
s	
	
"










(R�R�R�R�R�R�(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyR�
s
	(kR�t
__future__RtbinasciiR
t
contextlibt	functoolsRRR�tloggingt	getLoggerR�R�R�RxR$RwR
R
R'R�
RRRRRR�RtpasslibR	R
tpasslib.registrytregistrytpasslib.tests.backportsRt	_TestCaseRR
RRR�RRRRR�RRRRRRRRRRRtpasslib.utils.decorRtpasslib.utils.handlersRjRU
REt__all__tgoogle.appenginetgoogletImportErrorR=R�R>R,R5tTICK_RESOLUTIONR;R<R�R�tstripR|R:R*R RHRLRQRWRZRKRctcontextmanagerRiR!R"RvRzR~R�R�R�Ri
R#RP
R�R�R
R�(((s7/usr/lib/python2.7/site-packages/passlib/tests/utils.pyt<module>
s�

















(
F(



		




			

					!						�t���������	�a&