public void SubstituerVariableFichier(String FichierModele, String FichierResultat, String FichierDeVariables)
{
JCAVariable mesVariables = new JCAVariable();
String monContenu;
mesVariables.LireFichier(FichierDeVariables);
monContenu = System.IO.File.ReadAllText(FichierModele );
monContenu = JCAVariable.SubstituerVariables(monContenu, mesVariables.Variables );
System.IO.File.WriteAllText(FichierResultat, monContenu);
}
public void ExtrairePaireTest()
{
JCAVariable maVariable = new JCAVariable();
String Valeur;
String Cle;
Cle = maVariable.ExtrairePaire("Test=Valeur",out Valeur );
Assert.AreEqual("Test", Cle);
Assert.AreEqual("Valeur", Valeur );
}
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;
}
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 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<3>"));
Assert.IsTrue(Contenu.Contains("Valeur" de la variable Test3"));
Assert.IsTrue(Contenu.Contains("Test"1""));
Assert.IsTrue(Contenu.Contains("Valeur de <la> 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 );
}
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);
}
// l'appel aux constructeurs complexes a été mis
// ici pour pouvoir faire un try catch
// Boolean Debug = true;
public void InitJCAssertion()
{
if (! Init)
{
try {
Utilitaire = new JCAUtilitaires();
Init = true ;
mesArguments = new JCAssertionCore.JCAVariable();
maConsole = new JCAssertionCore.JCAConsole();
monJCACore = new JCACore();
}
catch (Exception excep)
{
ExceptionGlobale = excep ;
ExceptionRencontree = true;
CodeDeRetour = 99;
throw excep;
}
} // ! init
}
// Methode utilisé par le load et qui peutêtreunittestée
public int Execute()
{
InitJCAssertion();
NombreCas = 0;
NombreEchec = 0;
NombreReussi = 0;
Message = "Démarrage";
if ((args.Length == 0) && (! UnitTest ) ) Interactif = true;
mesArguments = maConsole.Arguments(args);
if ((mesArguments.GetValeurVariable("AV") != null) &&
(mesArguments.GetValeurVariable("AV") != ""))
{
Avertir = true;
}
if ((mesArguments.GetValeurVariable("I") != null) &&
(mesArguments.GetValeurVariable("I") != ""))
{
Interactif = true;
}
if (!JCAUtilitaires.EVSourceExiste())
Informer(Environment.NewLine +
"Avertissement : La source de journal d'événement 'JCAssertion' " +
"doit être définie pour avoir accès à "+
"tous les messages d'erreurs. Consultez www.jcassertion.org Configuration requise " +
"^pour plus de détails.");
// l'argument d0 provoque une exceptions
if ((mesArguments.GetValeurVariable("D0") != null) &&
(mesArguments.GetValeurVariable("D0") != ""))
{
throw new Exception(
"Exception déclenchée volontairement par l'argument /D0 ");
}
// Vérifier qu'au moins le nom de fichier d'assertion est fourni
if ((mesArguments.GetValeurVariable("FA") == null) ||
(mesArguments.GetValeurVariable("FA") == ""))
{
Informer("Ce programme doit recevoir des arguments enligne de commande." + Usage, true) ;
return 99;
}
// Valider un peu les arguments
String FichierAssertion = mesArguments.GetValeurVariable("FA");
String FichierVariable = "";
if ((mesArguments.GetValeurVariable("FV") != null) &&
(mesArguments.GetValeurVariable("FV") != ""))
FichierVariable = mesArguments.GetValeurVariable("FV");
if (!System.IO.File.Exists(FichierAssertion))
{
Informer( "Le fichier d'assertion . " +
FichierAssertion + " n'existe pas." , true );
return 99;
}
if((FichierVariable != "" ) &&
(! System.IO.File.Exists (FichierVariable)))
{
Informer ("Le fichier de variables . " +
FichierVariable + " n'existe pas.", true );
return 99;
}
if ((mesArguments.GetValeurVariable("J") != null) &&
(mesArguments.GetValeurVariable("J") != ""))
// Désactiver la journalisation du core
// Le^programme va faire un journal plus complet
monJCACore.Journaliser = false ;
JournalActivite = mesArguments.GetValeurVariable("J");
if (System.IO.File.Exists(JournalActivite))
System.IO.File.Delete(JournalActivite);
//
// commencer le traitementproprement dit
NAJtbxFAssertion(FichierAssertion);
MAJtbxFVariables(FichierVariable) ;
Informer("Lecture du fichier d'assertion : "
+ FichierAssertion );
monJCACore.Load(FichierAssertion );
NombreCas = monJCACore.NombreCas;
Informer("Nombre de cas à traiter : " + monJCACore.NombreCas.ToString () );
if(FichierVariable != "")
{
Informer ("Lecture du fichier de variables : "
+ FichierVariable);
monJCACore.Variables.LireFichier(FichierVariable );
}
int i = 1;
foreach (XmlNode monCas in monJCACore.getListeDeCas())
{
if (AnnulerExecution) break;
Informer ("Exécution du cas " + i.ToString() );
if (monJCACore.ExecuteCas(monCas))
{
NombreReussi = NombreReussi + 1;
Informer ("Assertion vraie") ;
Informer (monJCACore.Message);
}
else
{
MessageEchec = monJCACore.MessageEchec ;
Informer ("Assertion fausse");
Informer (monJCACore.Message);
Informer("Détail de l'échec de l'assertion" +
Environment.NewLine +
"----");
Informer(MessageEchec,Avertir );
Informer("-----" +
Environment.NewLine +
"Fin du détail de l'échec de l'assertion");
NombreEchec = NombreEchec + 1;
}
i = i++;
}
Informer("Fin de l'exécution");
Informer("Cas réussis : " + NombreReussi.ToString() + " sur " + NombreCas.ToString() );
Informer("Cas en échec : " + NombreEchec.ToString() + " sur " + NombreCas.ToString());
if(NombreEchec > 0)
return 1;
else
return 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 ;
}
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");
}