def verifica_trecho(rotulo, trc, ident, atrs):
"""Testes básicos de consistência do objeto {trc} da classe {Objeto_Trecho}, dados
{ident} e {atrs} esperados."""
global ok_global
sys.stderr.write("%s\n" % ("-" * 70))
sys.stderr.write("verificando trecho %s\n" % rotulo)
ok = trecho.verifica(trc, ident, atrs)
if trc != None and type(trc) is trecho.Objeto_Trecho:
# ----------------------------------------------------------------------
sys.stderr.write("testando {busca_por_codigo_e_data()}:\n")
cod1 = atrs['codigo']
dia1 = atrs['dia_partida']
hora1 = atrs['hora_partida']
trc1 = trecho.busca_por_codigo_e_data(cod1, dia1, hora1)
if trc1 != trc:
aviso_prog(
"retornou " + str(trc1) + ", deveria ter retornado " +
str(trc), True)
ok = False
if not ok:
aviso_prog("teste falhou", True)
ok_global = False
sys.stderr.write("%s\n" % ("-" * 70))
return
def testa_obtem_resumo(rot):
"""
Testa função {obtem_resumo} do módulo {roteiros}.
"""
try:
sys.stderr.write("Testando {obtem_resumo}\n")
resumo = roteiro.obtem_resumo(rot)
sys.stderr.write("Resumo retornado:" + str(resumo) + '\n')
except:
aviso_prog('Teste da função {obtem_resumo} falhou',True)
return False
return True
def testa_busca_por_origem_e_destino(org, dst, data_min, data_max, ids):
""" Testa a função {trecho.busca_por_origem_e_destino} com parâmetros
{org, dst, dia_min,dia_max}, que deve retornar a lista de indentificadores
de trechos {ids}."""
global ok_global
# ----------------------------------------------------------------------
sys.stderr.write("testando {busca_por_origem_e_destino()}:\n")
ids1 = trecho.busca_por_origem_e_destino(org, dst, data_min, data_max)
if ids1 != ids:
aviso_prog(
"retornou " + str(ids1) + ", deveria ter retornado " + str(ids),
True)
ok_global = False
def verifica(obj, tipo, id, atrs, cache, nome_tb, letra_tb, colunas, def_obj_mem):
ok = True # Este teste deu OK?
if obj == None:
sys.stderr.write("None\n")
elif not type(obj) is tipo:
aviso_prog("tipo do objeto " + str(type(obj)) + " inválido", True)
ok = False
else:
sys.stderr.write(" testando {obtem_identificador()}:\n")
id_cmp = obtem_identificador(obj)
if id_cmp != id:
aviso_prog("retornou " + str(id_cmp) + ", deveria ter retornado " + str(id), True)
ok = False
sys.stderr.write(" testando {obtem_atributos()}:\n")
atrs_cmp = obtem_atributos(obj)
atrs_esp = atrs.copy()
if 'criacao' in atrs_cmp: del atrs_cmp['criacao'] # Introduzido por {cria}.
if 'criacao' in atrs_esp: del atrs_esp['criacao'] # Introduzido por {cria}.
if atrs_cmp != atrs_esp:
aviso_prog("retornou " + str(atrs_cmp) + ", deveria ter retornado " + str(atrs_esp), True)
ok = False
sys.stderr.write("testando {busca_por_identificador()}:\n")
obj1 = busca_por_identificador(id, cache, nome_tb, letra_tb, colunas, def_obj_mem)
if obj1 != obj:
aviso_prog("retornou " + str(obj1) + ", deveria ter retornado " + str(obj), True)
ok = False
return ok
def testa_busca_por_origem(cod, ids):
""" Testa a função {trecho.busca_por_origem} com parâmetro {cod},
que deve retornar a lista de indentificadores de trechos {ids}."""
global ok_global
# ----------------------------------------------------------------------
sys.stderr.write("testando {busca_por_origem()}:\n")
ids1 = trecho.busca_por_origem(cod)
if ids1 != ids:
aviso_prog(
"retornou " + str(ids1) + ", deveria ter retornado " + str(ids),
True)
ok_global = False
return
def verifica_cadastrar_usuario(ses, dados, deveria_cadastrar):
global ok_global
comando_cadastrar_usuario.processa(ses, dados)
usuarioResponse = usuario.busca_por_email(dados["email"])
if (usuarioResponse != None and (not deveria_cadastrar)):
ok_global = False
aviso_prog("Cadastrou usuario quando não deveria cadastrar", True)
if (usuarioResponse == None and deveria_cadastrar):
ok_global = False
aviso_prog("Não cadastrou usuario quando deveria cadastrar", True)
def testa_descobre_todos(origem, destino, data_min, data_max, soh_disponiveis):
"""
Testa função {descobre_todos} do módulo {roteiros}.
"""
tx_args = "'%s', '%s', '%s', '%s', %s" % (origem, destino, data_min, data_max, str(soh_disponiveis))
sys.stderr.write("Testando {descobre_todos}(%s)\n" % tx_args)
roteiros = roteiro.descobre_todos(origem, destino, data_min, data_max, soh_disponiveis)
sys.stderr.write("Roteiros retornados:\n")
ok_local = True
for rot in roteiros:
sys.stderr.write(" " + str(roteiros) + "\n")
if not verifica_roteiro(rot):
aviso_prog('** roteiro inválido', True)
ok_local = False
return ok_local
def devolve_pagina(self, ses, pag):
"""Manda para o usuário a {pag} dada, que deve ser um string
com o conteúdo da página em HTML 5.0., com os preâmulos adequados
segundo o protocolo HTTP.
Se {pag} é {None}, sinaliza no preâmbulo o código 404 com conteúdo 'text/plain',
mensagem 'Não encontrado'. Caso contrário, devolve a página com código 200 e
'content-type' 'text/html'.
Se {ses} não é {None}, deve ser um objeto da classe {ObjSession}.
Nesse caso, a função inclui no preâmbulo cookies que identificam a
sessão e o o usuário."""
if pag == None:
aviso_prog("Página a devolver é {None}", True)
codigo = 404 # Error - Not found.
msg = "Pagina nao encontrada - Page not found"
tipo = 'text/plain'
pag = html_pag_mensagem_de_erro.gera(ses, msg)
if pag == None:
aviso_prog(
"Função {html_pag_mensagem_de_erro.gera} devolveu {None}",
True)
# Na marra:
pag = "<!doctype html>\n<html>\n<body>\n" + msg + "\n</body>\n</head>"
else:
codigo = 200 # No error.
tipo = 'text/html'
self.send_response(codigo)
self.send_header('Content-type', tipo)
# Manda cookies que identificam usuário e sessão:
if ses != None:
id_sessao = sessao.obtem_identificador(ses)
cookie = sessao.obtem_cookie(ses)
usr = sessao.obtem_usuario(ses)
id_usuario = usuario.obtem_identificador(usr)
else:
id_sessao = ""
cookie = ""
usr = None
id_usuario = ""
self.send_header('Set-Cookie', 'id_usuario=' + id_usuario)
self.send_header('Set-Cookie', 'id_sessao=' + id_sessao)
self.send_header('Set-Cookie', 'cookie_sessao=' + cookie)
self.end_headers()
self.wfile.write(pag.encode('utf-8'))
def verifica_objeto(rotulo, obj, id, atrs):
"""Testes básicos de consistência do objeto {obj} da classe {ObjTeste}, dados
{id} e {atrs} esperados."""
global ok_global
sys.stderr.write("%s\n" % ("-" * 70))
sys.stderr.write("verificando usuário %s\n" % rotulo)
ok = objeto.verifica(obj, type(obj0), id, atrs, cache, nome_tb, letra_tb,
colunas, def_obj_mem)
if not ok:
aviso_prog("teste falhou", True)
ok_global = False
sys.stderr.write("%s\n" % ("-" * 70))
return
def testa_lista_livres(trc, trc_id, atrs):
"""Testa retorno da função lista_livres."""
pol = poltrona.lista_livres(trc)
livres = [
sub['numero'] for sub in atrs
if sub['id_trecho'] == trechos[1] and sub['id_compra'] == None
]
ok = (pol == livres)
if not ok:
aviso_prog("teste falhou", True)
ok_global = False
sys.stderr.write(trc_id, "ok\n")
sys.stderr.write("%s\n" % ("-" * 70))
return livres
def verifica_sessao(rotulo, ses, ident, usr, abrt, cookie, carrinho):
"""Testes básicos de consistência do objeto {ses} da classe {Objeto_Sessao}, dados
{ident} e {atrs} esperados."""
global ok_global
sys.stderr.write("%s\n" % ("-" * 70))
sys.stderr.write("verificando sessão %s\n" % rotulo)
atrs = { 'usr': usr, 'abrt': abrt, 'cookie': cookie, 'carrinho': carrinho }
ok = sessao.verifica(ses, ident, atrs)
if ses != None and type(ses) is sessao.Objeto_Sessao:
sys.stderr.write("testando {obtem_usuario()}:\n")
usr1 = sessao.obtem_usuario(ses)
if usr1 != usr:
aviso_prog("retornou " + str(usr1) + ", deveria ter retornado " + str(usr),True)
ok = False
sys.stderr.write("testando {aberta()}:\n")
abrt1 = sessao.aberta(ses)
if abrt1 != abrt:
aviso_prog("retornou " + str(abrt1) + ", deveria ter retornado " + str(abrt),True)
ok = False
sys.stderr.write("testando {obtem_cookie()}:\n")
cookie1 = sessao.obtem_cookie(ses)
if cookie1 != cookie:
aviso_prog("retornou " + str(cookie1) + ", deveria ter retornado " + str(cookie),True)
ok = False
sys.stderr.write("testando {obtem_carrinho()}:\n")
carrinho1 = sessao.obtem_carrinho(ses)
if carrinho1 != carrinho:
aviso_prog("retornou " + str(carrinho1) + ", deveria ter retornado " + str(carrinho),True)
ok = False
if not ok:
aviso_prog("teste falhou",True)
ok_global = False
sys.stderr.write("%s\n" % ("-" * 70))
return
def verifica_login(rotulo, email, senha, deveria_logar):
global ok_global
dados = {
"email": email,
"senha": senha
}
modulo = comando_fazer_login
pag, ses = modulo.processa(None, dados)
if (deveria_logar and ses == None):
ok_global = False
aviso_prog("Não gerou a sessão quando deveria para o email " + str(email), True)
if ((not deveria_logar) and ses != None):
ok_global = False
aviso_prog("Gerou gerou a sessão quando não deveria para o email " + str(email), True)
frag = False # Resultado não é fragmento, é página completa.
pretty = False # Não tente deixar o HTML legível.
utils_testes.testa_modulo_html(modulo, rotulo, pag, frag, pretty)
def verifica_poltrona(rotulo, pol, ident, atrs):
"""Testes básicos de consistência do objeto {pol} da classe {Objeto_Poltrona}, dados
{ident} e {atrs} esperados."""
global ok_global
sys.stderr.write("%s\n" % ("-" * 70))
sys.stderr.write("verificando poltrona %s\n" % rotulo)
ok = poltrona.verifica(pol, ident, atrs)
if pol != None and type(pol) is poltrona.Objeto_Poltrona:
pass # Objeto não está com problemas, poltrona é válido
else:
ok = False
erro_prog("algo falhou")
if not ok:
aviso_prog("teste falhou", True)
ok_global = False
sys.stderr.write("%s\n" % ("-" * 70))
return
def verifica_usuario(rotulo, usr, ident, atrs):
"""Testes básicos de consistência do objeto {usr} da classe {Objeto_Usuario}, dados
{ident} e {atrs} esperados."""
global ok_global
sys.stderr.write("%s\n" % ("-" * 70))
sys.stderr.write("verificando usuário %s\n" % rotulo)
ok = usuario.verifica(usr, ident, atrs)
if usr != None and type(usr) is usuario.Objeto_Usuario:
# ----------------------------------------------------------------------
sys.stderr.write("testando {busca_por_email()}:\n")
em1 = atrs['email']
ident1 = usuario.busca_por_email(em1)
if ident1 != ident:
aviso_prog(
"retornou " + str(ident1) + ", deveria ter retornado " +
str(ident), True)
ok = False
# ----------------------------------------------------------------------
sys.stderr.write("testando {busca_por_CPF()}:\n")
CPF1 = atrs['CPF']
ident1 = usuario.busca_por_CPF(CPF1)
if ident1 != ident:
aviso_prog(
"retornou " + str(ident1) + ", deveria ter retornado " +
str(ident), True)
ok = False
if not ok:
aviso_prog("teste falhou", True)
ok_global = False
sys.stderr.write("%s\n" % ("-" * 70))
return
def verifica_valor(rotulo, val_mem, tipo_mem, val_SQL, tipo_SQL, nulo_ok):
"""Testa {valor_mem_para_valor_SQL} e {valor_SQL_para_valor_mem}."""
global ok_global
ok = True # Estado deste teste.
# Mostra parâmetros:
sys.stderr.write("%s\n" % ("-" * 70))
sys.stderr.write(rotulo + "\n")
sys.stderr.write(" val_mem = " + str(val_mem) + " tipo_mem = " +
str(tipo_mem) + "\n")
sys.stderr.write(" val_SQL = " + str(val_SQL) + " tipo_SQL = " +
str(tipo_SQL) + "\n")
# Testa {valor_mem_para_valor_SQL}:
val_SQL_cmp = conversao_sql.valor_mem_para_valor_SQL(
rotulo, val_mem, tipo_mem, tipo_SQL, nulo_ok)
if val_SQL_cmp != val_SQL:
aviso_prog(
"{valor_mem_para_valor_SQL} valor SQL não bate = '" +
str(val_SQL_cmp) + "'", True)
ok = False
# Testa {valor_SQL_para_valor_mem}:
val_mem_cmp = \
conversao_sql.valor_SQL_para_valor_mem(rotulo, val_SQL, tipo_SQL, tipo_mem, nulo_ok, tabelas.id_para_objeto)
if val_mem_cmp != val_mem:
aviso_prog(
"{valor_SQL_para_valor_mem} não bate = '" + str(val_mem_cmp) + "'",
True)
ok = False
# Veredito do teste:
if ok:
sys.stderr.write(" verifica_valor: ok\n")
ok_global = ok_global and ok
sys.stderr.write("%s\n" % ("-" * 70))
return
def verifica_dict(rotulo, dic_mem, falta_ok, dic_SQL):
"""Testa {dict_mem_para_dict_SQL} e {dict_SQL_para_dict_mem}."""
global ok_global
ok = True # Estado deste teste.
# Mostra parâmetros:
sys.stderr.write("%s\n" % ("-" * 70))
sys.stderr.write(rotulo + "\n")
sys.stderr.write(" dic_mem = '" + str(dic_mem) + "' falta_ok = " +
str(falta_ok) + "\n")
sys.stderr.write(" dic_SQL = '" + str(dic_SQL) + "'\n")
# Verifica conversão memória --> SQL:
dic_SQL_cmp = conversao_sql.dict_mem_para_dict_SQL(dic_mem, colunas,
falta_ok)
sys.stderr.write(" dic_SQL_cmp = '" + str(dic_SQL_cmp) + "'\n")
if dic_SQL_cmp != dic_SQL:
aviso_prog("{dict_mem_para_dict_SQL} não bate", True)
ok = False
# Verifica conversão SQL --> memória:
dic_mem_cmp = conversao_sql.dict_SQL_para_dict_mem(dic_SQL, colunas,
falta_ok,
tabelas.id_para_objeto)
sys.stderr.write(" dic_mem_cmp = '" + str(dic_mem_cmp) + "'\n")
for chave, tipo_mem, tipo_SQL, nulo_ok in colunas:
if tipo_mem is list or tipo_mem is tuple or tipo_mem is dict:
# Campo não deve estar em {dic_SQL} nem em {dic_mem_cmp}:
if chave in dic_SQL:
aviso_prog(
"chave " + chave + " não deveria estar em {dic_SQL}", True)
ok = False
elif chave in dic_mem_cmp:
aviso_prog(
"chave " + chave + " não deveria estar em {dic_mem_cmp}",
True)
ok = False
else:
# Campo deve estar ou não estar em ambos:
if (chave in dic_SQL) != (chave in dic_mem_cmp):
aviso_prog("chave " + chave + " com presença incongruente",
True)
ok = False
elif chave in dic_SQL:
val_mem = dic_mem[chave]
val_mem_cmp = dic_mem_cmp[chave]
if val_mem_cmp != val_mem:
aviso_prog("campo " + chave + " com valor incongruente",
True)
ok = False
if len(dic_mem_cmp) != len(dic_SQL):
aviso_prog("campos espúrios em {dic_mem_cmp", True)
ok = False
# Veredito do teste:
if ok:
sys.stderr.write(" verifica_dict: ok\n")
ok_global = ok_global and ok
sys.stderr.write("%s\n" % ("-" * 70))
return
