Estamos implementando muitos algoritmos que normalmente têm muitos parâmetros compartilhados, conhecidos publicamente e relevantes para a segurança.
Atualmente, simplesmente usamos uma classe contendo todos os parâmetros e dois objetos globais predefinidos:
class PublicParams(object):
p = q = 0
def __init__(self, p, q):
self.p = p
self.q = q
# used for tests
publicParams_test = PublicParams(15,7)
# Some 2048 bit numbers for example
publicParams_secure = PublicParams(128378947298374928374,128378947298374928374)
Os algoritmos, então, tomam um PublicParams
objeto como um argumento que assume como padrão opublicParams_secure
def AlgoOne(n, publicParams = publicParams_secure):
# do stuff with publicParams.p
# ...
AlgoTwo(x, publicParams)
e
def AlgoTwo(x, publicParams= publicParams_secure):
# do stuff with publicParams.q
Dessa forma, ainda podemos injetar diferentes parâmetros públicos para facilitar o teste de unidade:
class AlgoOneTest(unittest.TestCase):
def test(self):
# compare with manually computed result
self.assertTrue(AlgoOne(1, publicParams_test) == 10)
O que eu não gosto nessa abordagem:
- A atribuição de
publicParams
um valor padrão o torna opcional ao chamar algum algoritmo. No entanto, fica fácil esquecer de transmiti-lo ao chamarAlgoTwo
de dentroAlgoOne
, o que resultaria em dois objetos diferentes sendo usados se o objeto de teste fosse passado paraAlgoOne
Existe uma maneira melhor que seja menos propensa, mas ainda ofereça flexibilidade para testes de unidade? Esta é realmente a melhor prática?