def cria_testes(verb):
global cache, nome_tb, letra_tb, colunas, diags
inicializa(True)
# Identificador de usuários e cookie de cada sessão:
lista_ucs = \
[
( "U-00000001", "ABCDEFGHIJK", "C-00000001" ), # S-00000001
( "U-00000001", "BCDEFGHIJKL", "C-00000002" ), # S-00000002
( "U-00000002", "CDEFGHIJKLM", "C-00000003" ), # S-00000003
( "U-00000003", "DEFGHIJKLMN", None ), # S-00000004
]
for id_usuario, cookie, id_carrinho in lista_ucs:
usr = usuario.busca_por_identificador(id_usuario)
assert usr != None and type(usr) is usuario.Objeto_Usuario
if id_carrinho == None:
carrinho = None
else:
carrinho = compra.busca_por_identificador(id_carrinho)
assert carrinho != None and type(carrinho) is compra.Objeto_Compra
ses = cria(usr, cookie, carrinho)
assert ses != None and type(ses) is sessao.Objeto_Sessao
id_ses = sessao.obtem_identificador(ses)
usr = sessao.obtem_usuario(ses)
id_usr = usuario.obtem_identificador(usr) if usr != None else "ninguém"
if verb:
sys.stderr.write("sessão %s de %s criada\n" % (id_ses, id_usr))
return
def processa(ses, args):
# Determina se o usuário corrente {usr_ses} é administrador:
if ses is None:
usr_ses = None
admin = False
else:
usr_ses = sessao.obtem_usuario(ses)
assert usr_ses is not None
admin = usuario.obtem_atributos(usr_ses)['administrador']
id_usr = args["id_usuario"] if "id_usuario" in args else None
assert id_usr is not None, "id_usuario obrigatório para atualizar"
usr = usuario.busca_por_identificador(id_usr)
# Tenta editar o usuário:
try:
if usr == None: raise ErroAtrib("esse usuário não existe")
atrs_muda = args.copy()
del atrs_muda["id_usuario"]
usuario.confere_e_elimina_conf_senha(atrs_muda)
usuario.muda_atributos(usr, atrs_muda)
# Mostra de novo a página de alterar com dados novos:
args_novos = usuario.obtem_atributos(usr)
pag = html_pag_usuario.gera(ses, usr, args_novos, None)
except ErroAtrib as ex:
erros = ex.args[0]
# Repete a página de cadastrar com os mesmos argumentos e mens de erro:
pag = html_pag_usuario.gera(ses, usr, args, erros)
return pag
def cria_testes(verb):
global cache, nome_tb, letra_tb, colunas, diags
inicializa(True)
# Identificador de usuários e lista de poltronas de cada pedido de compra:
lista_cupsf = \
[
( "C-00000001", "U-00000001", "Amanda Almeida", "45.246.235-2", True, ),
( "C-00000002", "U-00000001", "Basílio Barros", "234.764.987-23", True, ),
( "C-00000003", "U-00000002", "Carlos Costa", "76.863.987-5", True, ),
( "C-00000004", "U-00000002", "Diego Dias", "654.987.098-09", False,),
( "C-00000005", "U-00000002", "Romario Silva", "122.787.038-05", False,),
( "C-00000006", "U-00000001", "Fabio Santos", "555.957.058-05", True, ),
( "C-00000007", "U-00000001", "Renato Augusto", "111.227.338-03", False,),
( "C-00000008", "U-00000001", "Carlos Tevez", "666.967.698-06", True, ),
( "C-00000009", "U-00000002", "André Santos", "554.181.018-01", False,),
( "C-00000010", "U-00000002", "Victor Cantillo", "444.955.085-08", True, ),
]
for id_cpr_esp, id_cliente, nome_pass, doc_pass, comprando in lista_cupsf:
cliente = usuario.busca_por_identificador(id_cliente)
cpr = cria(cliente, nome_pass, doc_pass)
assert cpr != None and type(cpr) is compra.Objeto_Compra
id_cpr = compra.obtem_identificador(cpr)
if not comprando: compra.fecha(cpr)
# Paranóia:
assert id_cpr == id_cpr_esp
cliente_1 = compra.obtem_cliente(cpr)
id_cliente_1 = usuario.obtem_identificador(cliente_1)
assert id_cliente_1 == id_cliente
if verb:
sys.stderr.write("compra %s de %s criada\n" % (id_cpr, id_cliente))
return
def gera(ids):
res = ""
for id_usuario in ids:
usr = usuario.busca_por_identificador(id_usuario)
bloco_prod = html_resumo_de_usuario.gera(usr)
res = res + bloco_prod + "\n"
lista_html = html_div.gera("display:inline-block", res)
return lista_html
def testa_atualiza_atributo(rot, ses, args):
assert 'id_usuario' in args
testa(rot, ses, args)
id_usr = args['id_usuario']
usr = usuario.busca_por_identificador(id_usr)
atrs_usr = usuario.obtem_atributos(usr)
for ch, val in atrs_usr.items():
if ch in args:
assert val == args[ch], (
"campo '%s' = '%s' não foi alterado para '%s'\n" %
(ch, val, args[ch]))
def processa(ses, args):
usr_ses = None if ses == None else sessao.obtem_usuario(ses)
assert sessao.eh_administrador(
ses) # O dono da sessão deve ser administrador.
try:
if not 'id' in args:
pag = html_pag_mensagem_de_erro.gera(
ses, 'É necessário adicionar um ID para pesquisar.')
return pag
id = args['id']
if len(id) != 10:
raise ErroAtrib("O identificador \"" + id + "\" é inválido")
letra = id[0]
if letra == "U":
usr = usuario.busca_por_identificador(id)
if usr == None:
raise ErroAtrib("Não existe usuário com identificador " + id)
usr_atrs = usuario.obtem_atributos(usr)
usr_atrs['id_usuario'] = usuario.obtem_identificador(usr)
pag = html_pag_usuario.gera(ses, usr, usr_atrs, None)
elif letra == "C":
cpr = compra.busca_por_identificador(id)
if cpr == None:
raise ErroAtrib(
"Não existe pedido de compra com identificador" + id)
pag = html_pag_compra.gera(ses, cpr, None, None)
elif letra == "T":
trc = trecho.busca_por_identificador(id)
if trc == None:
raise ErroAtrib(
"Não existe trecho de viagem com identificador" + id)
pag = html_pag_trecho.gera(ses, trc, None, None)
elif letra == "S":
ses_a_ver = sessao.busca_por_identificador(id)
if ses_a_ver == None:
raise ErroAtrib("Não existe sessão com identificador" + id)
pag = html_pag_sessao.gera(ses, ses_a_ver, None)
elif letra == "A":
pol = poltrona.busca_por_identificador(id)
if pol == None:
raise ErroAtrib("Não existe poltrona com identificador" + id)
pag = html_pag_poltrona.gera(ses, pol, None, None)
else:
raise ErroAtrib("Classe de objeto \"" + letra + "\" inválida")
except ErroAtrib as ex:
erros = ex.args[0]
return html_pag_mensagem_de_erro.gera(ses, erros)
return pag
def id_para_objeto(id):
letra = id[0]
if letra == "U":
obj = usuario.busca_por_identificador(id)
elif letra == "C":
obj = compra.busca_por_identificador(id)
elif letra == "S":
obj = sessao.busca_por_identificador(id)
elif letra == "A":
obj = poltrona.busca_por_identificador(id)
elif letra == "T":
obj = trecho.busca_por_identificador(id)
else:
erro_prog("identificador '" + id + " inválido")
return obj
def processa(ses, dados):
ses_nova = ses # Caso o login falhe.
if ses != None:
# Não deveria acontecer, mas por via das dúvidas:
pag = html_pag_mensagem_de_erro.gera(ses, "Favor sair da sessão corrente primeiro")
else:
erro_email = None # Email não especificado ou não cadastrado.
erro_senha = None # Senha não especificada ou inválida.
if 'senha' not in dados:
erro_senha = "campo 'senha' é obrigatório"
senha = None
else:
senha = dados['senha']
if 'email' not in dados:
erro_email = "campo 'email' é obrigatório"
email = None
else:
email = dados['email']
usr = None
if email != None and senha != None:
# Obtem o usuário pelo email:
id_usuario = usuario.busca_por_email(email)
if id_usuario == None:
erro_email = "Usuário " + email + " não está cadastrado"
else:
usr = usuario.busca_por_identificador(id_usuario)
assert usr != None
atrs_usr = usuario.obtem_atributos(usr)
if atrs_usr["senha"] != senha:
erro_senha = "Senha incorreta"
usr = None
if usr != None:
cookie = secrets.token_urlsafe(32)
carrinho = define_carrinho(usr, id_usuario)
ses_nova = sessao.cria(usr, cookie, carrinho)
pag = html_pag_principal.gera(ses_nova, None)
else:
erros = [ erro_email, erro_senha ]
pag = html_pag_mensagem_de_erro.gera(None, erros)
return pag, ses_nova
def processa(ses, args):
if ses == None or not sessao.aberta(ses):
erro_prog("sessão deveria estar aberta")
else:
usr_ses = sessao.obtem_usuario(ses)
admin = usuario.obtem_atributo(usr_ses, 'administrador')
if args == {} or args['id_usuario'] == None:
# O 'id_usuario' nao foi especificado; supõe que é o dono da sessao:
usr = usr_ses
id_usr = usuario.obtem_identificador(usr)
elif args['id_usuario'] != None:
# O 'id_usuario' foi especificado; obtém dados do do dito cujo.
id_usr = args['id_usuario']
usr = usuario.busca_por_identificador(id_usr)
else:
erro_prog("usuário não identificado")
atrs = usuario.obtem_atributos(usr)
pag = html_pag_usuario.gera(ses, usr, atrs, None)
return pag
def processa(ses, args):
assert ses != None
pag = html_pag_mensagem_de_erro.gera(ses, "sessão corrente")
assert sessao.aberta(ses)
usr_ses = sessao.obtem_usuario(ses)
assert usr_ses != None
id_usr_ses = usuario.obtem_identificador(usr_ses)
admin = sessao.eh_administrador(ses)
# Usuário a examinar:
if 'id' in args:
id_usr = args['id']
usr = usuario.busca_por_identificador(id_usr)
else:
usr = usr_ses
id_usr = id_usr_ses
if (id_usr != id_usr_ses) and not admin:
pag = html_pag_mensagem_de_erro.gera(ses, ["Apenas administradores podem ver sessões por este comando"])
return pag
# Compra a identificar como "Seu carrinho":
if id_usr == id_usr_ses:
carrinho = sessao.obtem_carrinho(ses)
id_carrinho = compra.obtem_identificador(carrinho) if carrinho != None else None
else:
carrinho = None # Usuário pode ter várias sessões, não vale a pena marcar carrinho(s).
id_carrinho = None
ids_compras = compra.busca_por_cliente(id_usr)
ver_compra = True # Queremos botão "Ver" em cada compra.
ht_conteudo = html_lista_de_compras.gera(ids_compras, ver_compra, id_carrinho)
pag = html_pag_generica.gera(ses, ht_conteudo, None)
return pag
"Inicializando módulo {usuario}, limpando tabela, criando usuários para teste:\n"
)
usuario.cria_testes(False)
sys.stderr.write(
"Inicializando módulo {compra}, limpando tabela, criando compras para teste:\n"
)
compra.cria_testes(False)
sys.stderr.write("Inicializando módulo {compra}, limpando tabela:\n")
compra.inicializa(True)
# ----------------------------------------------------------------------
sys.stderr.write("Obtendo dois usuários para teste:\n")
usr1 = usuario.busca_por_identificador("U-00000001")
usr2 = usuario.busca_por_identificador("U-00000002")
cmp1 = compra.busca_por_identificador("C-00000001")
cmp2 = compra.busca_por_identificador("C-00000003")
# ----------------------------------------------------------------------
# Funções de teste:
ok_global = True # Vira {False} se um teste falha.
def verifica_compra(rotulo, cpr, ident, cliente, status, nome_pass, doc_pass):
"""Testes básicos de consistência do objeto {cpr} da classe {Objeto_Compra}, dados
{ident} e {atrs} esperados."""
global ok_global
# ----------------------------------------------------------------------
# Administrador alterando usuário comum e promovendo a administrador:
ses_adm3 = sessao.busca_por_identificador("S-00000004")
usr_adm3 = sessao.obtem_usuario(ses_adm3)
assert usuario.obtem_atributo(usr_adm3, 'administrador')
id_usr_adm3 = usuario.obtem_identificador(usr_adm3)
args_alt2_com1 = args = {
'id_usuario': id_usr_com1,
'nome': "Giovanni Primo",
'telefone': "(011)2-2322",
'administrador': True,
}
testa_atualiza_atributo("sesA-usrC", ses_adm3, args_alt2_com1)
# ----------------------------------------------------------------------
# Administrador alterando outro administrador e rebaixando:
usr_adm8 = usuario.busca_por_identificador("U-00000008")
assert usuario.obtem_atributo(usr_adm8, 'administrador')
id_usr_adm8 = usuario.obtem_identificador(usr_adm8)
args_alt3_adm8 = args = {
'id_usuario': id_usr_adm8,
'nome': "François Huitième",
'telefone': "+99(99)9-999",
'administrador': False,
}
testa_atualiza_atributo("sesA-usrA", ses_adm3, args_alt3_adm8)
import sys
# Conecta no banco e alimenta com as informações para o teste
sys.stderr.write("Conectando com base de dados...\n")
res = base_sql.conecta("DB", None, None)
assert res is None
sys.stderr.write("Criando alguns objetos...\n")
tabelas.cria_todos_os_testes(False)
# Sessões de teste
ses_nao_admin = sessao.busca_por_identificador("S-00000001")
admin = usuario.busca_por_identificador("U-00000003")
ses_admin = sessao.cria(admin, "NOPQRSTUVWX", None)
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_solicitar_pag_buscar_usuarios
funcao = modulo.processa
frag = False # {True} se for apenas um fragmento HTML, {False} se for página completa.
pretty = True # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos).
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
testa("NL-e0", None, None)
def fecha_sessoes(id_usr):
sessoes = list(
map(lambda id_ses: sessao.busca_por_identificador(id_ses),
sessao.busca_por_usuario(id_usr)))
for sessao_usr in sessoes:
if sessao.aberta(sessao_usr):
sessao.fecha(sessao_usr)
pag_conteudo = "Viagens Oito-Cinco-Sete"
id_usr_nao_admin = "U-00000001"
id_usr_admin = "U-00000003"
usr_nao_admin = usuario.busca_por_identificador(id_usr_nao_admin)
usr_admin = usuario.busca_por_identificador(id_usr_admin)
# Teste sem sessao
testa("sem_sessao", None, pag_conteudo, None)
# Fecha todas as sessoes
fecha_sessoes(id_usr_nao_admin)
fecha_sessoes(id_usr_admin)
# Teste com apenas uma sessao
# - Nao admin
ses = sessao.cria(usr_nao_admin, "ASDIHADBH", None)
testa("uma_sessao_nao_admin", ses, pag_conteudo, None)
# - Admin
funcao = modulo.gera
frag = True # {True} se for apenas um fragmento HTML, {False} se for página completa.
pretty = False # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos).
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
# fixtures
sys.stderr.write("Conectando com base de dados...\n")
res = base_sql.conecta("DB", None, None)
assert res == None
sys.stderr.write("Criando alguns objetos...\n")
tabelas.cria_todos_os_testes(False)
# Testes das funções de {gera_html_form}:
usr1 = usuario.busca_por_identificador("U-00000001")
assert usr1 != None
id_usr1 = usuario.obtem_identificador(usr1)
atrs_usr1 = usuario.obtem_atributos(usr1)
assert not usuario.obtem_atributo(usr1, 'administrador')
usr3 = usuario.busca_por_identificador("U-00000003")
assert usr3 != None
id_usr3 = usuario.obtem_identificador(usr3)
atrs_usr3 = usuario.obtem_atributos(usr3)
assert usuario.obtem_atributo(usr3, 'administrador')
atrs_usr0 = atrs_usr1
del atrs_usr0['nome']
del atrs_usr0['telefone']
import utils_testes
import utils_testes
import sys
sys.stderr.write("Conectando com a base de dados...\n")
res = base_sql.conecta("DB", None, None)
assert res == None # Verifica que a conexão teve sucesso
sys.stderr.write("Criando alguns objetos...\n")
tabelas.cria_todos_os_testes(False)
# Sessão usada no teste
sessao1 = sessao.busca_por_identificador("S-00000001")
assert sessao1 != None
# Usuário usado no teste
usuario1 = usuario.busca_por_identificador("U-00000001")
assert usuario1 != None
def testa(rotulo, *args):
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = comando_solicitar_pag_buscar_trechos
funcao = modulo.processa
frag = False # {True} se for apenas um fragmento HTML, {False} se for página completa.
pretty = True # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos).
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
testa("NLog", None, None)
modulo = html_lista_de_poltronas_de_trecho
funcao = modulo.gera
frag = True # {True} se for apenas um fragmento HTML, {False} se for página completa.
pretty = False # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos).
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
testes = ( \
( "U-00000001", "T-00000001", ), # Cliente comum.
( "U-00000001", "T-00000002", ), # Cliente comum.
( "U-00000003", "T-00000003" ), # Admin.
( "U-00000003", "T-00000004", ), # Admin.
( None, "T-00000005", ), # Usuario deslogado.
)
for usr_id, trc_id in testes:
usr = None if usr_id == None else usuario.busca_por_identificador(usr_id)
admin = False if usr == None else usuario.obtem_atributo(
usr, 'administrador')
usr_cprs = [] if usr == None else usuario.compras_abertas(usr)
carr = None if len(usr_cprs) == 0 else usr_cprs[
0] # Faz de conta que a primeira compra é o carrinho.
id_carr = None if carr == None else compra.obtem_identificador(carr)
trc = None if trc_id == None else trecho.busca_por_identificador(trc_id)
assert trc != None
ids_pols = trecho.obtem_poltronas(trc)
fazer_checkin = admin #por enquanto
rot = trc_id + "-" + str(usr_id) + "-" + str(id_carr)
rot += "-admin" + str(admin)[0]
import tabelas
import conversao_sql
from utils_testes import erro_prog, aviso_prog, mostra
# Para diagnóstico:
import sys
# ----------------------------------------------------------------------
sys.stderr.write("Conectando com base de dados...\n")
base_sql.conecta("DB", None, None)
tabelas.inicializa_todas(True)
tabelas.cria_todos_os_testes(False)
usr1_id = "U-00000001"
usr1 = usuario.busca_por_identificador(usr1_id)
usr2_id = "U-00000002"
usr2 = usuario.busca_por_identificador(usr2_id)
cpr1_id = "C-00000001"
cpr1 = compra.busca_por_identificador(cpr1_id)
ses1_id = "S-00000001"
ses1 = sessao.busca_por_identificador(ses1_id)
ok_global = True # Vira {False} se um teste falha.
# ----------------------------------------------------------------------
# TESTES DE CONVERSÃO DE VALORES
"""Testa {funcao(*args)}, grava resultado
em "testes/saida/{modulo}.{funcao}.{rotulo}.html"."""
modulo = html_pag_poltrona
funcao = html_pag_poltrona.gera
frag = True # {True} se for apenas um fragmento HTML, {False} se for página completa.
pretty = False # Se {True}, formata HTML para legibilidate (mas introduz brancos nos textos).
utils_testes.testa_gera_html(modulo, funcao, rotulo, frag, pretty, *args)
# ----------------------------------------------------------------------
# Dados para testes:
# Um cliente comum:
usrC_id = "U-00000001"
usrC = usuario.busca_por_identificador(usrC_id)
assert not usuario.obtem_atributo(usrC, 'administrador')
# Um administrador:
usrA_id = "U-00000003"
usrA = usuario.busca_por_identificador(usrA_id)
assert usuario.obtem_atributo(usrA, 'administrador')
# Uma compra em aberto do cliente 1:
cprC_id = "C-00000001"
cprC = compra.busca_por_identificador(cprC_id)
assert compra.obtem_status(cprC) == 'comprando'
assert compra.obtem_cliente(cprC) == usrC
# Uma compra fechada:
cprF_id = "C-00000004"
