ExtensionesTest.cs

using System;
using System.Windows.Forms;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using sage.ew.db;
using sage.ew.global;
using System.Data;
using System.IO;
using sage.ew.ewbase;
using System.Reflection;
using sage.ew.functions.Clases.DiccionariosLoader;
using sage.ew.functions.Clases;
using Sage.ES.S50.Addons;
using sage.ew.functions;
using sage.ew.global.Diccionarios;
using Sage.ES.S50.UnitTest.Mock.Mock;
using Sage.ES.S50.UnitTest.Mock;
using sage.ew.interficies;

namespace Sage.ES.S50.UnitTest

{
    static partial class ExtensionesTest
    {
        #region Extensiones de entorno de test

        //private static TestContext _contexto = null;
        private static bool _CargaEjecutada = false;

        public static void __Test_LoadRandomConfig(this TestContext toContexto)
        {
            //Stopwatch timer = new Stopwatch();
            //timer.Start();

            if (_CargaEjecutada)
            {
                //Este método tiene una penalización brutal (30-60seg) y se ejecuta por cada clase de preuba 
                //con el objetivo de garantizar una configuración cargada... Este objetivo se consige la primera vez
                //para el resto de clases de prueba que se ejecuten en el mismo bloque no es necesario y no aporta nada

                //Pruebo de cargar un valor
                var claveDePruebaPresente = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_ConfigUnitTestLoaded", false));
                if (claveDePruebaPresente)
                {
                    return;
                }
            }

            __Test_LoadRandomConfigWithoutDictionary(toContexto);
            //toContexto.WriteLine($"LoadRandomConfig sin diccionarios {timer.ElapsedMilliseconds} ms");

            // Bajar fichero Sagelic
            LICENCIAS._ObtenerLicenciaActual();
            if (!LICENCIAS._Validar_Licencia_Suscripcion())
                Assert.Fail("Error al validar la licencia de suscripción.");
            //toContexto.WriteLine($"LoadRandomConfig validada la licencia {timer.ElapsedMilliseconds} ms");

            _CargaEjecutada = true;
            EW_GLOBAL.ValorEnClave_VarGlob("wl_ConfigUnitTestLoaded", true);
            

        }
        public static void __Test_LoadRandomConfigWithoutDictionary(this TestContext toContexto)
        {
            string lcEmpresa = System.Configuration.ConfigurationManager.AppSettings["_Empresa"].ToString();
            string lcCaja = System.Configuration.ConfigurationManager.AppSettings["_Caja"].ToString();
            string lcXmlConfig = System.Configuration.ConfigurationManager.AppSettings["_XmlConfig"].ToString();

            __Test_SQLConnect(toContexto);
            if (string.IsNullOrWhiteSpace(lcEmpresa))
                lcEmpresa = EmpresaAleatoria(toContexto);
            if (string.IsNullOrWhiteSpace(lcCaja))
                lcCaja = CajaAleatoria(toContexto);

            string dirName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            EW_GLOBAL.ValorEnClave_VarGlob("wl_sage50", true);  // PE-97745
            EW_GLOBAL.ValorEnClave_VarGlob("wc_usuario", "SUPERVISOR"); //Asignar usuario SUPERVISOR, en este punto el usuario actual es SUPERVISOR_NET
            EW_GLOBAL.ValorEnClave_VarGlob("wc_pathinicio", dirName);
            EW_GLOBAL.ValorEnClave_VarGlob("wc_iniservidor", dirName);
            EW_GLOBAL.ValorEnClave_VarGlob("wn_TipoProd", 2);

            InitializeDependencyInjectionMock();

            //Cargo diccionarios
            DiccionariosLoader.CargarDiccionarios(lcEmpresa, lcCaja);

            if (!string.IsNullOrWhiteSpace(lcXmlConfig) && File.Exists(lcXmlConfig))
                EW_GLOBAL._CargarVarExtra(lcXmlConfig);

            LoadAddons();
            
            EW_GLOBAL._Empresa = new sage.ew.empresa.Empresa(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));
        }
        public static void __Test_SQLConnect( this TestContext toContexto)
        {
            string lcServer = System.Configuration.ConfigurationManager.AppSettings["_Server"].ToString();
            string lcUser = System.Configuration.ConfigurationManager.AppSettings["_User"].ToString();
            string lcPass = System.Configuration.ConfigurationManager.AppSettings["_Pass"].ToString();
            string lcComunes = System.Configuration.ConfigurationManager.AppSettings["_Comunes"].ToString();

            if (DB.SQLChangeConnection("eurowin"))
                return;

            // Cargar diccionarios ESTANDARD 8.0
            DB.SQLConnect(lcServer, lcUser, lcPass, lcComunes, tcAliasConexion: "eurowin");

        }
        public static void LoadAddons()
        {
            string dirName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
            EW_GLOBAL.ValorEnClave_VarGlob("wc_pathinicio", dirName);
            EW_GLOBAL.ValorEnClave_VarGlob("wc_iniservidor", dirName);
            bool addonsCargados = AddonsController.Instance.AddonsManager._CargarAddOns(new FunctionsDependencies()
            {
                GenerarChecksumOpciones = Criptografia.GenerarChecksumOpciones,
                GetSage50PathLibrerias = FUNCTIONS.GetSage50PathLibrerias,
                CodigoLicencia = LICENCIAS._CodigoLicencia
            }
            );

            // Esperar a finalizar la carga asincrona de los addons            
            addonsCargados = AddonsController.Instance.AddonsManager._CargarAddons_WaitAll();
            if (!addonsCargados)
            {
                Assert.Fail(DiccionarioFactory.GetDiccionarioGlobal().GetValue("error_carga_addons").ToString());
            }
        }

        public static string __FieldAleatorioNew(this TestContext toContexto, string tcDataBase, string tcTable, string tcField = "CODIGO", int tnLenCampoEntero = 9)
        {
            int lnLen = 0, lnMax = 0, lnCont = 0;
            bool lltrobat = false;
            DataTable ldtTemp = new DataTable();
            string lcCodigo = string.Empty;
            string lcSql = "SELECT a.*,b.name as tipo_campo "
                        + " FROM " + DB.SQLDatabase(tcDataBase, "columns", true) + " as a inner join " + DB.SQLDatabase(tcDataBase, "types", true) + " as b on a.system_type_id=b.system_type_id "
                        + " WHERE [object_id] = (select object_id from " + DB.SQLDatabase(tcDataBase, "tables", true) + " as c where c.name=" + DB.SQLString(tcTable) + ") AND a.name=" + DB.SQLString(tcField) + ";";
            DB.SQLExec(lcSql, ref ldtTemp);

            if (ldtTemp != null && ldtTemp.Rows.Count > 0)
            {
                if (ldtTemp.Rows[0]["tipo_campo"].ToString().Contains("char") || ldtTemp.Rows[0]["tipo_campo"].ToString().Contains("text"))
                {
                    //Campo de tipo string
                    System.Reflection.PropertyInfo loPropiedad = typeof(String).GetType().GetProperty("Chars");
                    if (ldtTemp.Rows[0]["tipo_campo"].ToString().Contains("text"))
                        lnLen = Int32.MaxValue; //lenght for text fields
                    else
                        lnLen = Convert.ToInt32(ldtTemp.Rows[0]["max_length"].ToString());

                    lnMax = (lnLen == Int32.MaxValue) ? 1000 : (int)Math.Pow(10, lnLen) - 1;

                    do
                    {
                        lltrobat = false;
                        //dynamic loNuevo = loPropiedad.__Get_Random_Value();
                        lcCodigo = Guid.NewGuid().ToString().ToUpper();
                        if (lcCodigo.Length > lnLen)
                            lcCodigo = lcCodigo.Substring(0, lnLen);
                        string loTemp = DB.SQLValor(tcTable, tcField, lcCodigo, tcField, tcDataBase).ToString();
                        if (!string.IsNullOrWhiteSpace(loTemp))
                            lltrobat = true;

                        ++lnCont;
                        if (lnCont > lnMax)
                        {
                            lcCodigo = string.Empty;
                            lltrobat = false;
                        }

                    } while (lltrobat);
                    
                }
                else if (ldtTemp.Rows[0]["tipo_campo"].ToString().Contains("int"))
                {
                    //Campo de tipo numérico
                    Random r = new Random();
                    //lnLen = Convert.ToInt32(ldtTemp.Rows[0]["max_length"].ToString());
                    lnLen = tnLenCampoEntero > 0 ? tnLenCampoEntero : 9;
                    lnMax = (int)Math.Pow(10, lnLen) - 1;
                    do
                    {
                        lltrobat = false;
                        lcCodigo = r.Next(0, Int32.MaxValue).ToString();
                        if (lcCodigo.Length > lnLen)
                            lcCodigo = lcCodigo.Substring(0, lnLen);
                        string loTemp = DB.SQLValor(tcTable, tcField, lcCodigo, tcField, tcDataBase).ToString();
                        if (!string.IsNullOrWhiteSpace(loTemp) && loTemp != "0")
                            lltrobat = true;

                        ++lnCont;
                        if (lnCont > lnMax)
                        {
                            lcCodigo = string.Empty;
                            lltrobat = false;
                        }


                    } while (lltrobat);
                }
            }

            return lcCodigo;
        }

        public static string __FieldAleatorio(this TestContext toContexto, string tcDataBase, string tcTable, string tcField = "CODIGO")
        {
            string lcCodigoAleatoria = string.Empty;
            bool llOk = false;
            string lcSql = string.Empty;
            DataTable ldtResult = new DataTable();

            lcSql = "SELECT " + tcField + " FROM " + DB.SQLDatabase(tcDataBase, tcTable) + " WHERE " + tcField + " <> ''";
            llOk = DB.SQLExec(lcSql, ref ldtResult);
            if (llOk && ldtResult.Rows.Count > 0)
            {
                int lnMax = ldtResult.Rows.Count;
                Random loRand = new Random();
                int lnRandomIndex = loRand.Next(0, lnMax);

                lcCodigoAleatoria = ldtResult.Rows[lnRandomIndex][tcField].ToString();
            }
            //else Assert.Fail(tcTable + ": No se ha podido establecer un entorno para el test.");

            return lcCodigoAleatoria;
        }

        public static object __FieldDatabase(this TestContext toContexto, string tcDataBase, string tcTable, string valueFiltro, string tcFieldFiltro = "CODIGO", string tcFieldReturn = "NOMBRE")
        {
            object oFieldValue = new object();
            bool llOk = false;
            string lcSql = string.Empty;
            DataTable ldtResult = new DataTable();

            lcSql = "SELECT " + tcFieldReturn + " FROM " + DB.SQLDatabase(tcDataBase, tcTable) + " WHERE " + tcFieldFiltro + " = '" + valueFiltro.Trim() + "'";
            llOk = DB.SQLExec(lcSql, ref ldtResult);
            if (llOk && ldtResult.Rows.Count > 0)
            {
                oFieldValue = ldtResult.Rows[0][tcFieldReturn];
            }
            //else Assert.Fail(tcTable + ": No se ha podido establecer un entorno para el test.");

            return oFieldValue;
        }

        public static string __AnteriorEjercicio(this TestContext toContexto)
        {
            return DB._AnteriorEjercicio();
        }

        public static string __SiguienteEjercicio(this TestContext toContexto)
        {
            return DB._SiguienteEjercicio();
        }

        public static string __ActualEjercicio(this TestContext toContexto)
        {
            return DB.Ejercicio_EW;
        }

        public static bool __EsPenultimoEjercicio(this TestContext toContexto)
        {            
            return DB._EsPenultimoEjercicio();
        }

        private static string EmpresaAleatoria(this TestContext toContexto)
        {
            return toContexto.__FieldAleatorio("GESTION", "EMPRESA", "CODIGO");
        }

        private static string CajaAleatoria(this TestContext toContexto)
        {
            return toContexto.__FieldAleatorio("TPV", "CAJAS", "CODIGO");
        }

        #endregion Extensiones de entorno de test


        public static void __Test_MayorQueZero(this Control toControl, string tcNombrePropiedad)
        {
            //Recupero la propiedad
            System.Reflection.PropertyInfo loPropiedades = toControl.GetType().GetProperty(tcNombrePropiedad);

            //Validaciones de tipo de datos (espero un INT o un DECIMAL)
            bool llTipoCorrecto = false;
            //Espero tipos Decimal o Int32... pero es ampliable a otros tipos
            llTipoCorrecto = (loPropiedades.PropertyType.Name == "Decimal" || loPropiedades.PropertyType.Name == "Int32");
            Assert.AreEqual<bool>(llTipoCorrecto, true, "Tipo " + loPropiedades.PropertyType.Name + " no contemplado para unit test genericas.");

            dynamic lnDefault = (dynamic)loPropiedades.GetValue(toControl, null);
            dynamic lnZero = 0, lnNegativo = 0, lnPositivo = 0;
            dynamic lnActual;

            switch (loPropiedades.PropertyType.Name)
            {
                case "Decimal":
                    lnZero = 0M;
                    lnNegativo = -20M;
                    lnPositivo = 20M;
                    break;

                case "Int16":
                case "Int32":
                case "Int64":
                    lnZero = 0;
                    lnNegativo = -20;
                    lnPositivo = 20;
                    break;
            }


            //Valor 0
            loPropiedades.SetValue(toControl, lnZero, null);
            lnActual = (dynamic)loPropiedades.GetValue(toControl, null);
            Assert.AreNotEqual<dynamic>(lnActual, lnZero, "Propiedad " + tcNombrePropiedad + " admite un valor 0");

            loPropiedades.SetValue(toControl, lnNegativo, null);
            lnActual = (dynamic)loPropiedades.GetValue(toControl, null);
            Assert.AreNotEqual<dynamic>(lnActual, lnNegativo, "Propiedad " + tcNombrePropiedad + " admite negativos");

            lnPositivo = 20;
            loPropiedades.SetValue(toControl, lnPositivo, null);
            lnActual = (dynamic)loPropiedades.GetValue(toControl, null);
            Assert.AreEqual<dynamic>(lnActual, lnPositivo, "Propiedad " + tcNombrePropiedad + " no asigna correctamente el valor");
        }

        public static void __Test_SoloGET<T>(this Control toControl, string tcNombrePropiedad)
        {
            //Recupero la propiedad
            System.Reflection.PropertyInfo loPropiedades = toControl.GetType().GetProperty(tcNombrePropiedad);
            
            //Me guardo el valor inicial 
            dynamic loDefault = loPropiedades.GetValue(toControl, null);
            //Creo un nuevo valor
            dynamic loNuevo = loPropiedades.__Get_Random_Value();
            
            //Me aseguro de que sea distinto
            while (Equals(loDefault, loNuevo))
            {
                loNuevo = loPropiedades.__Get_Random_Value();
            }
            
            //Asigno el nuevo valor
            try
            {
                loPropiedades.SetValue(toControl, loNuevo, null);
                Assert.Fail("No se ha disparado excepción al hacer un SET => Existe dicho método para la propiedad");
            }
            catch (ArgumentException loException)
            {
                //Se ha de producir EXACTAMENTE esta excepción
                Assert.AreEqual("No se puede encontrar el método Set de la propiedad.", loException.Message);
            }
            catch (Exception loException)
            {
                Assert.Fail(string.Format("Excepción inesperada del tipo {0} mensage: {1}", loException.GetType(), loException.Message));
            }

            //dynamic loActual = (dynamic)loPropiedades.GetValue(toControl, null);

            //Assert.AreNotEqual<dynamic>(loActual, loNuevo, "La propiedad " + tcNombrePropiedad + " admite hacer un SET del valor");
        }

        public static void __Test_GetSetValue(this Control toControl, string tcNombrePropiedad, object toTestValue = null)
        {
            //Recupero la propiedad
            System.Reflection.PropertyInfo loPropiedad = toControl.GetType().GetProperty(tcNombrePropiedad);

            //Miro si he recibido un valor para realizar el test
            if (toTestValue == null)
            {
                //Me guardo el valor inicial 
                object loDefault = loPropiedad.GetValue(toControl, null);
                //Creo un nuevo valor
                object loNuevo = loPropiedad.__Get_Random_Value();

                //Me aseguro de que sea distinto
                while (Equals(loDefault, loNuevo))
                {
                    loNuevo = loPropiedad.__Get_Random_Value();
                }

                //Asigno el nuevo valor
                loPropiedad.SetValue(toControl, loNuevo, null);

                //Recupero el valor actual
                dynamic loActual = loPropiedad.GetValue(toControl, null);
                Assert.IsFalse(Equals(loDefault, loActual), "El valor actual es igual al inicial. Revisar que no haya restricciones al hacer un SET de la propiedad." + Environment.NewLine +
                    "De ser así utiliza el parámetro opcional para suministrar un valor que cumpla las restricciones.");

                //El valor actual ha de ser igual al nuevo
                Assert.AreEqual<dynamic>(loActual, loNuevo, "La propiedad " + tcNombrePropiedad + " no realiza correctamente operaciones de GET y SET");

                //Si la propiedad es de tipo texto la longitud ha de ser igual
                if (loPropiedad.PropertyType.FullName == "System.String")
                    Assert.AreEqual<int>(((string)loActual).Length, ((string)loNuevo).Length, "La longitud no concuerda.");
            }
            else //Utilizo el valor recibido
            {
                //Asigno el valor recibido
                loPropiedad.SetValue(toControl, toTestValue, null);
                //Recupero el valor actual
                dynamic loActual = loPropiedad.GetValue(toControl, null);

                //El valor actual ha de ser igual al nuevo
                Assert.AreEqual<dynamic>(loActual, toTestValue, "La propiedad " + tcNombrePropiedad + " no realiza correctamente operaciones de GET y SET");
            }


        }

        public static void __Test_NumericUpDownBasics(this Control toControl)
        {
            //Testeo clase base
            bool llOk = (toControl is sage.ew.objetos.ewnumericupdown);
            Assert.AreEqual<bool>(true, llOk, "La clase del objeto no es ewNumericUpDown.");

            //Testeo propiedades minimas.
            Assert.AreEqual<bool>(false, ((sage.ew.objetos.ewnumericupdown)toControl).ThousandsSeparator, "Separador de miles activado.");
            Assert.AreEqual(System.Windows.Forms.HorizontalAlignment.Right, ((sage.ew.objetos.ewnumericupdown)toControl).TextAlign, "Alineamiento de texto incorrecto.");
        }

        private static object __Get_Random_Value(this System.Reflection.PropertyInfo toPropiedad)
        {
            Random loRandom;

            switch (toPropiedad.PropertyType.FullName)
            {
                case "System.String":
                case "System.Guid":
                    return Guid.NewGuid().ToString();
                case "System.Int32":
                    loRandom = new Random();
                    return loRandom.Next();
                case "System.Char":
                    loRandom = new Random();
                    int lnNum = loRandom.Next(0, 26); // de Zero a 25
                    return (char)('a' + lnNum);
                case "System.Boolean":
                    loRandom = new Random();
                    return loRandom.Next(0, 2) == 0;
                case "System.Decimal":
                    loRandom = new Random();
                    int lnPrecision = loRandom.Next(1,28);
                    int lnEscala = loRandom.Next(0, lnPrecision);
                    decimal lnDecimal = 0M;

                    for (int lnIndPres = 0; lnIndPres < lnPrecision; lnIndPres++)
                    {
                        int lnDigito = loRandom.Next(0, 10);
                        lnDecimal = lnDecimal * 10M + lnDigito;
                    }
                    for (int lnIndEsc = 0; lnIndEsc < lnEscala; lnIndEsc++)
                    {
                        lnDecimal /= 10M;
                    }
                    return lnDecimal;

                default:
                    //Pruebo de buscar el tipo
                    Type elementType = _GetType(toPropiedad.PropertyType.FullName);
                        if (elementType != null)
                        {
                            //Creem una instancia del objecte
                            return Activator.CreateInstance(elementType);
                        }
                    break;
            }
            return null;
        }

        private static Type _GetType(string typeName, bool tlBuscarControles = false)
        {
            var type = Type.GetType(typeName);
            if (type != null) return type;

            if (!tlBuscarControles) //Busca clases
            {
                foreach (var a in AppDomain.CurrentDomain.GetAssemblies())
                {
                    type = a.GetType(typeName);
                    if (type != null)
                        return type;
                }
            }
            else
            {
                foreach (var a in AppDomain.CurrentDomain.GetAssemblies())
                {
                    //Busco directamente por si el tipo me viene informado al completo
                    type = a.GetType(typeName);
                    if (type != null) return type;
                    //Especulo a ver si la dll en la que me encuentro tiene el tipo deseado    
                    type = a.GetType(a.GetName().Name + "." + typeName);
                    if (type != null) return type;
                    //Especulo a ver si la dll en la que me encuentro tiene en UserControls el tipo deseado    
                    type = a.GetType(a.GetName().Name + ".UserControls." + typeName);
                    if (type != null) return type;
                    //Especulo a ver si la dll en la que me encuentro tiene en UserControls el tipo deseado    
                    type = a.GetType(a.GetName().Name + ".Clases." + typeName);
                    if (type != null) return type;
                }
            }
            return null;
        }
        public static void InitializeDependencyInjectionMock()
        {
            IRegisterTypes registerTypesSage50 = new RegisterTypesSage50Mock();
            registerTypesSage50.RegisterTypes();
            //DependencyInjector.Instance.RegisterTypes(RegisterType.All);
            EW_GLOBAL.ValorEnClave_VarGlob("wl_sage50", true);
        }
        //public static void InitializeDependencyInjectionAddonsMock()
        //{
        //    IRegisterTypes registerTypesAddons = new RegisterTypesAddonsMock();
        //    registerTypesAddons.RegisterTypes();
        //}
        #region Extensiones para tipo OBJECT

        public static void __Test_GetSetValue(this Object toObjeto, string tcNombrePropiedad, object toTestValue = null)
        {
            //Recupero la propiedad
            System.Reflection.PropertyInfo loPropiedad = toObjeto.GetType().GetProperty(tcNombrePropiedad);

            //Miro si he recibido un valor para realizar el test
            if (toTestValue == null)
            {
                //Me guardo el valor inicial 
                object loDefault = loPropiedad.GetValue(toObjeto, null);
                //Creo un nuevo valor
                object loNuevo = loPropiedad.__Get_Random_Value();

                //Me aseguro de que sea distinto
                while (Equals(loDefault, loNuevo))
                {
                    loNuevo = loPropiedad.__Get_Random_Value();
                }

                //Asigno el nuevo valor
                loPropiedad.SetValue(toObjeto, loNuevo, null);

                //Recupero el valor actual
                dynamic loActual = loPropiedad.GetValue(toObjeto, null);
                Assert.IsFalse(Equals(loDefault, loActual), "El valor actual es igual al inicial. Revisar que no haya restricciones al hacer un SET de la propiedad." + Environment.NewLine +
                    "De ser así utiliza el parámetro opcional para suministrar un valor que cumpla las restricciones.");

                //El valor actual ha de ser igual al nuevo
                if (loPropiedad.PropertyType.FullName == "System.Decimal")
                {
                    //PE-94722 Determino la precisión decimal
                    int lnNumDecimales = BitConverter.GetBytes(decimal.GetBits((decimal)loActual)[3])[2];
                    Assert.AreEqual<dynamic>(loActual, Decimal.Round((decimal)loNuevo, lnNumDecimales), "La propiedad " + tcNombrePropiedad + " no realiza correctamente operaciones de GET y SET");
                }
                else
                    Assert.AreEqual<dynamic>(loActual, loNuevo, "La propiedad " + tcNombrePropiedad + " no realiza correctamente operaciones de GET y SET");


                //Si la propiedad es de tipo texto la longitud ha de ser igual
                if (loPropiedad.PropertyType.FullName == "System.String")
                    Assert.AreEqual<int>(((string)loActual).Length, ((string)loNuevo).Length, "La longitud no concuerda.");
            }
            else //Utilizo el valor recibido
            {
                //Asigno el valor recibido
                loPropiedad.SetValue(toObjeto, toTestValue, null);
                //Recupero el valor actual
                dynamic loActual = loPropiedad.GetValue(toObjeto, null);

                //El valor actual ha de ser igual al nuevo
                Assert.AreEqual<dynamic>(loActual, toTestValue, "La propiedad " + tcNombrePropiedad + " no realiza correctamente operaciones de GET y SET");
            }
        }

        #endregion Extensiones para tipo OBJECT

    }
}