def test_remove_post(self):
conn = self.__class__.connection
pst = Post(conn)
cid = Cidade(conn)
user = Usuario(conn)
# Pega todas as cidades
cids = cid.lista()
oldPst = ('Um novo passaro',
'Encontrei um passaro novo na minha caminhada',
'https://passarito.com')
oldUser = ('david', "*****@*****.**", "David Fogelman", cids[0][0])
user.adiciona(*oldUser)
res = user.acha(oldUser[0])
id = res[0]
pst.adiciona(id, *oldPst)
res = pst.lista()
idPost = res[0][0]
pst.remove(idPost)
res = pst.lista()
self.assertIsNone(res)
class MenuUsuario:
def __init__(self,conexion,cursor):
self.usuario = Usuario(conexion,cursor)
while True:
print("1) Crear Usuario")
print("2) Login")
print("0) Salir")
op = input()
if op == '1':
self.capturar()
elif op == '2':
self.login()
elif op == '0':
break
def capturar(self):
usuario = input("Correo: ")
contra = getpass.getpass("Contraseña: ")
tipo = input("Tipo: ")
self.usuario.crear(usuario, contra, tipo)
def login(self):
usuario = input("Correo: ")
contra = getpass.getpass("Contraseña: ")
if self.usuario.login(usuario,contra):
print("Bienvenido")
else:
print("Usuario/contraseña incorrecta")
def test_adiciona_post(self):
conn = self.__class__.connection
pst = Post(conn)
cid = Cidade(conn)
user = Usuario(conn)
# Pega todas as cidades
cids = cid.lista()
oldPst = ('Um novo passaro',
'Encontrei um passaro novo na minha caminhada',
'https://passarito.com')
oldUser = ('david', "*****@*****.**", "David Fogelman", cids[0][0])
user.adiciona(*oldUser)
res = user.acha(oldUser[0])
self.assertSequenceEqual(res, oldUser)
id = res[0]
pst.adiciona(id, *oldPst)
psts = pst.lista()
self.assertTrue(any(elem in psts[0] for elem in oldPst))
res = pst.acha_por_id(psts[0][0])
self.assertSequenceEqual(res, psts[0])
idPost = psts[0][0]
pst.remove(idPost)
res = pst.lista()
self.assertFalse(res)
def userInfo():
usuario = Usuario(db)
user = request.get_json(force=True)
if(usuario.exists(user['usuario'])):
return jsonify(usuario.showInfo(user['usuario']))
return str(False)
def login():
usuario = request.args.get('usuario')
password = request.args.get('password')
userDB = Usuario(conexion, cursor)
print(userDB.login(usuario, password))
return usuario
def testValidacionRemota(self):
"""El servidor valida correctamente las urls permitidas"""
usuarioPrueba = Usuario(self.username)
url = "http://www.google.com"
respuesta, mensaje = usuarioPrueba.validarRemotamente(url)
self.assertTrue(respuesta)
self.assertEqual(mensaje, "")
class MenuUsuario:
def __init__(self, conexion, cursor):
self.usuario = Usuario(conexion, cursor)
while True:
print("1) Agregar Usuario")
print("2) Login")
print("0) Salir")
op = input()
if op == "1":
self.agregar()
elif op == "2":
self.login()
elif op == "0":
break
def agregar(self):
correo = input("Correo: ")
contra = getpass.getpass("Contraseña: ")
tipo = input("Tipo: ")
self.usuario.crear(correo, contra, tipo)
def login(self):
usuario = input("Ingrese su correo: ")
contra = getpass.getpass("Ingrese su contraseña: ")
if self.usuario.login(usuario, contra):
print("Bienvenido")
else:
print("Hubo un error")
def get_data_users(self, cola, cola2):
user = Usuario()
while True:
data_user = user.getAllUsers()
cola.put(data_user[0])
cola2.put(data_user[1])
sleep(5)
def login():
salir = False
while (salir != True):
formlogin = {}
if debug == 1:
formlogin['mail'] = "*****@*****.**"
formlogin['password'] = "******"
else:
formlogin['mail'] = input("Escriba su mail: ")
formlogin['password'] = getpass.getpass("Escriba su password: "******"Hola " + Fore.GREEN + user.get_nombrecom() + Fore.RESET +
" un gusto tenerte de vuelta!")
menu.menuPrincipal()
menu.ingreso()
username = user.get_nombrecom()
valor = int(input())
if not isinstance(valor, int):
print("solo ingrese numero")
if int(valor) >= 0 and int(valor) <= 3:
menu.opcion(valor, username)
salir = True
else:
print("La opción ingresada no es valida: " + str(valor))
print("Solo ingrese numero del 0 al 3")
print("\n")
else:
print(Fore.RED + " Usuario o contraseña incorrectos" +
Fore.RESET)
salir = False
def test_win(self):
juego = Usuario()
juego.respuesta = "1234"
juego.play("1234")
self.assertEqual(juego.bien, 4)
self.assertEqual(juego.regular, 0)
self.assertFalse(juego.is_playing)
def __init__(self):
self.usuarios = []
self.vehiculos = []
# SUPONEMOS QUE HAY TRES USUARIOS PRE-CARGADOS
self.usuarios.append(
Usuario('Juan', 'Perez', 1, 'meca', TipoUsuariosEnum.MECANICO))
self.usuarios.append(
Usuario('Esteban', 'Quito', 2, 'client', TipoUsuariosEnum.CLIENTE))
self.usuarios.append(
Usuario('Juan', 'Perez', 3, 'dios',
TipoUsuariosEnum.ADMINISTRADOR))
self.opciones_cliente = {
"1": self.cargar_vehiculo_cliente,
"2": self.consultar_service_cliente,
"3": self.listar_vehiculos_cliente,
"4": self.salir
}
self.opciones_admin = {
"0": self.consultar_service,
"1": self.listar_vehiculos,
# "2": self.cargar_vehiculo_cliente,
"3": self.cargar_vehiculo,
"4": self.borrar_vehiculo,
"5": self.listar_usuarios,
# "6": self.listar_vehiculos_cliente,
# "7": self.listar_vehiculos_cliente,
# "8": self.listar_vehiculos_cliente,
"9": self.salir
}
def main(self, usuarios):
print("==================================")
print("| |")
print("| PIZZARIA LUIGI |")
print("| |")
print("==================================")
resp = int(input("Seja bem-vindo! Escolha uma opção:\n<<1>> Logar\n<<2>> cadastrar\n<<3>> Sair\nRESPOSTA: "))
if(resp == 1):
os.system("cls" if os.name == "nt" else "clear")
entrar = Usuario.logar(self)
if(entrar == 1):
os.system("cls" if os.name == "nt" else "clear")
self.menu_funcionario()
if(entrar == 2):
os.system("cls" if os.name == "nt" else "clear")
self.menu_cliente()
if(entrar == False):
Usuario.logar(self)
os.system("cls" if os.name == "nt" else "clear")
self.main(usuarios)
elif(resp == 2):
os.system("cls" if os.name == "nt" else "clear")
Usuario.cadastrar(self, usuarios)
sleep(2)
os.system("cls" if os.name == "nt" else "clear")
self.main(usuarios)
elif(resp == 3):
exit()
else:
print("Resposta inválida, tente novamente!")
sleep(2)
os.system("cls" if os.name == "nt" else "clear")
self.main(usuarios)
def menu_funcionario(self):
print("==================================")
print("| |")
print("| PIZZARIA LUIGI |")
print("| menu do funcionário |")
print("==================================")
resp = int(input("Seja bem-vindo! Escolha uma opção:\n<<1>> Alterar Dados\n<<2>> Fazer Pedido\n<<3>> Voltar a tela inicial\nRESPOSTA: "))
if(resp == 1):
os.system("cls" if os.name == "nt" else "clear")
Usuario.alterarDados(self, usuarios)
os.system("cls" if os.name == "nt" else "clear")
self.menu_funcionario()
elif(resp == 2):
os.system("cls" if os.name == "nt" else "clear")
Usuario.cadastrar(self, usuarios)
os.system("cls" if os.name == "nt" else "clear")
self.menu_funcionario()
elif(resp == 3):
os.system("cls" if os.name == "nt" else "clear")
self.main(usuarios)
else:
print("Resposta inválida, tente novamente!")
sleep(2)
os.system("cls" if os.name == "nt" else "clear")
self.menu_funcionario()
def __init__(self,
id_usuario=None,
id_tipo_usuario=None,
nome=None,
ddd_telefone=None,
telefone=None,
ddd_celular=None,
celular=None,
email=None,
cep_atual=None,
latitude_atual=None,
longitude_atual=None):
Usuario.__init__(self,
id_usuario=id_usuario,
id_tipo_usuario=2,
nome=nome,
ddd_telefone=ddd_telefone,
telefone=telefone,
ddd_celular=ddd_celular,
celular=celular,
email=email,
cep_atual=cep_atual,
latitude_atual=latitude_atual,
longitude_atual=longitude_atual)
self.servicos_buscados = [Servico()]
def test_alterar_nome(self):
usuario2 = Usuario("rodolfo", "123456")
(usuario2._verificar_identidade, "rodolfo") | should | throw(ValueError)
usuario2.nome = "mauro"
usuario2.nome | should | equal_to("mauro")
(usuario2._verificar_identidade, "rodolfo") | should_not | throw(ValueError)
usuario2.apagar_usuario()
def test_bienregular_usuario(self):
juego = Usuario()
juego.respuesta = "1234"
juego.check_bienregular("1243")
self.assertEqual(juego.bien, 2)
self.assertEqual(juego.regular, 2)
self.assertTrue(juego.is_playing)
def opciones(opcion):
if opcion == 1:
usuarios = UsuarioDao.seleccionar()
for idx, usuario in enumerate(usuarios):
print(f"#{idx} - {usuario.__str__()}")
elif opcion == 2:
username = input("Username: "******"Password: "******"Id Usuario: "))
username = input("Username: "******"Password: "******"Id Usuario: "))
usuario = Usuario(id_usuario=id_usuario)
usuario_eliminar = UsuarioDao.eliminar(usuario)
print(f'Usuario eliminar: {usuario_eliminar}')
else:
print("Opcion invalida, digite un valor del (1-5)")
def test_lista_usuarios(self):
conn = self.__class__.connection
cid = Cidade(conn)
user = Usuario(conn)
# Pega todas as cidades
cids = cid.lista()
allUsers = [
('david', "*****@*****.**", "David Fogelman", cids[0][0]),
('david alias', "*****@*****.**", "David Pasaro", cids[0][0])
]
# Verifica que ainda não tem pássaros no sistema.
res = user.lista()
self.assertFalse(res)
# Adiciona alguns perigos.
users_id = []
for u in allUsers:
user.adiciona(*u)
users_id.append(user.acha(u[0]))
# Verifica se os perigos foram adicionados corretamente.
res = user.lista()
self.assertCountEqual(res, (users_id))
# Remove os perigos.
for u in users_id:
user.remove(u[0])
# Verifica que todos os perigos foram removidos.
res = user.lista()
self.assertFalse(res)
def get_data_users(self, cola):
user = Usuario()
while True:
data_user = user.getAllUsers()
cola.put(data_user[0])
#print("dentro de funcion usuarios: ",cola.get())
sleep(5)
def registrarUsuario():
user = Usuario(db)
data = request.get_json(force=True)
user.crear(data)
respuesta = make_response("Registro exitoso")
respuesta.headers.add("Access-Control-Allow-Origin", "*")
return respuesta
def excluir_usuario():
id = request.args.get("id")
Usuario.delete_by_id(id)
return Cliente()
def editarUsuario():
user = Usuario(db)
data = request.get_json(force=True)
print(data)
user.actualizar(data)
respuesta = make_response("Hello World")
respuesta.headers.add("Access-Control-Allow-Origin", "*")
return respuesta
def post_usuario(item: usuarioObj):
usr = Usuario(connection)
try:
usr.adiciona(item.username, item.email, item.nome, item.idCidade)
except Exception as e:
print(e)
return {"error": "Não foi possivel adicionar usuário"}
return {}
def login():
#print(request.args)
usuario = request.args.get('usuario')
password = request.args.get('password')
userDB = Usuario(conexion, cursor)
respuesta = make_response(str(userDB.login(usuario, password)))
respuesta.headers.add('Access-Control-Allow-Origin', '*')
return respuesta
def __init__(self, user_id, dni, nombre, apellido, clave, email, telefono,
direccion, ciudad):
Usuario.__init__(self, email, nombre, apellido, clave)
self.user_id = user_id
self.dni = dni
self.telefono = telefono
self.direccion = direccion
self.ciudad = ciudad
self.historial_compras = []
def login():
#print(request.args)
usuario = request.args.get('usuario')
password = request.args.get('password')
userDB = Usuario(conexion, cursor)
print(userDB.login(usuario, password))
print(usuario, password)
return usuario + " " + password
return "Para hacer login"
def insertar(cls, Usuario):
with CursorDelPool() as cursor:
# .mogrify(sql) mostrara el string que se ejecutara en la BD
logger.debug(cursor.mogrify(cls.__INSERTAR))
valores_insertar = (Usuario.get_username(), Usuario.get_password())
cursor.execute(cls.__INSERTAR, valores_insertar)
cantidad_insertados = cursor.rowcount
return cantidad_insertados
def login():
usuario = request.args.get('username')
password = request.args.get('password')
print("Buscando el usuario: " + usuario + " Contraseña: " + password)
userDB = Usuario(conexion, cursor)
respuesta = make_response(str(userDB.login(usuario, password)))
respuesta.headers.add('Access-Control-Allow-Origin', '*')
return respuesta
def historial():
usuario = request.args.get('usuario')
print('mostrando historial')
us = Usuario(conexion, cursor)
resultado = us.historialDeRentas(usuario)
print(resultado)
return jsonify(resultado)
def delete_usuario(usuario_id: str):
usr = Usuario(connection)
try:
usr.remove(usuario_id)
return {}
except Exception as e:
return {
"error": f"Não foi possivel delerar o usuário {usuario_id} passaro"
}
def it_teste_usuario_deve_enviar_arquivo(self):
usuario = Usuario(nome_de_guerra='usuario', senha='senha')
servidor = Servidor(codigo_patrimonio=10, descricao='oi', capacidade_do_hd=5, quantidade_de_ram=8, estacao=1, quantidade_maxima_de_buffer=10)
impressora = Impressora(10, 'impressora', 100)
impressora.conectar_ao_servidor()
arquivo = Arquivo(nome='file', proprietario=usuario, impressora_destino=impressora)
usuario.conectar()
usuario.enviar_arquivo(arquivo, 1)
usuario.conexao.arquivos_enviados |should| equal_to({arquivo.nome: 1})
def exists():
usuario = Usuario(db)
data = request.get_json(force=True)
""" data = {}
data['usuario'] = request.args.get('usuario') """
if(usuario.exists(data['usuario'])):
return 'True'
else:
return 'False'
def rentar():
usuario = request.args.get('usuario')
salon = request.args.get('salon')
horas = request.args.get('horas')
print('rentando salon')
us = Usuario(conexion, cursor)
resultado = make_response(str(us.rentarSalon(usuario, salon, horas)))
return resultado
def test_informacoes(self):
estacao = Estacao(123, 'MAQ1-GRH', '500GB', '4GB', 'Setor RH')
servidor = ServidorDeImpressora(1234, 'Ricks', 500, 4, 500, 6)
impressora = Impressora(123, 'HP 2341', '100')
servidor.adicionar_impressora(impressora)
impressora.status = 'ocupada'
arquivo = Arquivo('tcc.pdf', 20, 1)
usuario = Usuario('linus', '1234')
usuario.conectar_se_a_rede()
usuario.enviar_arquivo_para_impressao(arquivo, usuario, impressora)
estacao.listar_informacoes() |should| equal_to({'MAQ1-GRH': [123, 'linus', '19/09/2013 - 16:00'], \
'arquivos': [['tcc.pdf', 1]]})
def __init__(self, id_usuario=None, id_tipo_usuario=None,
nome=None, ddd_telefone=None, telefone=None,
ddd_celular=None, celular=None,
email=None, cep_atual=None,
latitude_atual=None, longitude_atual=None):
Usuario.__init__(self, id_usuario=id_usuario, id_tipo_usuario=1,
nome=nome, ddd_telefone=ddd_telefone,
telefone=telefone,
ddd_celular=ddd_celular, celular=celular,
email=email, cep_atual=cep_atual,
latitude_atual=latitude_atual,
longitude_atual=longitude_atual)
self.servicos_prestados = [Servico()]
def testRecargaDominiosDenegados(self):
"""Prueba la recarga de los dominios denegados"""
conexion = sqlite3.connect(config.PATH_DB)
cursor = conexion.cursor()
usuarioPrueba = Usuario(self.username)
url = "http://urldeprueba.com/prueba"
cursor.execute(
'insert into dominios_denegados(url,usuario) values (?,?)',
(url, usuarioPrueba.id, )
)
conexion.commit()
usuarioPrueba.recargarDominiosDenegados()
cursor.execute(
'delete from dominios_denegados where url=? and usuario=?',
(url, usuarioPrueba.id, )
)
conexion.commit()
conexion.close()
self.assertTrue(url in usuarioPrueba.dominios_denegados)
def testVerificarDominioPermitidos(self):
"""Se reconocen los dominios permitidos locales"""
conexion = sqlite3.connect(config.PATH_DB)
cursor = conexion.cursor()
usuarioPrueba = Usuario(self.username)
url = "http://urldeprueba.com/prueba"
cursor.execute(
'insert into dominios_permitidos(url,usuario) values (?,?)',
(url, usuarioPrueba.id, )
)
conexion.commit()
usuarioPrueba.recargarDominiosPermitidos()
self.assertTrue(usuarioPrueba.dominioPermitido(url))
cursor.execute(
'delete from dominios_permitidos where url=? and usuario=?',
(url, usuarioPrueba.id, )
)
conexion.commit()
conexion.close()
def testRecargaDominiosPublicamentePermitidos(self):
"""Prueba la recarga de los dominios publicamente permitidos"""
conexion = sqlite3.connect(config.PATH_DB)
cursor = conexion.cursor()
#hora_url = time.time()
usuarioPrueba = Usuario(self.username)
url = "http://urldeprueba.com/prueba"
cursor.execute(
'insert into dominios_publicamente_permitidos(url) values (?)',
(url,)
)
conexion.commit()
usuarioPrueba.recargarDominiosPublicamentePermitidos()
cursor.execute(
'delete from dominios_publicamente_permitidos where url=?',
(url,)
)
conexion.commit()
conexion.close()
self.assertTrue(url in usuarioPrueba.dominios_publicamente_permitidos)
def testRecargaCacheAceptadas(self):
"""Prueba la recarga de la cache de aceptadas"""
conexion = sqlite3.connect(config.PATH_DB)
cursor = conexion.cursor()
hora_url = time.time()
url = "http://urldeprueba.com/prueba"
cursor.execute(
'insert into cache_urls_aceptadas(url,hora) values (?,?)',
(url, hora_url, )
)
conexion.commit()
usuarioPrueba = Usuario(self.username)
usuarioPrueba.recargarCacheAceptadas()
cursor.execute(
'delete from cache_urls_aceptadas where url=? and hora=?',
(url, hora_url, )
)
conexion.commit()
conexion.close()
self.assertTrue(url in usuarioPrueba.cache_urls_aceptadas)
def testVerificarDominioPublicamenteDenegado(self):
"""Se reconocen los dominios publicamente denegados"""
conexion = sqlite3.connect(config.PATH_DB)
cursor = conexion.cursor()
#hora_url=time.time()
usuarioPrueba = Usuario(self.username)
url = "http://urldeprueba.com/prueba"
dominio = "urldeprueba.com"
cursor.execute(
'insert into dominios_publicamente_denegados(url) values (?)',
(dominio, )
)
conexion.commit()
usuarioPrueba.recargarDominiosPublicamenteDenegados()
self.assertTrue(usuarioPrueba.dominioPublicamenteDenegado(url))
cursor.execute(
'delete from dominios_publicamente_denegados where url=? ',
(dominio, )
)
conexion.commit()
conexion.close()
def test_obter_mais_copias(self):
estacao = Estacao(1,'DELL',4,512,'lab-8')
servidor = Servidor(2,'PC',512,4088,128,10000)
impressora = Impressora(20,'lASERjET HP',40)
usuario = Usuario('mauro','123456')
usuario.logar(estacao)
servidor.adicionar_impressora(impressora)
impressao = Impressao('arquivo1.txt',impressora, usuario)
impressao.copias |should| equal_to(1)
impressao2 =Impressao('arquivo1.txt',impressora, usuario,2)
# impressao |should| equal_to(impressao2)
impressao.copias |should| equal_to(3)
impressao2.copias |should| equal_to(3)
impressao |should| equal_to(impressao2)
impressora.imprimir()
usuario.apagar_usuario()
impressora.destruir_maquina()
estacao.destruir_maquina()
servidor.destruir_maquina()
def test_obter_impressao(self):
estacao = Estacao(1,'DELL',4,512,'lab-8')
servidor = Servidor(2,'PC',512,4088,128,10000)
impressora = Impressora(20,'lASERjET HP',40)
usuario = Usuario('mauro','123456')
usuario.logar(estacao)
servidor.adicionar_impressora(impressora)
impressao = Impressao('arquivo1.txt',impressora, usuario)
(impressao._validar_valor_positivo,1) |should_not| throw(ValueError)
(impressao._validar_valor_positivo,0) |should| throw(ValueError)
impressao.copias |should| equal_to(1)
impressao.arquivo |should| equal_to('arquivo1.txt')
impressao.usuario |should| equal_to(usuario)
impressora.imprimir()
usuario.apagar_usuario()
impressora.destruir_maquina()
estacao.destruir_maquina()
servidor.destruir_maquina()
def test_usuario_logar_deslogar(self):
estacao = Estacao(1, "DELL", 4, 512, "lab-8")
usuario = Usuario("mauro", "maurodias")
usuario.logar(estacao)
estacao.usuario | should | equal_to(usuario)
usuario.atual_estacao | should | equal_to(estacao)
(estacao._verificar_disponibilidade) | should | throw(ValueError)
(usuario._verificar_disponibilidade) | should | throw(ValueError)
estacao.usuario | should | equal_to(usuario)
(estacao.destruir_maquina) | should | throw(ValueError)
usuario.deslogar()
estacao.destruir_maquina()
usuario.apagar_usuario()
def test_lista_arquivos_em_espera_de_cada_impressora(self):
usuario = Usuario('linus', '1234')
estacao = Estacao(123, 'MAQ1-GRH', '500GB', '4GB', 'Setor RH')
impressora1 = Impressora(123, 'HP 2341', '100')
impressora2 = Impressora(456, 'HP 1111', '100')
self.servidor.adicionar_impressora(impressora1)
self.servidor.adicionar_impressora(impressora2)
impressora1.status = 'ocupada'
impressora2.status = 'ocupada'
arquivo1 = Arquivo('tcc.pdf', 20, 1)
arquivo2 = Arquivo('imagem.jpg', 20, 1)
arquivo3 = Arquivo('texto.pdf', 20, 1)
usuario.conectar_se_a_rede()
usuario.enviar_arquivo_para_impressao(arquivo1, usuario, impressora1)
usuario.enviar_arquivo_para_impressao(arquivo2, usuario, impressora1)
usuario.enviar_arquivo_para_impressao(arquivo3, usuario, impressora2)
self.servidor.listar_arquivos_em_espera_de_impressoras() \
|should| equal_to({'HP 2341': [['tcc.pdf', 'linus'], ['imagem.jpg', 'linus']], \
'HP 1111': [['texto.pdf', 'linus']]})
def testPersistirCacheDenegadas(self):
"""Se puede persistir en la db la cache de denegadas"""
conexion = sqlite3.connect(config.PATH_DB)
cursor = conexion.cursor()
#hora_url=time.time()
url = "http://urldepruebaapersisitir.com/persistir/url"
usuarioPrueba = Usuario(self.username)
for i in range(0, config.MAX_CACHE_URLS_DENEGADAS + 1):
usuarioPrueba.persistirACacheDenegadas(url + str(i))
usuarioPrueba.recargarCacheDenegadas()
for i in range(0, config.MAX_CACHE_URLS_DENEGADAS + 1):
self.assertTrue(usuarioPrueba.cacheDenegadas(url + str(i)))
cursor.executemany(
'delete from cache_urls_denegadas where url like ?',
(url + "%")
)
conexion.commit()
conexion.close()
def teste_deve_criar_uma_conexao(self):
usuario = Usuario(nome_de_guerra='@usuario', senha='senha')
usuario.conectar()
usuario.esta_conectado |should| equal_to(True)
def it_teste_usuario_deve_se_conectar(self): usuario = Usuario(nome_de_guerra='usuario', senha='senha') usuario.esta_conectado |should| equal_to(False) usuario.conectar() usuario.esta_conectado |should| equal_to(True) usuario.conexao |should| be_instance_of(Conexao)
class TestUsuario(unittest.TestCase):
def setUp(self):
self.usuario = Usuario('linus', '1234')
Estacao.estacoes = []
def test_usuario_utiliza_estacao(self):
estacao = Estacao(123, 'MAQ1-GRH', '500GB', '4GB', 'Setor RH')
Estacao.adicionar_estacao(estacao)
self.usuario.utilizar_estacao()
self.usuario.estacao |should| equal_to(estacao)
def test_se_nao_houver_estacao_disponivel_retorna_erro(self):
(self.usuario.utilizar_estacao) |should| throw(TypeError("Nenhuma estacao disponivel"))
def test_conectar_se_a_rede(self):
estacao = Estacao(123, 'MAQ1-GRH', '500GB', '4GB', 'Setor RH')
Estacao.adicionar_estacao(estacao)
self.usuario.conectar_se_a_rede()
self.usuario.status_da_conexao |should| equal_to('ativa')
def test_so_pode_haver_uma_unica_conexao_por_usuario(self):
estacao1 = Estacao(123, 'MAQ1-GRH', '500GB', '4GB', 'Setor RH')
estacao2 = Estacao(456, 'MAQ2-CBB', '100GB', '2GB', 'Secretaria CBB')
Estacao.adicionar_estacao(estacao1)
Estacao.adicionar_estacao(estacao2)
self.usuario.conectar_se_a_rede()
(self.usuario.conectar_se_a_rede) |should| throw(TypeError("Usuario ja conectado a rede"))
def test_desconectar_se_da_rede(self):
estacao1 = Estacao(123, 'MAQ1-GRH', '500GB', '4GB', 'Setor RH')
Estacao.adicionar_estacao(estacao1)
self.usuario.conectar_se_a_rede()
self.usuario.desconectar_se_da_rede()
self.usuario.status_da_conexao |should| equal_to('desativada')
def test_mostra_usuarios_ativos(self):
estacao = Estacao(123, 'MAQ1-GRH', '500GB', '4GB', 'Setor RH')
Estacao.adicionar_estacao(estacao)
self.usuario.conectar_se_a_rede()
Usuario.adicionar_usuario_ativo(self.usuario)
Usuario.usuarios_ativos |should| equal_to([self.usuario])
def test_imprimir_arquivo(self):
estacao = Estacao(123, 'MAQ1-GRH', '500GB', '4GB', 'Setor RH')
servidor = ServidorDeImpressora(1234, 'Ricks', 500, 4, 500, 6)
impressora = Impressora(123, 'HP 2341', '100')
servidor.adicionar_impressora(impressora)
arquivo = Arquivo('tcc.pdf', 20, 1)
self.usuario.conectar_se_a_rede()
self.usuario.enviar_arquivo_para_impressao(arquivo, self.usuario, impressora) |should| equal_to('Impressao realizada com sucesso')
def test_imprimir_dois_arquivos_iguais_para_mesmo_usuario_altera_numero_de_copias(self):
estacao = Estacao(123, 'MAQ1-GRH', '500GB', '4GB', 'Setor RH')
servidor = ServidorDeImpressora(1234, 'Ricks', 500, 4, 500, 6)
impressora = Impressora(123, 'HP 2341', '100')
impressora.status = 'ocupada'
servidor.adicionar_impressora(impressora)
arquivo1 = Arquivo('tcc.pdf', 20, 1)
arquivo2 = Arquivo('tcc.pdf', 20, 1)
self.usuario.conectar_se_a_rede()
self.usuario.enviar_arquivo_para_impressao(arquivo1, self.usuario, impressora)
self.usuario.enviar_arquivo_para_impressao(arquivo2, self.usuario, impressora)
servidor.arquivos_em_espera[0][0].copias |should| equal_to(2)
def test_mostra_usuarios_ativos(self):
estacao = Estacao(123, 'MAQ1-GRH', '500GB', '4GB', 'Setor RH')
Estacao.adicionar_estacao(estacao)
self.usuario.conectar_se_a_rede()
Usuario.adicionar_usuario_ativo(self.usuario)
Usuario.usuarios_ativos |should| equal_to([self.usuario])
def setUp(self):
self.usuario = Usuario('linus', '1234')
Estacao.estacoes = []
def test_obter_nome(self):
usuario = Usuario("diego", "xxx")
usuario.nome | should | equal_to("diego")
usuario.apagar_usuario()
def test_obter_senha(self):
usuario = Usuario("diego", "xxx")
usuario.senha | should | equal_to("xxx")
usuario.apagar_usuario()
def testRechazoRemota(self):
"""El servidor rechaza correctamente las urls denegadas"""
usuarioPrueba = Usuario(self.username)
url = "http://www.redtube.net"
respuesta, mensaje = usuarioPrueba.validarRemotamente(url)
self.assertFalse(respuesta)
def testCriarUsuario(self):
usuario = Usuario('rafael', 'pepe', '123')
self.assertNotEquals(usuario, None)
self.assertEquals(usuario.obterLogin(), 'pepe')
def test_alterar_senha(self):
usuario2 = Usuario("diego", "xxx")
usuario2.senha = "54321"
usuario2.senha | should | equal_to("54321")
usuario2.apagar_usuario()
def __init__(self, nombre,apellido,documento_identidad,fecha_nacimiento,sexo,cargo,fecha_ingreso,codigo,usuario,password,Dependencia):
Usuario.__init__(self, nombre,apellido,documento_identidad,fecha_nacimiento,sexo,cargo,fecha_ingreso,codigo,usuario,password,Dependencia)
self.rol='Gestor'
def test_listar_estacoes_usuarios(self):
usuario = Usuario('Luiz Mauro Piraciaba Cassiano Dias','123456')
usuario2 = Usuario('fabio','123456')
estacao = Estacao(1,'DELL',4,512,'lab-8')
servidor = Servidor(2,'PC',512,4088,128,10000)
impressora = Impressora(20,'lASERjET HP',40)
usuario2.logar(estacao)
servidor.adicionar_impressora(impressora)
impressao = Impressao('arquivo3.txt',impressora, usuario2,40)
impressora.linha_lista(impressora,impressao) |should| equal_to('| arquivo3.txt | fabio |')
usuario2.deslogar()
#truncating
usuario.logar(estacao)
impressao2 = Impressao('Relatorio unico de surpresa do dia de agosto do ano 2012.txt',impressora, usuario,10)
impressora.linha_lista(impressora,impressao2) |should| equal_to('| Relatorio unico de surpresa d... | Luiz Mauro Piraciaba Cassiano...|')
Impressora.mostrar_fila() |should_not| equal_to('Nenhuma impressora')
impressora.imprimir()
impressora.imprimir()
usuario.apagar_usuario()
usuario2.apagar_usuario()
impressora.destruir_maquina()
estacao.destruir_maquina()
servidor.destruir_maquina()