public void AgregarTratamientoAsociado(Tratamiento tratamientoPrimario, List<Tratamiento> listaTratamiento)
{
try
{
for (int i = 0; i < listaTratamiento.Count; i++)
{
bool TratamientosAgregados = new DAOTratamiento().SqlAgregarTratamientoAsociado(tratamientoPrimario, listaTratamiento[i]);
}
}
catch (ExcepcionTratamiento e)
{
throw e;
}
catch (ArgumentException e)
{
throw new ExcepcionTratamiento("El parametros invalidos", e);
}
catch (NullReferenceException e)
{
throw new ExcepcionTratamiento("Tratamientos vacios", e);
}
catch (Exception e)
{
throw new ExcepcionTratamiento("Error en la consulta de los Tratamientos", e);
}
}
public void ConsultarXNombreImplementoTest()
{
try
{
DAOTratamiento prueba = new DAOTratamiento();
Entidad tratamiento = FabricaEntidad.NuevoTratamiento();
(tratamiento as Tratamiento).Id = 1;
(tratamiento as Tratamiento).Nombre = "Tratamiento de prueba";
(tratamiento as Tratamiento).Duracion = 2;
(tratamiento as Tratamiento).Costo = 300;
(tratamiento as Tratamiento).Descripcion = "Descripcion de prueba";
(tratamiento as Tratamiento).Explicacion = "Explicacion de prueba";
(tratamiento as Tratamiento).Estado = "Inactivo";
(tratamiento as Tratamiento).Imagen = "Imagen";
List<Entidad> _lista = new List<Entidad>();
String nombreImplemento = "Resina";
DAOImplemento serverImplemento = new DAOImplemento();
_lista = serverImplemento.SqlBuscarXNombreImplemento(nombreImplemento, tratamiento);
//Assert que comprueba que el objeto exista.
Assert.IsNotNull(nombreImplemento);
//Assert para que los string no esten vacios
//Assert.IsNotEmpty(_lista);
}
catch (NullReferenceException e)
{
throw new Exception("no hay objeto", e);
}
}
public void AgregarTratamiento(Tratamiento tratamientoPrimario, List<Implemento> listaImplementos, List<Tratamiento> listaTratamiento)
{
try
{
bool TratamientoAgregado = new DAOTratamiento().SqlAgregarTratamiento(tratamientoPrimario);
int IdTratamientoAgregado = new DAOTratamiento().SqlIdTratmientoNuevo();
tratamientoPrimario.Id = Convert.ToInt16(IdTratamientoAgregado);
AgregarTratamientoAsociado(tratamientoPrimario,listaTratamiento);
for (int i = 0; i < listaImplementos.Count; i++)
{
listaImplementos[i].IdTratamiento = Convert.ToInt16(IdTratamientoAgregado);
}
bool ImplementosAgregados = new LogicaImplemento().AgregarImplemento(listaImplementos);
}
catch (ExcepcionTratamiento e)
{
throw e;
}
catch (ArgumentException e)
{
throw new ExcepcionTratamiento("Parametros invalidos", e);
}
catch (NullReferenceException e)
{
throw new ExcepcionTratamiento("Tratamientos vacios", e);
}
catch (Exception e)
{
throw new ExcepcionTratamiento("Error en agregar Tratamiento", e);
}
}
public void ConstructorTratamientoPrueba()
{
DAOTratamiento prueba = new DAOTratamiento();
Entidad tratamiento = FabricaEntidad.NuevoTratamiento();
(tratamiento as Tratamiento).Nombre = "Tratamiento de prueba";
(tratamiento as Tratamiento).Duracion = 2;
(tratamiento as Tratamiento).Costo = 300;
(tratamiento as Tratamiento).Descripcion = "Descripcion de prueba";
(tratamiento as Tratamiento).Explicacion = "Explicacion de prueba";
(tratamiento as Tratamiento).Estado = "Inactivo";
(tratamiento as Tratamiento).Imagen = "Imagen";
Assert.IsNotNull(prueba.SqlAgregarTratamiento(tratamiento));
Assert.IsTrue(prueba.SqlAgregarTratamiento(tratamiento));
String nombreEsperado = "Tratamiento de prueba";
String descripcionEsperado = "Descripcion de prueba";
String explicacionEsperado = "Explicacion de prueba";
String estadoEsperado = "Inactivo";
Assert.IsNotNull(tratamiento);
//probando gets
Assert.AreEqual((tratamiento as Tratamiento).Nombre, nombreEsperado);
Assert.AreEqual((tratamiento as Tratamiento).Duracion, 2);
Assert.AreEqual((tratamiento as Tratamiento).Costo, 300);
Assert.AreEqual((tratamiento as Tratamiento).Descripcion, descripcionEsperado);
Assert.AreEqual((tratamiento as Tratamiento).Explicacion, explicacionEsperado);
Assert.AreEqual((tratamiento as Tratamiento).Estado, estadoEsperado);
//probando sets
(tratamiento as Tratamiento).Nombre = "Tratamiento de prueba2";
(tratamiento as Tratamiento).Duracion = 20;
(tratamiento as Tratamiento).Costo = 3000;
(tratamiento as Tratamiento).Descripcion = "Descripcion de prueba2";
(tratamiento as Tratamiento).Explicacion = "Explicacion de prueba2";
(tratamiento as Tratamiento).Estado = "Activo";
(tratamiento as Tratamiento).Imagen = "Imagen";
Assert.AreEqual((tratamiento as Tratamiento).Nombre, "Tratamiento de prueba2");
Assert.AreEqual((tratamiento as Tratamiento).Duracion, 20);
Assert.AreEqual((tratamiento as Tratamiento).Costo, 3000);
Assert.AreEqual((tratamiento as Tratamiento).Descripcion, "Descripcion de prueba2");
Assert.AreEqual((tratamiento as Tratamiento).Explicacion, "Explicacion de prueba2");
Assert.AreEqual((tratamiento as Tratamiento).Estado, "Activo");
}
public void CambiarEstadoPrueba()
{
DAOTratamiento prueba = new DAOTratamiento();
Entidad tratamiento = FabricaEntidad.NuevoTratamiento();
(tratamiento as Tratamiento).Nombre = "Tratamiento de prueba";
(tratamiento as Tratamiento).Duracion = 2;
(tratamiento as Tratamiento).Costo = 300;
(tratamiento as Tratamiento).Descripcion = "Descripcion de prueba";
(tratamiento as Tratamiento).Explicacion = "Explicacion de prueba";
(tratamiento as Tratamiento).Estado = "Inactivo";
(tratamiento as Tratamiento).Imagen = "Imagen";
Entidad x = FabricaEntidad.NuevoTratamiento();
(x as Tratamiento).CambiarEstado(tratamiento);
Assert.IsNotNull(prueba.SqlActivarDesactivarTratamiento(tratamiento));
Assert.IsTrue(prueba.SqlActivarDesactivarTratamiento(tratamiento));
Assert.AreNotEqual((x as Tratamiento).Estado, (tratamiento as Tratamiento).Estado);
}
public void ConsultarXNombreTratamientoTest()
{
try
{
List<Tratamiento> listaTratamiento;
String nombreTratamiento="Primera";
DAOTratamiento serverTratamiento = new DAOTratamiento();
listaTratamiento = serverTratamiento.SqlBuscarXNombreTramiento(nombreTratamiento);
//Assert que comprueba que el objeto exista.
Assert.IsNotNull(nombreTratamiento);
//Assert para que los string no esten vacios
Assert.IsNotEmpty(listaTratamiento);
}
catch (NullReferenceException e)
{
throw new Exception("no hay objeto", e);
}
}
public void SqlActicarDesactivarTratamientoTest()
{
try
{
Int16 id1 = 1;
String nombre = "Tratamiento de prueba";
Int16 duracion = 2;
Int16 costo = 300;
String descripcion = "Descripcion de prueba";
String explicacion = "Explicacion de prueba";
String estado = "Inactivo";
bool tratamientoInsertado = false;
Tratamiento miTratamiento = new Tratamiento(id1, nombre, duracion, costo, descripcion, explicacion, estado);
miTratamiento.Imagen = "Imagen";
DAOTratamiento serverTratamiento = new DAOTratamiento();
tratamientoInsertado = serverTratamiento.SqlActivarDesactivarTratamiento(miTratamiento);
//Assert que comprueba que el objeto exista.
Assert.IsNotNull(miTratamiento);
Assert.AreEqual(costo, miTratamiento.Costo);
//Assert para que los string no esten vacios
Assert.IsNotEmpty(miTratamiento.Nombre);
Assert.IsNotEmpty(miTratamiento.Descripcion);
Assert.IsNotEmpty(miTratamiento.Explicacion);
Assert.IsNotEmpty(miTratamiento.Estado);
Assert.IsTrue(tratamientoInsertado);
}
catch (NullReferenceException e)
{
throw new Exception("no hay objeto", e);
}
}
//Consultar Lista Tratamiento LISTO
public List<Tratamiento> ConsultarTratamiento()
{
try
{
List<Tratamiento> miLista = new DAOTratamiento().SqlConsultarTratamiento();
return miLista;
}
catch (ExcepcionTratamiento e)
{
throw e;
}
catch (ArgumentException e)
{
throw new ExcepcionTratamiento("Parametros invalidos", e);
}
catch (NullReferenceException e)
{
throw new ExcepcionTratamiento("Tratamientos vacios", e);
}
catch (Exception e)
{
throw new ExcepcionTratamiento("Error en la consulta de los Tratamientos", e);
}
}
public void sqlBuscarXIdTratamientoTest()
{
Int16 id1 = 1;
DAOTratamiento serverTratamiento = new DAOTratamiento();
Tratamiento miTratamiento = serverTratamiento.SqlBuscarXIdTratamiento(id1);
//Assert que comprueba que el objeto exista.
Assert.IsNotNull(miTratamiento);
//Assert para que los string no esten vacios
Assert.IsNotEmpty(miTratamiento.Nombre);
Assert.IsNotEmpty(miTratamiento.Descripcion);
Assert.IsNotEmpty(miTratamiento.Explicacion);
Assert.IsNotEmpty(miTratamiento.Estado);
}
public void sqlConsultarTratamientoTest()
{
//LogicaTratamiento miTratamiento = new LogicaTratamiento(0,_Nombre,_Duracion,_Costo,_Descripcion,_Explicacion,_Estado);
DAOTratamiento serverTratamiento = new DAOTratamiento();
List<Entidad> listaTratamiento = new List<Entidad>();
listaTratamiento = serverTratamiento.SqlConsultarTratamiento();
//Assert que comprueba que el objeto exista.
Assert.IsNotNull(listaTratamiento);
//Assert que comprueba que el tratamiento no tenga campos vacios donde es obligatorio
Assert.IsNotEmpty(listaTratamiento);
}
public void SqlConsultarTratamientoNoAsociadoTest()
{
try
{
DAOTratamiento prueba = new DAOTratamiento();
Entidad tratamiento = FabricaEntidad.NuevoTratamiento();
(tratamiento as Tratamiento).Id = 1;
(tratamiento as Tratamiento).Nombre = "Tratamiento de prueba";
(tratamiento as Tratamiento).Duracion = 2;
(tratamiento as Tratamiento).Costo = 300;
(tratamiento as Tratamiento).Descripcion = "Descripcion de prueba";
(tratamiento as Tratamiento).Explicacion = "Explicacion de prueba";
(tratamiento as Tratamiento).Estado = "Inactivo";
(tratamiento as Tratamiento).Imagen = "Imagen";
Assert.IsNotNull(prueba.SqlAgregarTratamiento(tratamiento));
Assert.IsTrue(prueba.SqlAgregarTratamiento(tratamiento));
List<Entidad> listaTratamiento = new List<Entidad>();
DAOTratamiento serverTratamiento = new DAOTratamiento();
listaTratamiento = serverTratamiento.ConsultarTratamientoNoAsociado((tratamiento as Tratamiento).Id);
//Assert que comprueba que el objeto exista.
Assert.IsNotNull(tratamiento);
Assert.AreEqual(300, (tratamiento as Tratamiento).Costo);
//Assert para que los string no esten vacios
Assert.IsNotEmpty((tratamiento as Tratamiento).Nombre);
Assert.IsNotEmpty((tratamiento as Tratamiento).Descripcion);
Assert.IsNotEmpty((tratamiento as Tratamiento).Explicacion);
Assert.IsNotEmpty((tratamiento as Tratamiento).Estado);
Assert.IsNotEmpty(listaTratamiento);
}
catch (NullReferenceException e)
{
throw new Exception("no hay objeto", e);
}
}
public void sqlBuscarXIdTratamientoTest()
{
Int16 id1 = 1;
DAOTratamiento serverTratamiento = new DAOTratamiento();
Entidad tratamiento = FabricaEntidad.NuevoTratamiento();
tratamiento = serverTratamiento.SqlBuscarXIdTratamiento(id1);
//Assert que comprueba que el objeto exista.
Assert.IsNotNull(tratamiento);
//Assert para que los string no esten vacios
Assert.IsNotEmpty((tratamiento as Tratamiento).Nombre);
Assert.IsNotEmpty((tratamiento as Tratamiento).Descripcion);
Assert.IsNotEmpty((tratamiento as Tratamiento).Explicacion);
Assert.IsNotEmpty((tratamiento as Tratamiento).Estado);
}
//Consultar Tratamiento por Nombre
public List<Tratamiento> ConsultarXNombreTratamiento(string nombreTratamientoBuscar)
{
try
{
List<Tratamiento> miLista = new DAOTratamiento().SqlBuscarXNombreTramiento(nombreTratamientoBuscar);
return miLista;
}
catch (ArgumentException e)
{
throw new ExcepcionTratamiento("El nombre indicado no es valido", e);
}
catch (NullReferenceException e)
{
throw new ExcepcionTratamiento("No se Tiene ningun Tratamiento con el nombre idicado", e);
}
catch (Exception e)
{
//throw e;
throw new ExcepcionTratamiento("Error en la consulta de los Tratamientos", e);
}
}
//Consultar Tratamiento por ID
public Tratamiento ConsultarXIdTratamiento(int idTratamientoBuscar)
{
try
{
Tratamiento miTratamiento = new DAOTratamiento().SqlBuscarXIdTratamiento(idTratamientoBuscar);
return miTratamiento ;
}
catch (ArgumentException e)
{
throw new ExcepcionTratamiento("Parametros invalidos", e);
}
catch (NullReferenceException e)
{
throw new ExcepcionTratamiento("Tratamientos vacios", e);
}
catch (Exception e)
{
throw new ExcepcionTratamiento("Error en la consulta de los Tratamientos", e);
}
}
public void sqlModificarTratamientoTest()
{
DAOTratamiento prueba = new DAOTratamiento();
Entidad tratamiento = FabricaEntidad.NuevoTratamiento();
(tratamiento as Tratamiento).Id = 1;
(tratamiento as Tratamiento).Nombre = "Tratamiento de prueba";
(tratamiento as Tratamiento).Duracion = 2;
(tratamiento as Tratamiento).Costo = 300;
(tratamiento as Tratamiento).Descripcion = "Descripcion de prueba";
(tratamiento as Tratamiento).Explicacion = "Explicacion de prueba";
(tratamiento as Tratamiento).Estado = "Inactivo";
(tratamiento as Tratamiento).Imagen = "Imagen";
Assert.IsNotNull(prueba.SqlAgregarTratamiento(tratamiento));
Assert.IsTrue(prueba.SqlAgregarTratamiento(tratamiento));
DAOTratamiento serverTratamiento = new DAOTratamiento();
bool prueba1 = serverTratamiento.SqlModificarTratamiento(tratamiento);
//Assert que comprueba que el objeto exista.
Assert.IsNotNull(tratamiento);
//Assert para que los string no esten vacios
Assert.IsNotEmpty((tratamiento as Tratamiento).Nombre);
Assert.IsNotEmpty((tratamiento as Tratamiento).Descripcion);
Assert.IsNotEmpty((tratamiento as Tratamiento).Explicacion);
Assert.IsNotEmpty((tratamiento as Tratamiento).Estado);
Assert.IsNotNull(prueba1);
}
public void SqlAgregarTratamientoAsociadoTest()
{
try
{
//Objeto 1
Int16 id1 = 1;
String nombre = "Tratamiento de prueba 1";
Int16 duracion = 2;
Int16 costo = 300;
String descripcion = "Descripcion de prueba";
String explicacion = "Explicacion de prueba";
String estado = "Inactivo";
//Objeto 2
Int16 id2 = 2;
String nombre2 = "Tratamiento de prueba 2";
Int16 duracion2 = 2;
Int16 costo2 = 300;
String descripcion2 = "Descripcion de prueba";
String explicacion2 = "Explicacion de prueba";
String estado2 = "Inactivo";
bool tratamientoAsociado = false;
Tratamiento miTratamiento = new Tratamiento(id1, nombre, duracion, costo, descripcion, explicacion, estado);
Tratamiento miTratamiento2 = new Tratamiento(id2, nombre2, duracion2, costo2, descripcion2, explicacion2, estado2);
DAOTratamiento serverTratamiento = new DAOTratamiento();
tratamientoAsociado = serverTratamiento.SqlAgregarTratamientoAsociado(miTratamiento, miTratamiento2);
//Assert que comprueba que el objeto exista.
Assert.IsNotNull(miTratamiento);
Assert.IsNotNull(miTratamiento2);
Assert.AreEqual(costo, miTratamiento.Costo);
//Assert para que los string no esten vacios
Assert.Less(0,miTratamiento.Id);
Assert.IsNotEmpty(miTratamiento.Nombre);
Assert.IsNotEmpty(miTratamiento.Descripcion);
Assert.IsNotEmpty(miTratamiento.Explicacion);
Assert.IsNotEmpty(miTratamiento.Estado);
Assert.Less(0, miTratamiento2.Id);
Assert.IsNotEmpty(miTratamiento2.Nombre);
Assert.IsNotEmpty(miTratamiento2.Descripcion);
Assert.IsNotEmpty(miTratamiento2.Explicacion);
Assert.IsNotEmpty(miTratamiento2.Estado);
Assert.IsTrue(tratamientoAsociado);
}
catch (NullReferenceException e)
{
throw new Exception("no hay objeto", e);
}
}
public void EliminarTratamiento(Tratamiento miTratamientos)
{
try
{
bool tratamientoActivo= new DAOTratamiento().SqlActivarDesactivarTratamiento(miTratamientos);
}
catch (ExcepcionTratamiento e)
{
throw e;
}
catch (ArgumentException e)
{
throw new ExcepcionTratamiento("Parametros invalidos", e);
}
catch (NullReferenceException e)
{
throw new ExcepcionTratamiento("Tratamientos vacios", e);
}
catch (Exception e)
{
throw new ExcepcionTratamiento("Error en la consulta de los Tratamientos", e);
}
}
public void ModificarTratamiento(Tratamiento tratamientoPrimario, List<Implemento> listaImplementos, List<Tratamiento> listaTratamiento)
{
try
{
bool modificarTratamientoDetalle = new DAOTratamiento().SqlModificarTratamiento(tratamientoPrimario);
EliminarTratamientoAsociado(tratamientoPrimario);
AgregarTratamientoAsociado(tratamientoPrimario, listaTratamiento);
bool implementosAgregados = new LogicaImplemento().EliminarImplementos(tratamientoPrimario);
bool ImplementosAgregados = new LogicaImplemento().AgregarImplemento(listaImplementos);
}
catch (ExcepcionTratamiento e)
{
throw e;
}
catch (ArgumentException e)
{
throw new ExcepcionTratamiento("Parametros invalidos", e);
}
catch (NullReferenceException e)
{
throw new ExcepcionTratamiento("Tratamiento incorrecto", e);
}
catch (Exception e)
{
throw new ExcepcionTratamiento("Error en la consulta de los Tratamientos", e);
}
}
public void EliminarTratamientoAsociado(Tratamiento tratamientoPrimario)
{
try
{
bool TratamientosAgregados = new DAOTratamiento().SqlEliminarTratamientoAsociado(tratamientoPrimario);
}
catch (ExcepcionTratamiento e)
{
throw e;
}
catch (ArgumentException e)
{
throw new ExcepcionTratamiento("El parametros invalidos", e);
}
catch (NullReferenceException e)
{
throw new ExcepcionTratamiento("Tratamientos vacios", e);
}
catch (Exception e)
{
throw new ExcepcionTratamiento("Error en la consulta de los Tratamientos", e);
}
}
public void ConsultarXEstadoTratamientoTest()
{
try
{
List<Entidad> listaTratamiento = new List<Entidad>();
String EstadoTratamiento = "Activo";
DAOTratamiento serverTratamiento = new DAOTratamiento();
listaTratamiento = serverTratamiento.SqlBuscarXEstadoTramiento(EstadoTratamiento);
//Assert que comprueba que el objeto exista.
Assert.IsNotNull(EstadoTratamiento);
//Assert para que los string no esten vacios
Assert.IsNotEmpty(listaTratamiento);
}
catch (NullReferenceException e)
{
throw new Exception("no hay objeto", e);
}
}
public void sqlModificarTratamientoTest()
{
Int16 id1 = 1;
String _Nombre = "Tratamiento de prueba";
Int16 _Duracion = 2;
Int16 _Costo = 300;
String _Descripcion = "Descripcion de prueba";
String _Explicacion = "Explicacion de prueba";
String _Estado = "Inactivo";
Tratamiento miTratamiento = new Tratamiento(id1, _Nombre, _Duracion, _Costo, _Descripcion, _Explicacion, _Estado);
DAOTratamiento serverTratamiento = new DAOTratamiento();
bool prueba = serverTratamiento.SqlModificarTratamiento(miTratamiento);
//Assert que comprueba que el objeto exista.
Assert.IsNotNull(miTratamiento);
//Assert para que los string no esten vacios
Assert.IsNotEmpty(miTratamiento.Nombre);
Assert.IsNotEmpty(miTratamiento.Descripcion);
Assert.IsNotEmpty(miTratamiento.Explicacion);
Assert.IsNotEmpty(miTratamiento.Estado);
Assert.IsNotNull(prueba);
}