def __init__(self):
self.negocio_socio = NegocioSocio()
self.root = tk.Tk()
self.configure_gui()
self.create_widgets()
self.populate_treeview()
self.root.mainloop()
def __init__(self, root=None):
super().__init__(root)
self.grid(row=0, column=0, ipady=5, ipadx=5)
self.treeSocios = ttk.Treeview(self, columns=("nombre", "apellido", "dni"))
self.treeSocios.grid(column=0, row=0)
self.treeSocios.heading("#0", text="Id")
self.treeSocios.heading("#1", text="Nombre")
self.treeSocios.heading("#2", text="Apellido")
self.treeSocios.heading("#3", text="DNI")
frameControles = Frame(self)
frameControles.grid(column=0, row=1, sticky='w')
btnAlta = ttk.Button(frameControles, text='Alta', command=self.altaUI)
btnEliminar = ttk.Button(frameControles, text='Baja', command=self.eliminarUI)
btnModificar = ttk.Button(frameControles, text='Modificar', command=self.modificacionUI)
btnAlta.grid(column=0)
btnEliminar.grid(column=1, row=0)
btnModificar.grid(column=2, row=0)
# instancia reglas de negocio
self.capa_negocio = NegocioSocio()
self.llenarTreeSocios()
def __init__(self):
self.app = Tk()
self.app.title("Socios")
self.frame = Frame(self.app)
self.frame.grid(column=0, row=0)
self.treeview = ttk.Treeview(self.frame,
columns=("one", "two", "three"))
self.treeview.heading("#0", text="ID")
self.treeview.heading("one", text="Nombre")
self.treeview.heading("two", text="Apellido")
self.treeview.heading("three", text="DNI")
self.treeview.pack()
self.ns = NegocioSocio()
self.menu = Frame(self.app)
self.menu.grid(row=1, column=0)
self.datos = Frame(self.app)
self.datos.grid(row=2, column=0)
self.muestraDatos()
ttk.Button(self.menu, text="Alta", command=self.alta).grid(row=0,
column=0)
ttk.Button(self.menu, text="Modificacion",
command=self.modificacion).grid(row=0, column=1)
ttk.Button(self.menu, text="Baja", command=self.baja).grid(row=0,
column=2)
self.app.mainloop()
class TestsNegocio(unittest.TestCase):
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
def tearDown(self):
super(TestsNegocio, self).tearDown()
self.ns.datos.borrar_todos()
def test_alta(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
exito = self.ns.alta(socio)
# post-condiciones: 1 socio registrado
self.assertTrue(exito)
self.assertEqual(len(self.ns.todos()), 1)
def test_regla_1(self):
pass
def test_regla_2_nombre_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='J', apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_nombre_mayor_15(self):
pass
def test_regla_2_apellido_menor_3(self):
pass
def test_regla_2_apellido_mayor_15(self):
pass
def test_regla_3(self):
pass
def test_baja(self):
pass
def test_buscar(self):
pass
def test_buscar_dni(self):
pass
def test_todos(self):
pass
def test_modificacion(self):
pass
def cargarSocio(self):
nombre = self.enombre.get()
apellido = self.eapellido.get()
dni = self.edni.get()
cdNegocio = NegocioSocio()
cdNegocio.alta(nombre, apellido, dni)
self.v1.listar()
self.master.destroy()
def realiza():
negocio = NegocioSocio()
sel = tree.selection()[0]
diccionario = tree.item(sel)
id = diccionario['text']
socio = negocio.baja(id)
tree.delete(sel)
modificar.destroy()
def modificarSocio(self):
print('El socio a modificar es:', self.item)
nombre = self.enombre.get()
apellido = self.eapellido.get()
dni = self.edni.get()
id = self.id.get()
cdNegocio = NegocioSocio()
cdNegocio.modificacion(id, nombre, apellido, dni)
self.v1.listar()
self.master.destroy()
def realiza():
negocio = NegocioSocio()
if dni_e.get() != "" and apellido_e.get() != "" and nombre_e.get(
) != "":
socio = negocio.alta(
Socio(dni=dni_e.get(),
nombre=nombre_e.get(),
apellido=apellido_e.get()))
if socio != None:
tree.insert("",
tk.END,
text=id,
values=(nombre_e.get(), apellido_e.get(),
dni_e.get()))
alta.destroy()
else:
messagebox.showerror("Error de Usuario",
"No pueden quedar campos vacíos")
def realiza():
negocio = NegocioSocio()
sel = tree.selection()[0]
diccionario = tree.item(sel)
id = diccionario['text']
socio_mod = negocio.modificacion(
Socio(dni=dni_e.get(),
nombre=nombre_e.get(),
apellido=apellido_e.get()))
if socio_mod != False:
tree.delete(sel)
tree.insert("",
tk.END,
text=id,
values=(nombre_e.get(), apellido_e.get(), dni_e.get()))
modificar.destroy()
else:
messagebox.showerror('Error de datos',
'Los no cumple con los requisitos')
modificar.destroy()
def add_or_update_socio(opcion):
win = Toplevel()
win.configure(background="white")
win.geometry("240x130")
win.resizable(False, False)
win.geometry("+{}+{}".format(
int(win.winfo_screenwidth() / 2 - win.winfo_reqwidth() / 2),
int(win.winfo_screenheight() / 2 - win.winfo_reqheight() / 2),
))
def aceptar(opcion):
if opcion == Opciones.ALTA:
add_socio(dni_socio.get(), nombre_socio.get(),
apellido_socio.get())
else:
update_socio(socio, dni_socio.get(), nombre_socio.get(),
apellido_socio.get())
win.destroy()
add_data_to_table()
root.deiconify()
def cancelar():
win.destroy()
root.deiconify()
dni_socio = IntVar()
nombre_socio = StringVar()
apellido_socio = StringVar()
if opcion == Opciones.MODIFICACION:
ns = NegocioSocio()
socio = ns.buscar(id_socio_seleccionado.get())
if socio == None:
cancelar()
win.title("Modificar socio")
dni_socio.set(socio.dni)
nombre_socio.set(socio.nombre)
apellido_socio.set(socio.apellido)
elif opcion == Opciones.ALTA:
win.title("Crear socio")
Label(win, text="DNI", bg="white").grid(sticky=W + N + S,
column=0,
row=0,
padx=5,
pady=5)
Entry(win, textvariable=dni_socio, bg="white").grid(sticky=E + N + S,
column=1,
columnspan=2,
row=0,
padx=5,
pady=5)
Label(win, text="Nombre", bg="white").grid(sticky=W + N + S,
column=0,
row=1,
padx=5,
pady=5)
Entry(win, textvariable=nombre_socio, bg="white").grid(sticky=E + N + S,
column=1,
columnspan=2,
row=1,
padx=5,
pady=5)
Label(win, text="Apellido", bg="white").grid(sticky=W + N + S,
column=0,
row=2,
padx=5,
pady=5)
Entry(win, textvariable=apellido_socio, bg="white").grid(sticky=E + N + S,
column=1,
columnspan=2,
row=2,
padx=5,
pady=5)
Button(
win,
text="Aceptar",
bg="white",
command=lambda: aceptar(opcion),
height=1,
width=5,
).grid(column=1, row=3, padx=5, pady=5, sticky=W + E + N + S)
Button(
win,
text="Cancelar",
bg="white",
command=lambda: cancelar(),
height=1,
width=5,
).grid(column=2, row=3, padx=5, pady=5, sticky=W + E + N + S)
class UISocio(Frame):
def __init__(self, root=None):
super().__init__(root)
self.grid(row=0, column=0, ipady=5, ipadx=5)
self.treeSocios = ttk.Treeview(self, columns=("nombre", "apellido", "dni"))
self.treeSocios.grid(column=0, row=0)
self.treeSocios.heading("#0", text="Id")
self.treeSocios.heading("#1", text="Nombre")
self.treeSocios.heading("#2", text="Apellido")
self.treeSocios.heading("#3", text="DNI")
frameControles = Frame(self)
frameControles.grid(column=0, row=1, sticky='w')
btnAlta = ttk.Button(frameControles, text='Alta', command=self.altaUI)
btnEliminar = ttk.Button(frameControles, text='Baja', command=self.eliminarUI)
btnModificar = ttk.Button(frameControles, text='Modificar', command=self.modificacionUI)
btnAlta.grid(column=0)
btnEliminar.grid(column=1, row=0)
btnModificar.grid(column=2, row=0)
# instancia reglas de negocio
self.capa_negocio = NegocioSocio()
self.llenarTreeSocios()
def llenarTreeSocios(self):
listSocio = self.capa_negocio.todos()
for socio in listSocio:
self.treeSocios.insert("", END, text=socio.id, values=(socio.nombre, socio.apellido, socio.dni))
def vaciarTreeSocios(self):
self.treeSocios.delete(*self.treeSocios.get_children())
def limpiarTreeSocios(self):
for i in self.treeSocios.get_children():
self.treeSocios.delete(i)
def actualizarTreeSocios(self):
self.limpiarTreeSocios()
self.llenarTreeSocios()
def getSocio(root):
socio = Socio()
socio.nombre = root.txtNombre
socio.apellido = root.txtApelido
socio.dni = root.txtDni
def altaUI(self):
alta = Toplevel()
HandlerSocio(root=alta, form=self, status="A")
def eliminarUI(self):
for socio in self.treeSocios.selection():
self.capa_negocio.baja(self.treeSocios.item(socio)['text'])
self.actualizarTreeSocios()
def modificacionUI(self):
for socio in self.treeSocios.selection():
s = self.capa_negocio.buscar(self.treeSocios.item(socio)['text'])
if s is not None:
modificacion = Toplevel()
HandlerSocio(root=modificacion, form= self , status="M", socio=s)
else:
messagebox.showerror('ERROR', ' Por favor seleccione un socio')
def negocioagregar(self, socio):
return self.capa_negocio.alta(socio)
def negociomodificar(self, socio):
return self.capa_negocio.modificacion(socio)
def negociobuscar(self, dni):
return self.capa_negocio.buscar_dni(dni)
def add_socio(dni, nombre, apellido):
socio = Socio(dni=dni, nombre=nombre, apellido=apellido)
ns = NegocioSocio()
ns.alta(socio)
def add_data_to_table():
delete_frame_grid_controls()
ns = NegocioSocio()
global socios
global id_socio_seleccionado
socios = ns.todos()
cont = 0
Label(frame_grid,
text="",
width=4,
anchor="center",
relief="ridge",
font=(
"Helvetica",
12,
)).grid(row=cont, column=0)
Label(frame_grid,
text="DNI",
width=10,
anchor="center",
relief="ridge",
font=(
"Helvetica",
12,
)).grid(row=cont, column=1)
Label(frame_grid,
text="Nombre",
width=20,
anchor="center",
relief="ridge",
font=("Helvetica", 12)).grid(row=cont, column=2)
Label(frame_grid,
text="Apellido",
width=20,
anchor="center",
relief="ridge",
font=("Helvetica", 12)).grid(row=cont, column=3)
cont += 1
for socio in socios:
Radiobutton(frame_grid,
width=2,
anchor="center",
bg="white",
relief="ridge",
variable=id_socio_seleccionado,
value=socio.id_socio).grid(row=cont, column=0)
Label(frame_grid,
text=socio.dni,
width=10,
anchor="w",
bg="white",
relief="ridge",
font=("Helvetica", 12)).grid(row=cont, column=1)
Label(frame_grid,
text=socio.nombre,
width=20,
anchor="w",
bg="white",
relief="ridge",
font=("Helvetica", 12)).grid(row=cont, column=2)
Label(frame_grid,
text=socio.apellido,
width=20,
anchor="w",
bg="white",
relief="ridge",
font=("Helvetica", 12)).grid(row=cont, column=3)
cont += 1
create_buttons(cont)
class Application:
def __init__(self):
self.app = Tk()
self.app.title("Socios")
self.frame = Frame(self.app)
self.frame.grid(column=0, row=0)
self.treeview = ttk.Treeview(self.frame,
columns=("one", "two", "three"))
self.treeview.heading("#0", text="ID")
self.treeview.heading("one", text="Nombre")
self.treeview.heading("two", text="Apellido")
self.treeview.heading("three", text="DNI")
self.treeview.pack()
self.ns = NegocioSocio()
self.menu = Frame(self.app)
self.menu.grid(row=1, column=0)
self.datos = Frame(self.app)
self.datos.grid(row=2, column=0)
self.muestraDatos()
ttk.Button(self.menu, text="Alta", command=self.alta).grid(row=0,
column=0)
ttk.Button(self.menu, text="Modificacion",
command=self.modificacion).grid(row=0, column=1)
ttk.Button(self.menu, text="Baja", command=self.baja).grid(row=0,
column=2)
self.app.mainloop()
def muestraDatos(self):
self.limpiarGrilla()
socios = self.ns.todos()
for socio in socios:
self.cargarDatos(socio)
def cargarDatos(self, socio):
self.treeview.insert("",
END,
text=socio.id,
values=(socio.nombre, socio.apellido, socio.dni))
def alta(self):
self.limpiarGrilla()
ttk.Label(self.datos, text="Apellido:").grid(column=0, row=1)
ttk.Label(self.datos, text="Nombre:").grid(column=0, row=2)
ttk.Label(self.datos, text="DNI:").grid(column=0, row=3)
self.apellido = ttk.Entry(self.datos, text="")
self.apellido.grid(column=1, row=1, columnspan=2)
self.nombre = ttk.Entry(self.datos, text="")
self.nombre.grid(column=1, row=2, columnspan=2)
self.dni = ttk.Entry(self.datos, text="")
self.dni.grid(column=1, row=3, columnspan=2)
self.errorCampo = ttk.Label(self.datos, text="")
self.errorCampo.grid(column=0, row=5)
ttk.Button(self.datos,
text="Confirmar",
command=lambda: self.agregar()).grid(row=4, column=0)
ttk.Button(self.datos,
text="Cancelar",
command=lambda: self.limpiarGrilla()).grid(row=4, column=1)
def agregar(self):
self.errorCampo.grid_remove()
self.errorCampo = ttk.Label(self.datos, text="")
self.errorCampo.grid(column=0, row=5)
nombre = self.nombre.get()
apellido = self.apellido.get()
dni = self.dni.get()
if nombre == "" or apellido == "" or dni == "":
self.errorCampo.config(text="Debe completar todos los campos")
else:
socio = Socio(dni=dni, apellido=apellido, nombre=nombre)
try:
self.ns.alta(socio)
self.cargarDatos(socio)
except Exception as e:
self.errorCampo.config(text=e)
def modificacion(self):
self.limpiarGrilla()
try:
idPersona = self.treeview.focus()
if self.treeview.item(idPersona)['text'] == "":
ttk.Label(self.datos,
text="Debe seleccionar una fila a modificar").grid(
column=0, row=1)
else:
ttk.Label(self.datos, text="Nombre:").grid(column=0, row=1)
ttk.Label(self.datos, text="Apellido:").grid(column=0, row=2)
ttk.Label(self.datos, text="DNI:").grid(column=0, row=3)
self.idSocio = self.treeview.item(idPersona)['text']
self.nombre = ttk.Entry(self.datos, text="")
self.nombre.grid(column=1, row=1, columnspan=2)
self.nombre.insert(END,
self.treeview.item(idPersona)['values'][0])
self.apellido = ttk.Entry(self.datos, text="")
self.apellido.grid(column=1, row=2, columnspan=2)
self.apellido.insert(
END,
self.treeview.item(idPersona)['values'][1])
self.dni = ttk.Entry(self.datos, text="")
self.dni.grid(column=1, row=3, columnspan=2)
self.dni.insert(END,
self.treeview.item(idPersona)['values'][2])
self.errorCampo = ttk.Label(self.datos, text="")
self.errorCampo.grid(column=0, row=5)
ttk.Button(self.datos,
text="Confirmar",
command=lambda: self.modificar(idPersona)).grid(
row=4, column=0)
ttk.Button(self.datos,
text="Cancelar",
command=lambda: self.limpiarGrilla()).grid(row=4,
column=1)
except:
ttk.Label(self.datos,
text="Debe seleccionar una fila a modificar").grid(
column=0, row=5)
def modificar(self, idPersona):
try:
self.errorCampo.grid_remove()
self.errorCampo = ttk.Label(self.datos, text="")
self.errorCampo.grid(column=0, row=5)
idSocio = self.idSocio
nombre = self.nombre.get()
apellido = self.apellido.get()
dni = self.dni.get()
if nombre == "" or apellido == "" or dni == "":
self.errorCampo.config(text="Debe completar todos los campos")
else:
try:
socio = Socio(id=idSocio,
dni=dni,
apellido=apellido,
nombre=nombre)
if self.ns.modificacion(socio, idSocio):
self.treeview.insert("",
self.treeview.index(idPersona) +
1,
text=idSocio,
values=(nombre, apellido, dni))
self.treeview.delete(idPersona)
self.limpiarGrilla()
ttk.Label(self.datos, text="Modificado").grid(column=0,
row=5)
else:
ttk.Label(self.datos,
text="No se pudo modificar").grid(column=0,
row=5)
except Exception as e:
self.errorCampo.config(text=e)
except:
ttk.Label(self.datos,
text="Debe seleccionar una fila a modificar").grid(
column=0, row=5)
def baja(self):
self.limpiarGrilla()
try:
idPersona = self.treeview.focus()
try:
idSocio = self.treeview.item(idPersona)['text']
if self.ns.baja(id_socio=idSocio):
self.treeview.delete(idPersona)
self.limpiarGrilla()
ttk.Label(self.datos,
text="Baja confirmada").grid(column=0, row=1)
else:
ttk.Label(self.datos,
text="No se pudo eliminar").grid(column=0, row=1)
except Exception as e:
self.errorCampo.config(text=e)
except:
ttk.Label(self.datos,
text="Debe seleccionar una fila a borrar").grid(column=0,
row=1)
def limpiarGrilla(self):
self.datos.grid_remove()
self.datos = Frame(self.app)
self.datos.grid(row=2, column=0)
class TestsNegocio(unittest.TestCase):
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
def tearDown(self):
super(TestsNegocio, self).tearDown()
self.ns.datos.borrar_todos()
def test_alta(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
exito = self.ns.alta(socio)
# post-condiciones: 1 socio registrado
self.assertTrue(exito)
self.assertEqual(len(self.ns.todos()), 1)
def test_regla_1(self):
# valido que socio este registrado
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_1(valido))
self.ns.alta(valido)
incorrecto = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertRaises(DniRepetido, self.ns.regla_1, incorrecto)
def test_regla_2_nombre_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='J', apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_nombre_mayor_15(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombremayor a 15 caracteres
invalido = Socio(dni=12345678,
nombre='Juannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn',
apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# apellido menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='Juan', apellido='P')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_mayor_15(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# apellido mayor a 15 caracteres
invalido = Socio(dni=12345678,
nombre='Juan',
apellido='Peeeeeerrrrrreeeeeezzzzzzzzzzz')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
self.assertTrue(self.ns.regla_3())
# Se añaden mas de 200 socios
dni = 12345678
for y in range(0, 200):
dni += 1
invalido = Socio(dni=dni, nombre='Juan', apellido='Perez')
self.ns.alta(invalido)
self.assertRaises(MaximoAlcanzado, self.ns.regla_3)
def test_baja(self):
# valida baja
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
self.assertTrue(self.ns.baja(valido.id))
# borra un socio que no se ha cargado
invalido = Socio(dni=87654321, nombre='Juan', apellido='Perez')
self.assertFalse(self.ns.baja(invalido.id))
def test_buscar(self):
# valida busqueda
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
self.assertTrue(self.ns.buscar(valido.id))
# Se busca un socio que no se ha cargado
invalido = Socio(dni=87654321, nombre='Giovanni', apellido='Martin')
self.assertFalse(self.ns.buscar(invalido.id))
def test_buscar_dni(self):
# valida busqueda por dni
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
self.assertTrue(self.ns.buscar_dni(valido.dni))
# Se busca por dni un socio que no se ha cargado
invalido = Socio(dni=87654321, nombre='Giovanni', apellido='Martin')
self.assertFalse(self.ns.buscar_dni(invalido.dni))
def test_todos(self):
# valida devoucion de un arreglo de socios no vacio, cargando uno para asegurar la no nulidad de socios
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
assert self.ns.todos() is not None
def test_modificacion(self):
# valida modificacion de socio existente
valido = Socio(dni=453545896875, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
nuevo = Socio(id=valido.id,
dni=545453598798696,
nombre='Juan',
apellido='Perez')
self.assertTrue(self.ns.modificacion(nuevo))
# Se modifica socio inexistente
invalido = Socio(dni=17654321, nombre='Giovani', apellido='Martin')
self.assertFalse(self.ns.modificacion(invalido))
class TestsNegocio(unittest.TestCase):
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
def tearDown(self):
super(TestsNegocio, self).tearDown()
self.ns.datos.borrar_todos()
def test_alta(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
exito = self.ns.alta(socio)
# post-condiciones: 1 socio registrado
self.assertTrue(exito)
self.assertEqual(len(self.ns.todos()), 1)
def test_regla_1(self):
#valida regla
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_1(socio))
#repite dni
self.ns.alta(socio)
error = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertRaises(DniRepetido, self.ns.regla_1, error)
def test_regla_2_nombre_menor_3(self):
# valida regla
correcto = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(correcto))
# nombre menor a 3 caracteres
error = Socio(dni=12345678, nombre='J', apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, error)
def test_regla_2_nombre_mayor_15(self):
# valida regla
correcto = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(correcto))
# nombremayor a 15 caracteres
error = Socio(dni=12345678, nombre='Juaaaaaaaaaaaaaaaaaaaaaaaaaan', apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, error)
def test_regla_2_apellido_menor_3(self):
# valida regla
correcto = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(correcto))
# apellido menor a 3 caracteres
error = Socio(dni=12345678, nombre='Juan', apellido='P')
self.assertRaises(LongitudInvalida, self.ns.regla_2, error)
def test_regla_2_apellido_mayor_15(self):
# valida regla
correcto = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(correcto))
# apellido mayor a 15 caracteres
error = Socio(dni=12345678, nombre='Juan', apellido='Peeeeeeeeeeeeeeeeeeeeeeeeeeeerez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, error)
def test_regla_3(self):
# valida regla
correcto = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(correcto)
self.assertTrue(self.ns.regla_3())
#mas de 200 socios
a=12345679
for y in range(0, 200):
error = Socio(dni=a,nombre='Juan', apellido='Perez')
self.ns.alta(error)
a=a+1
self.assertRaises(MaximoAlcanzado, self.ns.regla_3)
def test_baja(self):
# valida baja
correcto = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(correcto)
self.assertTrue(self.ns.baja(correcto.id))
#borra socio no cargado
error = Socio(dni =12345678, nombre='Juan', apellido='Perez')
self.assertFalse(self.ns.baja(error.id))
def test_buscar(self):
# valida buscar
correcto = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(correcto)
self.assertTrue(self.ns.buscar(correcto.id))
#busca socio no cargado
error = Socio(dni = 444444444, nombre='Juan', apellido='Perez')
self.assertFalse(self.ns.buscar(error.id))
def test_buscar_dni(self):
# valida busqueda por dni
correcto = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(correcto)
self.assertTrue(self.ns.buscar_dni(correcto.dni))
# busca por dni un socio que no se ha cargado
error = Socio(dni = 41028971, nombre='Bruno', apellido='Caracini')
self.assertFalse(self.ns.buscar_dni(error.dni))
def test_todos(self):
# valida devolucion de un arreglo de socios no vacio
correcto = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(correcto)
assert self.ns.todos() != None
def test_modificacion(self):
# valida modificacion
correcto = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(correcto)
modi = Socio(dni=12345679, nombre='Juan Andres', apellido='Perez')
#self.assertTrue(self.ns.modificacion(modi))
# modifica socio que no existe
error = Socio(dni = 44444444, nombre='Juan', apellido='Perez')
self.assertFalse(self.ns.modificacion(error))
class TestsNegocio(unittest.TestCase):
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
def tearDown(self):
super(TestsNegocio, self).tearDown()
self.ns.datos.borrar_todos()
def test_alta(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
exito = self.ns.alta(socio)
# post-condiciones: 1 socio registrado
self.assertTrue(exito)
self.assertEqual(len(self.ns.todos()), 1)
def test_regla_1(self):
#pre-condicion: socio existente
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
exito = self.ns.alta(socio)
self.assertTrue(exito)
#ejecuto la logica (true)
valido = Socio(dni= 38250500, nombre='Carlos', apellido='Arias')
self.assertTrue(self.ns.regla_1(valido))
# Excepcion manejada , DNI repetido
repetido = Socio(dni= 38250500 , nombre='Pedro', apellido = 'Nuñez')
self.assertRaises(DniRepetido , self.ns.regla_1 , repetido)
def test_regla_2_nombre_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='J', apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_nombre_mayor_15(self):
#valida regla
valido = Socio(dni=789456123, nombre='Fabricio', apellido='Fontanelli')
self.assertTrue(self.ns.regla_2(valido))
# nombre mayor a 15 caracteres
invalido = Socio(dni= 789456123 , nombre='Fabricio Emanuel Pablo', apellido ='Fontanelli')
self.assertRaises(LongitudInvalida, self.ns.regla_2 , invalido )
def test_regla_2_apellido_menor_3(self):
#valida regla
valido = Socio(dni=456123789, nombre='German', apellido='Fontanelli')
self.assertTrue(self.ns.regla_2(valido))
# apellido menor a 3 caracteres
invalido = Socio(dni= 456123789 , nombre='German', apellido ='Re')
self.assertRaises(LongitudInvalida, self.ns.regla_2 , invalido )
def test_regla_2_apellido_mayor_15(self):
#valida regla
valido = Socio(dni=753159456, nombre='Damian', apellido='Garcia')
self.assertTrue(self.ns.regla_2(valido))
# apellido apellido mayor a 15
invalido = Socio(dni= 753159456 , nombre='Damian', apellido ='Garcia Perez Moreno')
self.assertRaises(LongitudInvalida, self.ns.regla_2 , invalido )
def test_regla_3(self):
#precondicion : doy de alta 200 socios
for i in range(0, 200):
socio = Socio(dni=i, nombre='Juan', apellido='Perez')
self.ns.alta(socio)
#igual
self.assertEqual(len(self.ns.todos()), 200)
#excepcion
with self.assertRaises(MaximoAlcanzado):
self.ns.regla_3()
def test_baja(self):
#precondicion : 1 socio registrado
socio = Socio(dni=789456123, nombre='Fabricio', apellido='Fontanelli')
exitoAlta = self.ns.alta(socio)
self.assertTrue(exitoAlta)
self.assertEqual(len(self.ns.todos()),1)
#ejecuto logica
exitoBaja = self.ns.baja(socio.id)
#postcondiciones : 1 socio dado de baja
self.assertTrue(exitoBaja)
self.assertEqual(len(self.ns.todos()),0)
def test_buscar(self):
#precondicion : 1 socio existente
socio = Socio(dni=789456123, nombre='Fabricio', apellido='Fontanelli')
exitoAlta = self.ns.alta(socio)
self.assertTrue(exitoAlta)
self.assertEqual(len(self.ns.todos()),1)
#ejecuto la logica - busco el socio
socioBuscado = self.ns.buscar(socio.id)
#postcondiciones - encontre el socio
self.assertEqual(socio , socioBuscado)
#Doy de baja el socio
self.ns.baja(socio.id)
#postcondiciones - no se encontro el socio
self.assertFalse(self.ns.buscar(socio.id))
def test_buscar_dni(self):
#precondicion : 1 socio existente
socio = Socio(dni=789456123, nombre='Fabricio', apellido='Fontanelli')
exitoAlta = self.ns.alta(socio)
self.assertTrue(exitoAlta)
self.assertEqual(len(self.ns.todos()),1)
#ejecuto la logica - busco el socio
socioBuscado = self.ns.buscar_dni(socio.dni)
#postcondiciones - encontre el socio
self.assertEqual(socio,socioBuscado)
#doy de baja el socio
self.ns.baja(socio.id)
#postcondiciones - no encuentro el socio
self.assertFalse(self.ns.buscar_dni(socio.dni))
def test_todos(self):
#precondiciones : no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0 )
#doy de alta socios y valido que los de de alta bien
socio1 = Socio(dni=12345678, nombre='Juan', apellido='Perez')
exito1 = self.ns.alta(socio1)
self.assertTrue(exito1)
socio2 = Socio(dni=78945612, nombre='Damian', apellido='Rios')
exito2 = self.ns.alta(socio2)
self.assertTrue(exito2)
socio3 = Socio(dni=45612378, nombre='John', apellido='Sosa')
exito3 = self.ns.alta(socio3)
self.assertTrue(exito3)
#ejecuto la logica
listaSocios = self.ns.todos()
#postcondiciones - tengo 3 socios cargados
self.assertEqual(len(listaSocios),3)
def test_modificacion(self):
#precondiciones - cargo un socio asi puedo modificar
socio= Socio(dni= 12345678 , nombre = 'Fabricio', apellido = 'Villa')
exitoAlta = self.ns.alta(socio)
self.assertTrue(exitoAlta)
#ejecuto la logica , realizo modificaciones a la instancia
socio.nombre = "Sebastian"
socio.apellido = "Perez"
socio.dni = 45612378
#ejecuto la logica
exitoModificacion= self.ns.modificacion(socio)
#postcondicion : socio modificado
self.assertTrue(exitoModificacion)
#busco el socio
socioEncontrado = self.ns.buscar_dni(45612378)
#compruebo si coincide con la modificacion
self.assertEqual(socioEncontrado.nombre , "Sebastian")
self.assertEqual(socioEncontrado.apellido,"Perez")
class PresentacionSocios:
def __init__(self):
self.negocio_socio = NegocioSocio()
self.root = tk.Tk()
self.configure_gui()
self.create_widgets()
self.populate_treeview()
self.root.mainloop()
def configure_gui(self):
self.root.title('ABM de Socios')
self.root.geometry('1000x600')
def create_widgets(self):
self.frame = ttk.Frame(self.root, padding=10)
self.root.rowconfigure(0, weight=1)
self.root.columnconfigure(0, weight=1)
self.frame.grid(sticky=tk.W + tk.E + tk.N + tk.S)
self.tree = ttk.Treeview(self.frame, columns=('id', 'nombre', 'apellido', 'dni'))
self.tree['show'] = 'headings' # no mostrar columna vacía
self.tree.heading('id', text='Id')
self.tree.heading('nombre', text='Nombre')
self.tree.heading('apellido', text='Apellido')
self.tree.heading('dni', text='DNI')
self.frame.rowconfigure(0, weight=1)
self.frame.columnconfigure(0, weight=1)
self.tree.grid(sticky=tk.W + tk.E + tk.N + tk.S)
self.frame_acciones = ttk.Frame(self.root, padding=(10, 0, 0, 10))
self.frame_acciones.grid(row=1, column=0, sticky=tk.W + tk.E)
self.btn_alta = ttk.Button(self.frame_acciones, text='Alta', command=self.alta_socio)
self.btn_modificacion = ttk.Button(self.frame_acciones, text='Modificación', command=self.modifica_socio)
self.btn_baja = ttk.Button(self.frame_acciones, text='Baja', command=self.baja_socio)
self.btn_alta.pack(side=tk.LEFT, padx=(0, 5))
self.btn_baja.pack(side=tk.LEFT, padx=(0, 5))
self.btn_modificacion.pack(side=tk.LEFT)
def populate_treeview(self):
self.tree.delete(*self.tree.get_children())
lista_socios = self.negocio_socio.todos()
lista_socios.sort(key=attrgetter('nombre', 'apellido')) # ordena por nombre y apellido
for s in lista_socios:
self.tree.insert('', 'end', values=(s.id, s.nombre, s.apellido, s.dni))
def alta_socio(self):
ed = EditaSocio(self.root, self.negocio_socio)
socio = ed.resultado
if socio:
try:
self.negocio_socio.alta(socio)
self.populate_treeview()
except Exception as err:
mbox.showerror('Error', str(err), parent=self.root)
def modifica_socio(self):
item_id = self.tree.focus()
if item_id:
id_socio = self.tree.item(item_id, 'values')[0]
socio = self.negocio_socio.buscar(id_socio)
ed = EditaSocio(self.root, self.negocio_socio, socio=socio)
s = ed.resultado
if s:
try:
self.negocio_socio.modificacion(socio)
self.populate_treeview()
except Exception as err:
mbox.showerror('Error', str(err), parent=self.root)
def baja_socio(self):
item_id = self.tree.focus()
if item_id:
baja = mbox.askyesno('Confirme baja de socio', '¿Realmente desea dar de baja?', default='no',
parent=self.root)
if baja:
id_socio = self.tree.item(item_id, 'values')[0]
self.negocio_socio.baja(id_socio)
self.populate_treeview()
def update_socio(socio, dni, nombre, apellido):
socio.dni = dni
socio.nombre = nombre
socio.apellido = apellido
ns = NegocioSocio()
ns.modificacion(socio)
class TestsNegocio(unittest.TestCase):
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
def tearDown(self):
super(TestsNegocio, self).tearDown()
self.ns.datos.borrar_todos()
def test_alta(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
exito = self.ns.alta(socio)
# post-condiciones: 1 socio registrado
self.assertTrue(exito)
self.assertEqual(len(self.ns.todos()), 1)
def test_regla_1(self):
# valida regla
valido = Socio(dni=12345679, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_1(valido))
self.ns.alta(valido)
# mismo socio despues de agregarlo
invalido = Socio(dni=12345679, nombre='Juan', apellido='Perez')
self.assertRaises(DniRepetido, self.ns.regla_1, invalido)
def test_regla_2_nombre_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='J', apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_nombre_mayor_15(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre menor a 3 caracteres
invalido = Socio(dni=12345678,
nombre='Josecarlosjuanricardo',
apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='Juan', apellido='Per')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_mayor_15(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre menor a 3 caracteres
invalido = Socio(dni=12345678,
nombre='Juan',
apellido='Perezgomezcenturionricardo')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_3(self):
self.assertTrue(self.ns.regla_3)
for i in range(200):
self.ns.alta(Socio(dni=i, nombre='Juan', apellido='Perez'))
self.assertRaises(MaximoAlcanzado, self.ns.regla_3)
def test_baja(self):
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
assert (len(self.ns.todos())) == 1
self.assertTrue(self.ns.baja(valido.id_socio))
assert (len(self.ns.todos())) == 0
self.assertFalse(self.ns.baja(valido.id_socio))
def test_buscar(self):
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
assert self.ns.buscar(valido.id_socio) == valido
def test_buscar_dni(self):
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
assert self.ns.buscar_dni(valido.dni) == valido
def test_todos(self):
assert len(self.ns.todos()) == 0
for i in range(20):
self.ns.alta(Socio(dni=i, nombre='Juan', apellido='Perez'))
assert len(self.ns.todos()) == 20
def test_modificacion(self):
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
self.assertTrue(
self.ns.modificacion(
Socio(id_socio=1,
dni=12345678,
nombre='Juana',
apellido='Perez')))
#Falla la regla 2 por el nombre
self.assertFalse(
self.ns.modificacion(
Socio(id_socio=1, dni=12345678, nombre='Jua',
apellido='Perez')))
#Falla la regla 2 por el apellido
self.assertFalse(
self.ns.modificacion(
Socio(id_socio=1, dni=12345678, nombre='Juana',
apellido='Per')))
class TestsNegocio(unittest.TestCase):
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
def tearDown(self):
super(TestsNegocio, self).tearDown()
self.ns.datos.borrar_todos()
def test_alta(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
exito = self.ns.alta(socio)
# post-condiciones: 1 socio registrado
self.assertTrue(exito)
self.assertEqual(len(self.ns.todos()), 1)
def test_regla_1(self):
socio1 = Socio(dni=22222222, nombre='Juan', apellido='Perez')
self.ns.alta(socio1)
socio2 = Socio(dni=22222222, nombre='Roberto', apellido='Sanchez')
exito = self.ns.regla_1(socio2)
self.assertTrue(exito)
def test_regla_2_nombre_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='J', apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_nombre_mayor_15(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre mayor a 15 caracteres
invalido = Socio(dni=12345678,
nombre='Juanrobertojosematiasermenegildo',
apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# apellido menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='Juan', apellido='P')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_mayor_15(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# apellido mayor a 15 caracteres
invalido = Socio(dni=12345678,
nombre='Juan',
apellido='Perezgomezbolanosdiaz')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_3(self):
socio = Socio(dni=12345677, nombre="Roberto", apellido="Sanchez")
self.ns.alta(socio)
self.assertRaises(MaximoAlcanzado, self.ns.regla_3())
def test_baja(self):
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(socio)
exito = self.ns.baja(socio.id)
self.assertTrue(exito)
def test_buscar(self):
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(socio)
buscado = self.ns.buscar(socio.id)
self.assertEqual(socio, buscado)
def test_buscar_dni(self):
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(socio)
buscado = self.ns.buscar_dni(socio.dni)
self.assertEqual(socio, buscado)
def test_todos(self):
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(socio)
self.assertTrue(self.ns.todos() != None)
def test_modificacion(self):
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
socio.dni = 87654321
socio.roberto = "Roberto"
socio.apellido = "Sanchez"
exito = self.ns.modificacion(socio)
self.assertTrue(exito)
class Ventana1:
def __init__(self, master):
self.master = master
self.master.title('ABM Socios')
self.master.geometry('500x400+0+0')
self.cdNegocio = NegocioSocio()
#=====================================Treeview===========================================================
self.tv = ttk.Treeview(self.master)
self.tv['show'] = 'headings'
self.tv["columns"] = ("one", "two", "three", "four")
vsb = ttk.Scrollbar(self.tv, orient="vertical", command=self.tv.yview)
vsb.place(x=30 + 355 + 2, y=0, height=200 + 20)
#====================================TVColums==============================================================
self.tv.column("one", width=100)
self.tv.column("two", width=100)
self.tv.column("three", width=100)
self.tv.column("four", width=100)
#====================================TVHeadings===========================================================
self.tv.heading("one", text="ID")
self.tv.heading("two", text="Nombre")
self.tv.heading("three", text="Apellido")
self.tv.heading("four", text="DNI")
#===============================Prueba de insertar datos================================================
'''
cdNegocio = NegocioSocio()
socios = cdNegocio.todos()
print('Prueba')
for s in socios:
self.tv.insert("" , 0, values=(s.id,s.nombre,s.apellido,s.dni))
self.tv.pack()
'''
self.listar()
self.frame = Frame(self.master, bg='gray')
self.frame.pack()
self.tv.bind('<ButtonRelease-1>', self.selectItem)
#====================================Variables===========================================================
#=====================================Frames================================================================
self.listado = Frame(self.frame, width=300, height=50)
self.listado.grid(row=2, column=1)
self.botones = Frame(self.frame,
width=100,
height=50,
relief='ridge',
bd=2)
self.botones.grid(row=5, column=1)
#===========================================Botones============================================================
self.btnAlta = Button(self.botones,
text='Agregar',
command=lambda: self.alta())
self.btnAlta.grid(row=1, column=1)
self.btnBaja = Button(self.botones,
text='Borrar',
command=lambda: self.baja())
self.btnBaja.grid(row=1, column=2)
self.btnModificaciones = Button(self.botones,
text='Modificar',
command=lambda: self.modificar())
self.btnModificaciones.grid(row=1, column=3)
self.btnSalir = Button(self.botones,
text='Salir',
background='red',
command=self.master.destroy)
self.btnSalir.grid(row=1, column=4)
self.master.mainloop()
def listar(self):
self.tv.delete(*self.tv.get_children())
socios = self.cdNegocio.todos()
for s in socios:
self.tv.insert("", 0, values=(s.id, s.nombre, s.apellido, s.dni))
self.tv.pack()
def baja(self):
print('El id del Socio a borrar es:', self.itemAc[0])
r = self.deleteme(self.itemAc[1], self.itemAc[2])
if r == 1:
self.cdNegocio.baja(self.itemAc[0])
self.listar()
else:
pass
pass
def modificar(self):
self.new_window(1)
def alta(self):
self.new_window(2)
def new_window(self, t):
# t es un parametro de tipo que me permite conocer por que metodo se solicito la nueva ventana
self.newWindow = Toplevel(self.master)
if t == 2:
self.itemAc = None
self.app = Ventana2(self.newWindow, self, self.itemAc, t)
def selectItem(self, a):
curItem = self.tv.focus()
item = self.tv.item(curItem)
self.itemAc = item['values']
def deleteme(self, n, a):
ressult = messagebox.askquestion("Borrar Socio",
"Borrar al socio: " + n + ' ' + a +
" ?",
icon='warning')
if ressult == 'yes':
return 1
else:
return 0
class TestsNegocio(unittest.TestCase):
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
def tearDown(self):
super(TestsNegocio, self).tearDown()
self.ns.datos.borrar_todos()
def test_alta(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
exito = self.ns.alta(socio)
# post-condiciones: 1 socio registrado
self.assertTrue(exito)
self.assertEqual(len(self.ns.todos()), 1)
def test_regla_1(self):
valido = Socio(dni = 35678942, nombre='Gabriel', apellido='Gomez')
self.assertTrue(self.ns.regla_1(valido))
#dni repetido
invalido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertRaises(DniRepetido, self.ns.regla_1, invalido)
def test_regla_2_nombre_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='J', apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_nombre_mayor_15(self):
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre de mas de 15 caracteres
invalido = Socio(dni=12345678, nombre='Javier Roberto Jose', apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_menor_3(self):
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
#apellido menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='Juan', apellido='P')
self.assertTrue(self.ns.regla_2(invalido))
def test_regla_2_apellido_mayor_15(self):
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
#apellido de mas de 15 caracteres
invalido = Socio(dni=12345678, nombre='Juan', apellido='Perez Rodriguez')
self.assertTrue(self.ns.regla_2(invalido))
def test_regla_3(self):
socio = Socio(dni=45678912, nombre="Luís", apellido="Lopez")
self.ns.alta(socio)
self.assertTrue(self.ns.regla_3())
#socios mayores a 200
socio = Socio(dni=45678912, nombre="Luís", apellido="Lopez")
self.ns.alta(socio)
self.assertRaises(MaximoAlcanzado, self.ns.regla_3())
def test_baja(self):
pass
def test_buscar(self):
pass
def test_buscar_dni(self):
pass
def test_todos(self):
pass
def test_modificacion(self):
pass
class TestsNegocio(unittest.TestCase):
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
self.ns.datos.borrar_todos() # arrancar siempre limpio
def tearDown(self):
super(TestsNegocio, self).tearDown()
self.ns.datos.borrar_todos()
def test_alta(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
exito = self.ns.alta(socio)
# post-condiciones: 1 socio registrado
self.assertTrue(exito)
self.assertEqual(len(self.ns.todos()), 1)
def test_regla_1(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(socio)
# valida regla
valido = Socio(id=socio.id + 1,
dni=12345679,
nombre='Juan',
apellido='García')
self.assertTrue(self.ns.regla_1(valido))
# DNI repetido
invalido = Socio(id=valido.id + 1,
dni=12345678,
nombre='Pedro',
apellido='Gomez')
self.assertRaises(DniRepetido, self.ns.regla_1, invalido)
def test_regla_2_nombre_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre menor o igual a 3 caracteres
invalido = Socio(dni=12345678, nombre='Jua', apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_nombre_mayor_15(self):
# valida regla
valido = Socio(dni=12345678, nombre='María Fernanda', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre mayor o igual a 15 caracteres
invalido = Socio(dni=12345678,
nombre='María Fernandaa',
apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Adrián', apellido='Suar')
self.assertTrue(self.ns.regla_2(valido))
# apellido menor o igual a 3 caracteres
invalido = Socio(dni=12345678, nombre='Adrián', apellido='Sua')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_mayor_15(self):
# valida regla
valido = Socio(dni=12345678,
nombre='Carlos',
apellido='Ibarguengoitia')
self.assertTrue(self.ns.regla_2(valido))
# apellido mayor o igual a 15 caracteres
invalido = Socio(dni=12345678,
nombre='Carlos',
apellido='Ibarguengoitiaa')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_3(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
for i in range(12345678, 12345878): # 200 socios
socio = Socio(dni=i, nombre='Juan', apellido='Perez')
self.ns.alta(socio)
# post-condiciones:
self.assertEqual(len(self.ns.todos()), 200)
self.assertRaises(MaximoAlcanzado, self.ns.regla_3)
def test_baja(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio1 = Socio(dni=12345678, nombre='Juan', apellido='Perez')
socio2 = Socio(dni=12345679, nombre='Juan', apellido='García')
socio3 = Socio(dni=12345680, nombre='Roberto', apellido='Rodríguez')
self.ns.alta(socio1)
self.ns.alta(socio2)
self.ns.alta(socio3)
exito = self.ns.baja(socio2.id)
# post-condiciones:
self.assertTrue(exito)
self.assertEqual(len(self.ns.todos()), 2)
def test_buscar(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio1 = Socio(dni=12345678, nombre='Juan', apellido='Perez')
socio2 = Socio(dni=12345679, nombre='Juan', apellido='García')
socio3 = Socio(dni=12345680, nombre='Roberto', apellido='Rodríguez')
self.ns.alta(socio1)
self.ns.alta(socio2)
self.ns.alta(socio3)
encontrado = self.ns.buscar(socio2.id)
self.assertEqual(encontrado, socio2)
def test_buscar_dni(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio1 = Socio(dni=12345678, nombre='Juan', apellido='Perez')
socio2 = Socio(dni=12345679, nombre='Juan', apellido='García')
socio3 = Socio(dni=12345680, nombre='Roberto', apellido='Rodríguez')
self.ns.alta(socio1)
self.ns.alta(socio2)
self.ns.alta(socio3)
encontrado = self.ns.buscar_dni(socio2.dni)
# post-condiciones: encuentra el socio 2
self.assertEqual(encontrado, socio2)
def test_todos(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio1 = Socio(dni=12345678, nombre='Juan', apellido='Perez')
socio2 = Socio(dni=12345679, nombre='Juan', apellido='García')
socio3 = Socio(dni=12345680, nombre='Roberto', apellido='Rodríguez')
self.ns.alta(socio1)
self.ns.alta(socio2)
self.ns.alta(socio3)
# post-condiciones:
self.assertEqual(len(self.ns.todos()), 3)
def test_modificacion(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(socio)
socio.nombre = 'Pedro'
socio.apellido = 'Gómez'
socio.dni = 12345679
exito = self.ns.modificacion(socio)
socio_modificado = self.ns.buscar(socio.id)
self.assertTrue(exito)
self.assertEqual(socio_modificado.id, socio.id)
self.assertEqual(socio_modificado.nombre, 'Pedro')
self.assertEqual(socio_modificado.apellido, 'Gómez')
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
class TestsNegocio(unittest.TestCase):
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
def tearDown(self):
super(TestsNegocio, self).tearDown()
self.ns.datos.borrar_todos()
def test_alta(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre='Juan', apellido='Perez')
exito = self.ns.alta(socio)
# post-condiciones: 1 socio registrado
self.assertTrue(exito)
self.assertEqual(len(self.ns.todos()), 1)
def test_regla_1(self):
#ejecuto la lógica
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_1(valido))
exito = self.ns.alta(valido)
invalido = Socio(dni=12345678, nombre='Pedro', apellido='Lopez')
self.assertRaises(DniRepetido, self.ns.regla_1, invalido)
def test_regla_2_nombre_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='J', apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_nombre_mayor_15(self):
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# nombre mayor a 15 caracteres
invalido = Socio(dni=12345678,
nombre='JuanPacooooooooooooooooo',
apellido='Perez')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_menor_3(self):
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# apellido menor a 3 caracteres
invalido = Socio(dni=12345678, nombre='Juan', apellido='P')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_mayor_15(self):
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.assertTrue(self.ns.regla_2(valido))
# apellido mayor a 15 caracteres
invalido = Socio(dni=12345678,
nombre='Juan',
apellido='Perezzzzzzzzzzzzzzzzzzzzzzz')
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_3(self):
#valido primer ingreso
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
self.assertTrue(self.ns.regla_3())
#Inscripción de 200 socios
dni = 3912060
for i in range(200):
dni = dni + 1
socio = Socio(dni=dni,
nombre='Juan El ' + str(i),
apellido='Perez')
self.ns.alta(socio)
#Inscripción de socio 201
self.assertRaises(MaximoAlcanzado, self.ns.regla_3)
def test_baja(self):
#baja valida socio existente
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
self.assertTrue(self.ns.baja(valido.id))
# baja invalida socio no inscripto
invalido = Socio(dni=87654321, nombre='Juan', apellido='Perez')
self.assertFalse(self.ns.baja(invalido.id))
def test_buscar(self):
#alta valida y búsqueda válida
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
self.assertIsNotNone(self.ns.buscar(valido.id))
#creación y búsqueda sin alta
invalido = Socio(dni=87654321, nombre='Pedro', apellido='Lopez')
self.assertIsNone(self.ns.buscar(invalido.id))
def test_buscar_dni(self):
# busqueda valida por dni
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
self.assertIsNotNone(self.ns.buscar_dni(valido.dni))
# creación y búsqueda por DNI sin alta
invalido = Socio(dni=87654321, nombre='Pedro', apellido='lopez')
self.assertIsNone(self.ns.buscar_dni(invalido.dni))
def test_todos(self):
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
self.assertIsNotNone(self.ns.todos())
def test_modificacion(self):
# modificacion valida de socio existente
valido = Socio(dni=12345678, nombre='Juan', apellido='Perez')
self.ns.alta(valido)
valido_modif = Socio(id=valido.id,
dni=87654321,
nombre='Pedro',
apellido='Lopez')
self.assertTrue(self.ns.modificacion(valido_modif))
# modificacion socio inexistente
invalido = Socio(id=12312312,
dni=87654321,
nombre='Pedro',
apellido='Lopez')
self.assertFalse(self.ns.modificacion(invalido))
def __init__(self, master):
self.master = master
self.master.title('ABM Socios')
self.master.geometry('500x400+0+0')
self.cdNegocio = NegocioSocio()
#=====================================Treeview===========================================================
self.tv = ttk.Treeview(self.master)
self.tv['show'] = 'headings'
self.tv["columns"] = ("one", "two", "three", "four")
vsb = ttk.Scrollbar(self.tv, orient="vertical", command=self.tv.yview)
vsb.place(x=30 + 355 + 2, y=0, height=200 + 20)
#====================================TVColums==============================================================
self.tv.column("one", width=100)
self.tv.column("two", width=100)
self.tv.column("three", width=100)
self.tv.column("four", width=100)
#====================================TVHeadings===========================================================
self.tv.heading("one", text="ID")
self.tv.heading("two", text="Nombre")
self.tv.heading("three", text="Apellido")
self.tv.heading("four", text="DNI")
#===============================Prueba de insertar datos================================================
'''
cdNegocio = NegocioSocio()
socios = cdNegocio.todos()
print('Prueba')
for s in socios:
self.tv.insert("" , 0, values=(s.id,s.nombre,s.apellido,s.dni))
self.tv.pack()
'''
self.listar()
self.frame = Frame(self.master, bg='gray')
self.frame.pack()
self.tv.bind('<ButtonRelease-1>', self.selectItem)
#====================================Variables===========================================================
#=====================================Frames================================================================
self.listado = Frame(self.frame, width=300, height=50)
self.listado.grid(row=2, column=1)
self.botones = Frame(self.frame,
width=100,
height=50,
relief='ridge',
bd=2)
self.botones.grid(row=5, column=1)
#===========================================Botones============================================================
self.btnAlta = Button(self.botones,
text='Agregar',
command=lambda: self.alta())
self.btnAlta.grid(row=1, column=1)
self.btnBaja = Button(self.botones,
text='Borrar',
command=lambda: self.baja())
self.btnBaja.grid(row=1, column=2)
self.btnModificaciones = Button(self.botones,
text='Modificar',
command=lambda: self.modificar())
self.btnModificaciones.grid(row=1, column=3)
self.btnSalir = Button(self.botones,
text='Salir',
background='red',
command=self.master.destroy)
self.btnSalir.grid(row=1, column=4)
self.master.mainloop()
def delete_socio():
ns = NegocioSocio()
global id_socio_seleccionado
ns.baja(id_socio_seleccionado.get())
add_data_to_table()
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
self.ns.datos.borrar_todos() # arrancar siempre limpio
class TestsNegocio(unittest.TestCase):
def setUp(self):
super(TestsNegocio, self).setUp()
self.ns = NegocioSocio()
def tearDown(self):
super(TestsNegocio, self).tearDown()
self.ns.datos.borrar_todos()
def test_alta(self):
# pre-condiciones: no hay socios registrados
self.assertEqual(len(self.ns.todos()), 0)
# ejecuto la logica
socio = Socio(dni=12345678, nombre="Juan", apellido="Perez")
exito = self.ns.alta(socio)
# post-condiciones: 1 socio registrado
self.assertTrue(exito)
self.assertEqual(len(self.ns.todos()), 1)
def test_regla_1(self):
# valida regla
valido = Socio(dni=45678912, nombre="Luís", apellido="Lopez")
self.assertTrue(self.ns.regla_1(valido))
# DNI socio repetido
invalido = Socio(dni=12345678, nombre="Juan", apellido="Perez")
self.assertRaises(DniRepetido, self.ns.regla_1, invalido)
def test_regla_2_nombre_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre="Juan", apellido="Perez")
self.assertTrue(self.ns.regla_2(valido))
# nombre menor a 3 caracteres
invalido = Socio(dni=12345678, nombre="J", apellido="Perez")
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_nombre_mayor_15(self):
# valida regla
valido = Socio(dni=12345678, nombre="Juan", apellido="Perez")
self.assertTrue(self.ns.regla_2(valido))
# nombre mayor a 15 caracteres
invalido = Socio(dni=12345678,
nombre="Juan Jose Facundo",
apellido="Perez")
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_menor_3(self):
# valida regla
valido = Socio(dni=12345678, nombre="Juan", apellido="Perez")
self.assertTrue(self.ns.regla_2(valido))
# apellido menor a 3 caracteres
invalido = Socio(dni=12345678, nombre="Juan", apellido="P")
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_2_apellido_mayor_15(self):
# valida regla
valido = Socio(dni=12345678, nombre="Juan", apellido="Perez")
self.assertTrue(self.ns.regla_2(valido))
# apellido mayor a 15 caracteres
invalido = Socio(dni=12345678,
nombre="Juan",
apellido="Perez Alvarez Molina")
self.assertRaises(LongitudInvalida, self.ns.regla_2, invalido)
def test_regla_3(self):
# valida regla
socio = Socio(dni=45678912, nombre="Luís", apellido="Lopez")
self.ns.alta(socio)
self.assertTrue(self.ns.regla_3())
# número de socios mayor a 2
socio = Socio(dni=12378945, nombre="Luisa", apellido="Molina")
self.ns.alta(socio)
self.assertRaises(MaximoAlcanzado, self.ns.regla_3)
def test_baja(self):
pass
def test_buscar(self):
pass
def test_buscar_dni(self):
pass
def test_todos(self):
pass
def test_modificacion(self):
pass
