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"