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