ExtensionesTest_ewmante.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using sage.ew.ewbase;
using System.Reflection;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using sage.ew.interficies;

namespace Sage.ES.S50.UnitTest
{
    static partial class ExtensionesTest
    {
        #region PE-93059 : Extensiones para tipo ewMante

        public static void __Test_Constructores(this ewMante toObjeto)
        {
            //Comprobar número de constructors
            ConstructorInfo[] p = toObjeto.GetType().GetConstructors();
            if (p.Length < 2)
                Assert.Inconclusive("El mantenimiento debe tener como mínimo dos constructores (con y sin código)");

            //TODO Comprobar els valors de les propietats privades de la clase ja que es defineixen al constructor?
        }

        public static void __Test_EwMante_New(this IMante toObjeto, string tcCodigo, bool tlDeleteOnFinish = true, RequiredValues toRequiredValues = null)
        {
            Type loType = toObjeto.GetType();
            IMante target = (IMante)Activator.CreateInstance(loType);
            IMante loadedTarget = (IMante)Activator.CreateInstance(loType);
            //dynamic target = loType.GetConstructor(new Type[] { }).Invoke(new object[] { });
            //dynamic loadedTarget = loType.GetConstructor(new Type[] { }).Invoke(new object[] { });

            bool llResult = false;
            string newNombre = "Registro para " + tcCodigo;

            //Primera prova : Comrpobem que el nou codi no existexi a la BD
            target._Codigo = tcCodigo;
            Assert.AreEqual<bool>(false, target._Existe_Registro(), "No se ha puede hacer el test _New puesto que el código " + tcCodigo + " ya existe en la base de datos");

            //Segona prova: guardar sense definir _Nombre 
            llResult = target._Save();
            Assert.AreEqual<bool>(false, llResult, "Se ha guardado el registro con código " + tcCodigo + " sin definir su nombre");
            //Nota: Tal i com estan els manteniments, el fet de navegar a un codi inexistent genera el registre a la BD sense nom, per lo que aquesta validació falla. 

            //Tercera prova: guardar manteniment amb _Codigo i _Nombre
            target._Nombre = newNombre;
            toRequiredValues?.FillRequiredValues(target);
            llResult = target._Save();
            Assert.AreEqual<bool>(true, llResult, "No se ha guardado el nuevo registro con código " + tcCodigo + ". _Error_Message:" + target._Error_Message);
            //Carreguem el nou registre en un nou objecte
            loadedTarget._Codigo = tcCodigo;
            loadedTarget._Load();
            //Comprobem codi i nom
            Assert.AreEqual<bool>(true, loadedTarget._Existe_Registro(), "No se ha encontrado el nuevo registro '" + loadedTarget._Codigo + "' en la base de datos");
            Assert.AreEqual<string>(tcCodigo, loadedTarget._Codigo, "El campo _Codigo no coincide (" + loadedTarget._Codigo + " - " + tcCodigo + ").");
            Assert.AreEqual<string>(newNombre, loadedTarget._Nombre, "El campo _Nombre no coincide (" + loadedTarget._Nombre + " - " + newNombre + ").");

            if (tlDeleteOnFinish)
            {
                //Quarta prova : Esborrem el registre generat y comprobem que no existeixi
                target._Delete();
                Assert.AreEqual<bool>(false, loadedTarget._Existe_Registro(), "No se ha borrado el registro '" + loadedTarget._Codigo + "' de la base de datos. _Error_Message:" + target._Error_Message);
            }
        }
   
        public static void __Test_EwMante_Load(this IMante toObjeto, string tcCodigo, string tcCodigoNew = "", RequiredValues toRequiredValues = null)
        {
            Type loType = toObjeto.GetType();
            IMante target = (IMante)Activator.CreateInstance(loType);

            bool llDelete = false;
            if (string.IsNullOrWhiteSpace(tcCodigo))
            {
                Assert.AreNotEqual<string>(String.Empty, tcCodigoNew, "Load generando registro: No se ha pasado el código para generar un nuevo registro");
                target._Codigo = tcCodigo;
                Assert.AreEqual<bool>(false, target._Existe_Registro(), "Load generando registro: Se ha encontrado el registro '" + tcCodigo + "' en la base de datos");
                toObjeto.__Test_EwMante_New(tcCodigoNew, tlDeleteOnFinish: false, toRequiredValues: toRequiredValues);
                tcCodigo = tcCodigoNew;
                llDelete = true;
            }

            //Existeix el codi?
            target._Codigo = tcCodigo;
            Assert.AreEqual<bool>(true, target._Existe_Registro(), "No se ha encontrado el registro '" + tcCodigo + "' en la base de datos");

            //Carreguem dades
            target._Load();
            //Comprobem _Codigo y _Nombre
            Assert.AreEqual<string>(tcCodigo, target._Codigo, "El campo _Codigo no coincide (" + tcCodigo + ").");
            Assert.AreNotEqual<string>(String.Empty, target._Nombre, "El campo _Nombre esta vacío (" + tcCodigo + ")");

            if (llDelete)
            {
                IMante loadedTarget = (IMante)Activator.CreateInstance(loType);
                //Carreguem el nou registre en un nou objecte
                loadedTarget._Codigo = tcCodigo;
                loadedTarget._Load();
                //Esborrem el registre generat y comprobem que no existeixi
                target._Delete();
                Assert.AreEqual<bool>(false, loadedTarget._Existe_Registro(), "Load generando registro: No se ha borrado el registro '" + loadedTarget._Codigo + "' de la base de datos. _Error_Message:" + loadedTarget._Error_Message);
            }
        }

        public static void __Test_EwMante_Save(this IMante toObjeto, string tcCodigo, string tcCodigoNew = "", RequiredValues toRequiredValues = null)
        {
            Type loType = toObjeto.GetType();
            IMante target = (IMante)Activator.CreateInstance(loType);
            IMante loadedTarget = (IMante)Activator.CreateInstance(loType);

            bool llDelete = false;
            if (string.IsNullOrWhiteSpace(tcCodigo))
            {
                Assert.AreNotEqual<string>(String.Empty, tcCodigoNew, "Save generando registro: No se ha pasado el código para generar un nuevo registro");
                target._Codigo = tcCodigo;
                Assert.AreEqual<bool>(false, target._Existe_Registro(), "Save generando registro: Se ha encontrado el registro '" + tcCodigo + "' en la base de datos");
                toObjeto.__Test_EwMante_New(tcCodigoNew, tlDeleteOnFinish: false, toRequiredValues: toRequiredValues);
                tcCodigo = tcCodigoNew;
                llDelete = true;
            }

            string lcNombreOriginal = string.Empty;
            string lcNombreModificado = string.Empty;

            //Carreguem el nou registre en un nou objecte
            target._Codigo = tcCodigo;
            //Comprobem que el registre existeixi
            Assert.AreEqual<bool>(true, target._Existe_Registro(), "No se ha encontrado el registro '" + tcCodigo + "' en la base de datos");
            target._Load();
            //El manteniment no pot tindre el nom en blanc
            Assert.AreNotEqual<string>(String.Empty, target._Nombre, "El campo _Nombre del registro esta vacío (" + tcCodigo + ")");
            //Modifiquem el nom i guardem
            lcNombreOriginal = target._Nombre;
            //Si s'ha quedat algun registre amb error sense modificar al seu estat original el modifiquem com estaria inicialment
            if (lcNombreOriginal.StartsWith("(TEST)"))
                lcNombreModificado = lcNombreOriginal.Substring(6);
            else
                lcNombreModificado = "(TEST)" + lcNombreOriginal;
            target._Nombre = lcNombreModificado;
            target._Save();

            //Comprobem el _Nombre amb un nou objecte
            loadedTarget._Codigo = tcCodigo;
            loadedTarget._Load();

            //Task 105067 Excepciones por substring fuera de rango => es un ínidice base 0
            if (loadedTarget._Nombre.Length < lcNombreModificado.Length)
                lcNombreModificado = loadedTarget._Nombre; //La modificación excede el campo nombre => Recorto

            Assert.AreNotEqual<string>(String.Empty, loadedTarget._Nombre, "El campo _Nombre del registro modificado esta vacío (" + tcCodigo + ")");
            
            Assert.AreEqual<string>((lcNombreModificado.Length > loadedTarget._Nombre.Length) ?
                lcNombreModificado.Substring(6, loadedTarget._Nombre.Length) : 
                lcNombreModificado, loadedTarget._Nombre, "El campo _Nombre del registro modificado no coincide (" + tcCodigo + ").");

            //Deixem el manteniment com al principi
            // Hacer un Load para detectar el cambio en el nombre
            target._Load();
            target._Nombre = lcNombreOriginal;
            target._Save();

            //Tornem a comprobar-ho
            //Volvemos a crear objeto loaderTarget ya que sino, no vuelve a cargar los datos (debido al cacheo que realiza internamente (JBuitrago)
            loadedTarget = null;
            loadedTarget = (IMante)Activator.CreateInstance(loType);
            loadedTarget._Codigo = tcCodigo;
            loadedTarget._Load();
            Assert.AreNotEqual<string>(String.Empty, loadedTarget._Nombre, "El campo _Nombre del registro modificado esta vacío (" + tcCodigo + ")");
            Assert.AreEqual<string>((lcNombreOriginal.Length > loadedTarget._Nombre.Length) ? 
                lcNombreOriginal.Substring(0, loadedTarget._Nombre.Length) : 
                lcNombreOriginal, loadedTarget._Nombre, "El campo _Nombre del registro modificado no coincide (" + tcCodigo + ").");

            if (llDelete)
            {
                IMante loadedTarget2 = (IMante)Activator.CreateInstance(loType);
                //Carreguem el nou registre en un nou objecte
                loadedTarget2._Codigo = tcCodigo;
                loadedTarget2._Load();
                //Esborrem el registre generat y comprobem que no existeixi
                target._Delete();
                Assert.AreEqual<bool>(false, loadedTarget2._Existe_Registro(), "Load generando registro: No se ha borrado el registro '" + loadedTarget2._Codigo + "' de la base de datos. _Error_Message:" + loadedTarget2._Error_Message);
            }
        }

        public static void __Test_EwMante_Delete(this IMante toObjeto, string tcCodigo, string tcCodigoNew = "", RequiredValues toRequiredValues = null)
        {
            Type loType = toObjeto.GetType();
            IMante target = (IMante)Activator.CreateInstance(loType);
            IMante loadedTarget = (IMante)Activator.CreateInstance(loType);

            bool llDelete = false;
            if (string.IsNullOrWhiteSpace(tcCodigo))
            {
                Assert.AreNotEqual<string>(String.Empty, tcCodigoNew, "Delete generando registro: No se ha pasado el código para generar un nuevo registro");
                target._Codigo = tcCodigo;
                Assert.AreEqual<bool>(false, target._Existe_Registro(), "Delete generando registro: Se ha encontrado el registro '" + tcCodigo + "' en la base de datos");
                toObjeto.__Test_EwMante_New(tcCodigoNew, tlDeleteOnFinish: false, toRequiredValues: toRequiredValues);
                tcCodigo = tcCodigoNew;
                llDelete = true;
            }

            //Primera prova : Comrpobem que el nou codi no existexi a la BD
            target._Codigo = tcCodigo;
            if (!target._Existe_Registro())
            {
                //El registro no existe. Lo creamos nuevo y luego lo borramos
                target._Codigo = tcCodigo;
                target._Nombre = "Registro temporal";
                toRequiredValues?.FillRequiredValues(target);
                target._Save();
                //Comrpobem que el nou registre s'hagi creat a la BD
                Assert.AreEqual<bool>(true, target._Existe_Registro(), "No se ha puede hacer el test _Delete puesto que no se ha podido crear el registro con código " + tcCodigo);
            }
            else
            {
                //Nou objecte per tornar a crear el registre despres d'esborrarlo
                loadedTarget._Codigo = target._Codigo;
                loadedTarget._Load();
            }

            //Borrem el registre
            if (target._Delete())
            {
                Assert.AreEqual<bool>(false, target._Existe_Registro(), "No se ha borrado el registro con código " + tcCodigo + ". _Error_Message:" + target._Error_Message);
                //Regenerem el registre si cal
                if (!string.IsNullOrWhiteSpace(loadedTarget._Codigo))
                {
                    loadedTarget._Save();
                    Assert.AreEqual<bool>(true, loadedTarget._Existe_Registro(), "No se ha podido regenerar el registro con código " + tcCodigo + ". _Error_Message:" + target._Error_Message);
                }
            }
            else
            {
                //No s'ha pogut esborrar. Comprobem que s'hagi definit el perque a la propietat _Error_Message
                Assert.AreNotEqual<string>(String.Empty, target._Error_Message, "No se ha borrado el registro con código " + tcCodigo + " ni se ha informado el porque en _Error_Message");
            }

            if (llDelete)
            {
                IMante loadedTarget2 = (IMante)Activator.CreateInstance(loType);
                //Carreguem el nou registre en un nou objecte
                loadedTarget2._Codigo = tcCodigo;
                loadedTarget2._Load();
                //Esborrem el registre generat y comprobem que no existeixi
                target._Delete();
                Assert.AreEqual<bool>(false, loadedTarget2._Existe_Registro(), "Load generando registro: No se ha borrado el registro '" + loadedTarget2._Codigo + "' de la base de datos. _Error_Message:" + loadedTarget2._Error_Message);
            }
        }

        public static void __Test_EwMante_New_Load_Save_Delete(this IMante toObjeto, string tcNewCodigo, string tcRandomCodigo, RequiredValues toRequiredValues = null)
        {
            //New
            toObjeto.__Test_EwMante_New(tcNewCodigo,true,toRequiredValues);
            //Load
            toObjeto.__Test_EwMante_Load(tcRandomCodigo, tcNewCodigo, toRequiredValues);
            //Save
            toObjeto.__Test_EwMante_Save(tcRandomCodigo, tcNewCodigo, toRequiredValues);
            //Delete
            toObjeto.__Test_EwMante_Delete(tcNewCodigo, "", toRequiredValues);
            toObjeto.__Test_EwMante_Delete(tcRandomCodigo, tcNewCodigo, toRequiredValues);
        }

        #endregion PE-93059 : Extensiones para tipo ewMante
    }
}