public void EcrireEtLire()
        {
            JCAVariable mesVariablesAvant = new JCAVariable();
            JCAVariable mesVariablesApres = new JCAVariable();
            String NomFichier = JCACore.RepertoireAssembly() + "Ressources\\EcrireEtLire.xml";

            // tester l'état de l'environnement de test
            if (File.Exists(NomFichier)) File.Delete(NomFichier);
            Assert.IsFalse (File.Exists (NomFichier),"Le fichier de sérialisation devrait ne pas exister");

            // remplir les avariables avant ecriture
            mesVariablesAvant.MAJVariable("Test<3>", "Valeur\" de la variable Test3");
            mesVariablesAvant.MAJVariable("Test\"1\"", "Valeur de <la> variable Test1");
            mesVariablesAvant.MAJVariable("AATest2", "Valeur de la variable Test2");
            mesVariablesAvant.MAJVariable("JCA.FichierDeVariables", NomFichier);

            mesVariablesAvant.EcrireFichier(NomFichier);

            String Contenu = System.IO.File.ReadAllText(NomFichier);
            Assert.IsTrue(Contenu.Contains("Test&lt;3&gt;"));
            Assert.IsTrue(Contenu.Contains("Valeur&quot; de la variable Test3"));
            Assert.IsTrue(Contenu.Contains("Test&quot;1&quot;"));
            Assert.IsTrue(Contenu.Contains("Valeur de &lt;la&gt; variable Test1"));
            Assert.IsTrue(Contenu.Contains("AATest2"));
            Assert.IsTrue(Contenu.Contains("Valeur de la variable Test2"));

            // Créer du contenu qui sera remplacé dans la variable apr
            mesVariablesApres.MAJVariable("errone","Cette valeur devrait disparaitre");
            String Detail;
            Boolean TestComplexe = mesVariablesAvant.EstEgal (mesVariablesApres.Variables  , out Detail  );

            Assert.IsFalse(TestComplexe, "Avant de commencer le test lesvariablesdevraient être différentes");

            mesVariablesApres.LireFichier(NomFichier );

            TestComplexe = mesVariablesAvant.EstEgal(mesVariablesApres.Variables, out Detail);

            Assert.IsTrue(TestComplexe, "Aprè le test les deux objets de variable devraient être pareils : " + Detail );
        }
示例#2
0
        public int ExecuteExporte(string[] args, out String Message)
        {
            JCAVariable mesArgs = new JCAssertionCore.JCAVariable();
            JCAVariable mesVariables = new JCAssertionCore.JCAVariable();
            JCAConsole maConsole = new JCAssertionCore.JCAConsole ();
            String Usage = "usage :" + Environment.NewLine + Environment.NewLine + "JCAExporte /F:fichier /V1:cle=valeur /v2=cle2=valeur2 ...";
            String Cle;
            String Valeur;

            Message = "";

            if (args.Count() < 2)
            {
                Message = "Pas assez d'arguments. " + Environment.NewLine + Usage ;
                return 99;
            }

            mesArgs = maConsole.Arguments(args);

            if ((mesArgs.GetValeurVariable("F") == null) || (mesArgs.GetValeurVariable("F") == ""))
                {
                    Message = "L'argument /F (Chemin du fichier de sortie n'a pas été spécfié.)" + Environment.NewLine + Usage;
                    return 99;
                }

            // Traitemen OK
            String NomFichier = mesArgs.GetValeurVariable("F");
            if (System.IO.File.Exists (NomFichier)) mesVariables.LireFichier(NomFichier );
            // Ajouter ou maj les variables

            foreach (var monParem in mesArgs.Variables )
                {

                    if ((monParem.Key.Length > 0 ) && (monParem.Key.Substring(0,1).ToUpper()   == "V"))
                    {
                        Cle = mesArgs.ExtrairePaire(monParem.Value, out  Valeur);
                        mesVariables.MAJVariable (Cle ,Valeur );

                    }
                }

            // metre les variables par défaut
            mesVariables.MAJVariable(JCAVariable.Constantes.JCA_FichierDeVariables   ,
                NomFichier);

            //Sauvegarder
            mesVariables.EcrireFichier(NomFichier);
            Message = Environment.NewLine +  "Fichier : " + NomFichier + " mis à jour.";

            return 0;
        }
示例#3
0
        public JCAVariable Arguments(string[] args)
        {
            String Cle;
            String Valeur;
            JCAVariable Resultat = new JCAVariable();

            foreach  (String  Param in args  )
                {
                    if ((Param != null ) && (Param != "")  )
                        {
                            if(ExtraireParam(Param ,out Cle, out Valeur ))
                                Resultat.MAJVariable (Cle,Valeur );
                        }
                }
            return Resultat;
        }
        public void MAJVariablesOKTest()
        {
            String NomFichier = Chemin +
                "MAJVariablesOKTest.xml";

            // Préparer les variables de test
            JCAVariable mesVariables = new JCAVariable();
            mesVariables.MAJVariable("s","Suffixe");
            mesVariables.MAJVariable("p", "Préfixe");
            mesVariables.MAJVariable("Autre", "Autres");
            mesVariables.MAJVariable("R", "Résultat");

            Assert.IsTrue(mesVariables.GetValeurVariable(
                JCAVariable.Constantes.JCA_FichierDeVariables)
                == null,
                "La variable JCA.FichierDeVariables ne devrait pas exister.");

            // Défnir le noued xml qui contient le test
            JCACore monCore = new JCACore();
            monCore.Variables = mesVariables;

            XmlDocument monCas = new XmlDocument ();

            monCas.InnerXml = "<Assertion><Type>MAJVariables</Type>" +
                "<Cle>{{R}}</Cle>" +
                "<Valeur>{{p}}te{{Autre}}st{{s}}</Valeur>" +
                "</Assertion>";

            // Un cas qui marche sans fichier

            Assert.IsTrue(monCore.ExecuteCas(monCas),
                "L'éxécution du cas a échoué : " +
                monCore.Message + Environment.NewLine +
                monCore.MessageEchec );
            Assert.IsTrue(monCore.Variables.GetValeurVariable("Résultat").Contains("PréfixeteAutresstSuffixe"),
                "Variable Résultat avec le mauvais contenu : " +
                 monCore.Variables.GetValeurVariable("Résultat"));

            // Un cas qui marche avec fichier
            monCore.Variables = mesVariables;
            monCore.Variables.MAJVariable(
               JCAVariable.Constantes.JCA_FichierDeVariables, NomFichier );
            if (System.IO.File.Exists(NomFichier))
                System.IO.File.Delete(NomFichier );
            Assert.IsFalse(System.IO.File.Exists(NomFichier),
                "Le fichier ne devrait pas exister");
            Assert.IsTrue(monCore.ExecuteCas(monCas),
                "L'éxécution du cas a échoué : " +
                monCore.Message + Environment.NewLine +
                monCore.MessageEchec);
            Assert.IsTrue(monCore.Variables.GetValeurVariable("Résultat").Contains("PréfixeteAutresstSuffixe"),
                "Variable Résultat avec le mauvais contenu : " +
                 monCore.Variables.GetValeurVariable("Résultat"));
            Assert.IsTrue(System.IO.File.Exists(NomFichier),
                "Le fichierdevrait exister : " + NomFichier );

            String ResultatFichier = System.IO.File.ReadAllText(NomFichier );
            Assert.IsTrue(ResultatFichier.Contains("PréfixeteAutresstSuffixe"),
                "Variable Résultat dans le fichier " +
                NomFichier  +" avec le mauvais contenu : " +
                 ResultatFichier);
        }
示例#5
0
        public static bool JCAMAJVariables(XmlNode monXMLNode,
            ref string Message, 
            ref  Dictionary<String, String> Variables,
            ref String MessageEchec)
        {
            Message = Message + Environment.NewLine +
                "Assertion MAJVariables" + Environment.NewLine  ;
            if (monXMLNode == null) throw new JCAssertionException("Le XML est vide.");
            ValideBalise(monXMLNode, "Cle");
            string MaCle = ValeurBalise (monXMLNode,"Cle");
            MaCle = JCAVariable.SubstituerVariables(MaCle, Variables);
            Message = Message + "Clé:" + MaCle + Environment.NewLine  ;
            ValideBalise(monXMLNode, "Valeur");

            string MaValeur = ValeurBalise (monXMLNode,"Valeur");
            MaValeur = JCAVariable.SubstituerVariables(MaValeur, Variables);
            Message = Message + "Valeur:" + MaValeur + Environment.NewLine;

            JCAVariable VariableTemp = new JCAVariable() ;
            VariableTemp.Variables  = Variables;
            VariableTemp.MAJVariable (MaCle, MaValeur  );
            Variables = VariableTemp.Variables;
            if(VariableTemp.GetValeurVariable(
                JCAVariable.Constantes.JCA_FichierDeVariables) != null )
                {
                    VariableTemp.EcrireFichier (VariableTemp.GetValeurVariable(
                        JCAVariable.Constantes.JCA_FichierDeVariables));

                }

            Message = Message + Environment.NewLine +
                    "Valeur de variable mise à jour.";
            MessageEchec = "";

            return true ;
        }
示例#6
0
        public void SubstituerVariablesFichier()
        {
            JCACore monCore = new JCACore();
            XmlDocument monCas = new XmlDocument();

            monCas.InnerXml = "<Assertion><Type>SubstituerVariablesFichier</Type>" +
                "<FichierModele>{{Chemin}}SQLexec.txt</FichierModele>" +
                "<FichierSortie>{{Chemin}}SQLexec.txt.sql</FichierSortie>" +
                "<FichierVariables>{{Chemin}}SQLexec.var.xml</FichierVariables>" +
                "</Assertion>";
            Assert.IsFalse(monCore.ExecuteCas(monCas));
            Assert.IsTrue(monCore.Message.Contains("La variable Chemin n'a pas eu de valeur fournie"),
                "Attendu:La variable Chemin n'a pas eu de valeur fournie. Réel :" + monCore.Message  );

            // cas qui marche
            String Modele = Chemin + "SQLexec.txt";
            System.IO.File.WriteAllText(Modele, "spool {{SpoolFile}}" +
                Environment.NewLine + "select '{{Logon}}' from dual;" +
                Environment.NewLine  );

            // Créer le fichier de variables SQLexec.var.xml
            JCAVariable sqlvar = new JCAVariable();
            sqlvar.MAJVariable("Logon","jean-claude");
            sqlvar.MAJVariable("SpoolFile","z:log.txt");
            sqlvar.EcrireFichier(Chemin + "SQLexec.var.xml");

            monCore.Variables.MAJVariable("Chemin", Chemin );
            Assert.IsTrue(monCore.ExecuteCas(monCas));
            Assert.IsTrue(monCore.Message.Contains("La substitution des variables dans le fichier a réussie"), "Attendu:La substitution des variables dans le fichier a réussie");
            //todo verif fichier sql
            String Contenu = System.IO.File.ReadAllText(Chemin + "SQLexec.txt.sql");
            Assert.IsTrue(Contenu.Contains("spool z:log.txt"), "Attendu:spool z:log.txt");
            Assert.IsTrue(Contenu.Contains("select 'jean-claude' from dual;"), "Attendu:select 'jean-claude' from dual;");

            // TODO unitester les autres validations
        }
        public void ClientOK()
        {
            // Préparer les variables de test
            JCAVariable mesVariables = new JCAVariable();
            mesVariables.MAJVariable("monUser","JCA");
            mesVariables.MAJVariable("monPassword", "JCA");
            mesVariables.MAJVariable("monServeur", "localhost");
            mesVariables.MAJVariable("O", "Ouvrir");
            mesVariables.MAJVariable("F", "Fermer");

            JCACore monCore = new JCACore();
            monCore.Variables = mesVariables;

            // un cas sans action mais avec les 3 param`tres
            XmlDocument monCas = new XmlDocument();

            monCas.InnerXml = "<Assertion><Type>ConnectionOracle</Type>" +
                "<User>{{monUser}}</User>" +
                "<Password>{{monPassword}}</Password>" +
                "<Serveur>{{monServeur}}</Serveur>" +
                "</Assertion>";

            Assert.IsFalse(monCore.ODPSQLConnectionOuverte(),
                "Avant de commencer la connection devrait être fermée");
            Assert.IsTrue(monCore.ExecuteCas(monCas),
                "L'éxécution du cas a échoué : " +
                monCore.Message + Environment.NewLine +
                monCore.MessageEchec);
            Assert.IsFalse(monCore.ODPSQLConnectionOuverte(),
                "Sans code d'action  la connection devrait être fermée");

            // test d'action Ouvrir
            Assert.IsFalse(monCore.ODPSQLConnectionOuverte(),
                "Avant de commencer la connection devrait être fermée");

            monCas.InnerXml = "<Assertion><Type>ConnectionOracle</Type>" +
                "<User>{{monUser}}</User>" +
                "<Password>{{monPassword}}</Password>" +
                "<Serveur>{{monServeur}}</Serveur>" +
                "<Action>{{O}}</Action>" +
                "</Assertion>";

            Assert.IsTrue(monCore.ExecuteCas(monCas),
                "L'éxécution du cas action ouvrir a échoué : " +
                monCore.Message + Environment.NewLine +
                monCore.MessageEchec);
            Assert.IsTrue(monCore.ODPSQLConnectionOuverte(),
                "L'action  aurait du ouvrir la connection");

            // Test d'action fermer
            Assert.IsTrue(monCore.ODPSQLConnectionOuverte(),
                "La connection devrait être ouverte");
            monCas.InnerXml = "<Assertion><Type>ConnectionOracle</Type>" +
                "<User>{{monUser}}</User>" +
                "<Password>{{monPassword}}</Password>" +
                "<Serveur>{{monServeur}}</Serveur>" +
                "<Action>{{F}}</Action>" +
                "</Assertion>";
            Assert.IsTrue(monCore.ExecuteCas(monCas),
                "L'éxécution du cas action fermer a échoué : " +
                monCore.Message + Environment.NewLine +
                monCore.MessageEchec);

            Assert.IsFalse(monCore.ODPSQLConnectionOuverte(),
                "L'action aurait du fermer la connection");
        }