コード例 #1
0
    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)
コード例 #2
0
ファイル: menuUsuario.py プロジェクト: alexdylan/app1
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")
コード例 #3
0
    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)
コード例 #4
0
ファイル: api.py プロジェクト: poenix111/api_littleBB
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)
コード例 #5
0
def login():
    usuario = request.args.get('usuario')
    password = request.args.get('password')
    userDB = Usuario(conexion, cursor)

    print(userDB.login(usuario, password))
    return usuario
コード例 #6
0
 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, "")
コード例 #7
0
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")
コード例 #8
0
 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)
コード例 #9
0
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
コード例 #10
0
ファイル: test_usuario.py プロジェクト: fedeh7/Proyectos
 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)
コード例 #11
0
ファイル: menu.py プロジェクト: bruno2112/TP_Final_Prog2
 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
     }
コード例 #12
0
    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)
コード例 #13
0
 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()
コード例 #14
0
ファイル: cliente.py プロジェクト: rnicola-1605/quick_service
    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()]
コード例 #15
0
ファイル: testeUsuario.py プロジェクト: maurodias/PrinterLAN
 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()
コード例 #16
0
ファイル: test_usuario.py プロジェクト: fedeh7/Proyectos
 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)
コード例 #17
0
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)")
コード例 #18
0
    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)
コード例 #19
0
 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)
コード例 #20
0
ファイル: api.py プロジェクト: poenix111/api_littleBB
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
コード例 #21
0
ファイル: index_back.py プロジェクト: juninhocb/PI
def excluir_usuario():

    id = request.args.get("id")

    Usuario.delete_by_id(id)

    return Cliente()
コード例 #22
0
ファイル: api.py プロジェクト: poenix111/api_littleBB
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
コード例 #23
0
ファイル: main.py プロジェクト: manucirne/birdbook
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 {}
コード例 #24
0
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
コード例 #25
0
ファイル: cliente.py プロジェクト: airkve/trabajofinal
 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 = []
コード例 #26
0
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"
コード例 #27
0
    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
コード例 #28
0
ファイル: servidor.py プロジェクト: MissaelHA/InvernaderoSBD
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
コード例 #29
0
def historial():
    usuario = request.args.get('usuario')

    print('mostrando historial')
    us = Usuario(conexion, cursor)
    resultado = us.historialDeRentas(usuario)
    print(resultado)

    return jsonify(resultado)
コード例 #30
0
ファイル: main.py プロジェクト: manucirne/birdbook
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"
        }
コード例 #31
0
	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})
コード例 #32
0
ファイル: api.py プロジェクト: poenix111/api_littleBB
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'
コード例 #33
0
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
コード例 #34
0
ファイル: estacao_spec.py プロジェクト: joaofeliperm/benete
    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]]})
コード例 #35
0
    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()]
コード例 #36
0
 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)
コード例 #37
0
 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()
コード例 #38
0
 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)
コード例 #39
0
 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)
コード例 #40
0
 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()
コード例 #41
0
    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()
コード例 #42
0
    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()
コード例 #43
0
ファイル: testeUsuario.py プロジェクト: maurodias/PrinterLAN
    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()
コード例 #44
0
 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']]})
コード例 #45
0
    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()
コード例 #46
0
 def teste_deve_criar_uma_conexao(self):
     usuario = Usuario(nome_de_guerra='@usuario', senha='senha')
     usuario.conectar()
     usuario.esta_conectado |should| equal_to(True) 
コード例 #47
0
	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)
コード例 #48
0
ファイル: usuario_spec.py プロジェクト: joaofeliperm/benete
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)
コード例 #49
0
ファイル: usuario_spec.py プロジェクト: joaofeliperm/benete
 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])
コード例 #50
0
ファイル: usuario_spec.py プロジェクト: joaofeliperm/benete
 def setUp(self):
     self.usuario = Usuario('linus', '1234')
     Estacao.estacoes = []
コード例 #51
0
ファイル: testeUsuario.py プロジェクト: maurodias/PrinterLAN
 def test_obter_nome(self):
     usuario = Usuario("diego", "xxx")
     usuario.nome | should | equal_to("diego")
     usuario.apagar_usuario()
コード例 #52
0
ファイル: testeUsuario.py プロジェクト: maurodias/PrinterLAN
 def test_obter_senha(self):
     usuario = Usuario("diego", "xxx")
     usuario.senha | should | equal_to("xxx")
     usuario.apagar_usuario()
コード例 #53
0
 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)
コード例 #54
0
 def testCriarUsuario(self):
     usuario = Usuario('rafael', 'pepe', '123')
     self.assertNotEquals(usuario, None)
     self.assertEquals(usuario.obterLogin(), 'pepe')
コード例 #55
0
ファイル: testeUsuario.py プロジェクト: maurodias/PrinterLAN
 def test_alterar_senha(self):
     usuario2 = Usuario("diego", "xxx")
     usuario2.senha = "54321"
     usuario2.senha | should | equal_to("54321")
     usuario2.apagar_usuario()
コード例 #56
0
ファイル: roles.py プロジェクト: marcosd94/reservas
 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'
コード例 #57
-1
    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()