antoine.perederii
/
Banquale
0
7
Fork 0
Code Issues Pull Requests Packages Projects 5 Releases Wiki Activity

Added test and doxygen
continuous-integration/drone/push Build is failing Details

Browse Source
master
Titouan LOUVET 2 years ago
parent 6710bfe2cd
commit 154b22a114
5 changed files with 230 additions and 159 deletions
Show Stats Download Patch File Download Diff File

7
src/Banquale/Banquale/Views/TransactionsPage.xaml.cs
Unescape View File

@ -58,14 +58,7 @@ namespace Banquale.Views
/// </summary> /// </summary>
async void Categ_Clicked(System.Object sender, System.EventArgs e) async void Categ_Clicked(System.Object sender, System.EventArgs e)
{ {
<<<<<<< HEAD
await Shell.Current.Navigation.PushAsync(new CategoryPage()); await Shell.Current.Navigation.PushAsync(new CategoryPage());
=======
Mgr.SelectedAccount.Balance += Mgr.SelectedTransaction.Sum;
Mgr.SelectedAccount.TransactionsList.Remove(Mgr.SelectedTransaction);
await DisplayAlert("Opposition", "La demande d'opposition à été réalisé avec succés", "OK");
await Shell.Current.Navigation.PopAsync();
>>>>>>> 093cffc19bc037cd518567f105548bd33f8fe902
} }
/// <summary> /// <summary>

79
src/Banquale/Model/IPersistenceManager.cs
Unescape View File

@ -1,28 +1,65 @@
/// \file using Xunit;
/// \brief Définition de l'interface IPersistenceManager. using Moq;
/// \author PEREDERII Antoine, LOUVET Titouan
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Model;
namespace Model namespace UnitTest
{
public class PersistenceManagerTests
{ {
/// <summary> [Fact]
/// Interface pour la gestion de la persistance des données. public void DataLoad_ValidData_ReturnsTuple()
/// </summary>
public interface IPersistenceManager
{ {
/// <summary> // Arrange
/// Charge les données depuis une source de persistance. Mock<IPersistenceManager> persistenceManagerMock = new Mock<IPersistenceManager>();
/// </summary> HashSet<Customer> customers = new HashSet<Customer>();
/// <returns>Un tuple contenant le hashSet des clients et le consultant.</returns> Consultant consultant = new Consultant("Cons", "Gérard", "123456");
public (HashSet<Customer>, Consultant) DataLoad(); persistenceManagerMock.Setup(x => x.DataLoad()).Returns((customers, consultant));
/// <summary> // Act
/// Enregistre les données dans une source de persistance. (HashSet<Customer>, Consultant) result = persistenceManagerMock.Object.DataLoad();
/// </summary>
/// <param name="cu">La liste des clients à enregistrer.</param> // Assert
/// <param name="co">Le consultant à enregistrer.</param> Assert.NotNull(result);
void DataSave(HashSet<Customer> cu, Consultant co); Assert.Equal(customers, result.Item1);
Assert.Equal(consultant, result.Item2);
}
[Theory]
[InlineData(typeof(HashSet<Customer>), typeof(Consultant))]
public void DataSave_ValidData_CallsDataSave(Type customerType, Type consultantType)
{
// Arrange
Mock<IPersistenceManager> persistenceManagerMock = new Mock<IPersistenceManager>();
HashSet<Customer> customers = new HashSet<Customer>();
Consultant consultant = new Consultant("Cons", "Gérard", "123456");
// Act
persistenceManagerMock.Object.DataSave(customers, consultant);
// Assert
persistenceManagerMock.Verify(x => x.DataSave(It.IsAny<HashSet<Customer>>(), It.IsAny<Consultant>()), Times.Once);
}
public static TheoryData<HashSet<Customer>, Consultant> TestData =>
new TheoryData<HashSet<Customer>, Consultant>
{
{ new HashSet<Customer>(), new Consultant("Cons", "Gérard", "123456") },
};
[Theory]
[MemberData(nameof(TestData))]
public void DataSave_ValidData_MemberData(HashSet<Customer> customers, Consultant consultant)
{
// Arrange
Mock<IPersistenceManager> persistenceManagerMock = new Mock<IPersistenceManager>();
// Act
persistenceManagerMock.Object.DataSave(customers, consultant);
// Assert
persistenceManagerMock.Verify(x => x.DataSave(customers, consultant), Times.Once);
}
} }
} }

101
src/Banquale/UnitTest/AccountTest.cs
Unescape View File

@ -1,70 +1,63 @@
/// \file using Xunit;
/// \brief Fichier de test pour la classe Account.
/// \author Votre nom
using Model;
using System; using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.Serialization;
namespace UnitTest namespace Model.Tests
{ {
/// <summary> public class AccountTests
/// Classe de test pour la classe Account.
/// </summary>
public class AccountTest
{ {
/// <summary>
/// Méthode principale du test.
/// </summary>
[Fact] [Fact]
public void TestAnAccount() public void Account_Initialization_Test()
{ {
// Création de deux comptes // Initialisation
Account account1 = new Account(1000, "John Doe", "FR123456789"); double initialBalance = 1000.0;
Account account2 = new Account(500, "Jane Smith", "FR987654321"); string accountName = "Gérard";
string accountIBAN = "FR7612345678901234567895003";
// Affichage des informations des comptes
Console.WriteLine("Compte 1:"); // Account
Console.WriteLine($"Nom: {account1.Name}"); Account account = new Account(initialBalance, accountName, accountIBAN);
Console.WriteLine($"IBAN: {account1.IBANHide}");
Console.WriteLine($"Solde: {account1.Balance}"); // Assert
Assert.Equal(initialBalance, account.Balance);
Assert.Equal(accountName, account.Name);
Assert.Equal(accountIBAN, account.IBAN);
}
Console.WriteLine("\nCompte 2:"); [Theory]
Console.WriteLine($"Nom: {account2.Name}"); [InlineData(1000.0, 500.0, true, 500.0)] // Debit transaction
Console.WriteLine($"IBAN: {account2.IBANHide}"); [InlineData(1000.0, 500.0, false, 1500.0)] // Credit transaction
Console.WriteLine($"Solde: {account2.Balance}"); public void Account_DoTransactions_Test(double initialBalance, double transactionAmount, bool isDebit, double expectedBalance)
{
// Initialisation
Account account = new Account(initialBalance, "Gérard", "FR7612345678901234567895003");
Account otherAccount = new Account(0.0, "Gérarde", "FR76987654321098765432109876004");
// Effectuer une transaction entre les comptes // Account
double amount = 200; account.DoTransactions(otherAccount, transactionAmount, isDebit);
Console.WriteLine($"\nEffectuer une transaction de {amount} du compte 1 vers le compte 2...");
account1.DoTransactions(account2, amount, true);
// Affichage des informations des comptes après la transaction // Assert
Console.WriteLine("\nAprès la transaction:"); Assert.Equal(expectedBalance, account.Balance);
Console.WriteLine("Compte 1:"); }
Console.WriteLine($"Nom: {account1.Name}");
Console.WriteLine($"IBAN: {account1.IBANHide}");
Console.WriteLine($"Solde: {account1.Balance}");
Console.WriteLine("\nCompte 2:"); public static TheoryData<double, double, bool, double> TestData =>
Console.WriteLine($"Nom: {account2.Name}"); new TheoryData<double, double, bool, double>
Console.WriteLine($"IBAN: {account2.IBANHide}"); {
Console.WriteLine($"Solde: {account2.Balance}"); { 1000.0, 500.0, true, 500.0 }, // Debit transaction
{ 1000.0, 500.0, false, 1500.0 }, // Credit transaction
};
// Demander de l'aide [Theory]
string helpSubject = "Besoin d'aide"; [MemberData(nameof(TestData))]
string helpDescription = "Je rencontre un problème avec mon compte."; public void Account_DoTransactions_MemberData_Test(double initialBalance, double transactionAmount, bool isDebit, double expectedBalance)
Message helpMessage = Account.AskForHelp(helpSubject, helpDescription); {
Console.WriteLine($"\nDemande d'aide envoyée : {helpMessage}"); // Initialisation
Account account = new Account(initialBalance, "Gérard", "FR7612345678901234567895003");
Account otherAccount = new Account(0.0, "Gérarde", "FR76987654321098765432109876004");
// Comparaison de deux comptes // Account
Console.WriteLine("\nComparaison des comptes..."); account.DoTransactions(otherAccount, transactionAmount, isDebit);
bool areEqual = account1.Equals(account2);
Console.WriteLine($"Les comptes sont-ils égaux ? {areEqual}");
//Console.ReadLine(); // Assert
Assert.Equal(expectedBalance, account.Balance);
} }
} }
} }

62
src/Banquale/UnitTest/ConsultantTest.cs
Unescape View File

@ -1,12 +1,13 @@
using System; /// \file
/// \brief Définition des tests pour la classe Consultant.
/// \author PEREDERII Antoine, LOUVET Titouan
using Xunit;
using System;
using Model; using Model;
namespace UnitTest namespace UnitTest
{ {
/// \file
/// \brief Fichier de tests pour la classe Consultant.
/// \author Votre nom
/// <summary> /// <summary>
/// Classe de tests pour la classe Consultant. /// Classe de tests pour la classe Consultant.
/// </summary> /// </summary>
@ -18,9 +19,9 @@ namespace UnitTest
[Fact] [Fact]
public void Constructor_MessagesListInitialized() public void Constructor_MessagesListInitialized()
{ {
// Arrange // Initialisation
string name = "Doe"; string name = "Cons";
string firstName = "John"; string firstName = "Gérard";
string password = "123456"; string password = "123456";
// Act // Act
@ -30,5 +31,50 @@ namespace UnitTest
Assert.NotNull(consultant.MessagesList); Assert.NotNull(consultant.MessagesList);
Assert.Empty(consultant.MessagesList); Assert.Empty(consultant.MessagesList);
} }
/// <summary>
/// Teste si la liste des messages du consultant est initialisée correctement en utilisant InlineData.
/// </summary>
/// <param name="name">Nom du consultant.</param>
/// <param name="firstName">Prénom du consultant.</param>
/// <param name="password">Mot de passe du consultant.</param>
[Theory]
[InlineData("Cons", "Gérard", "123456")]
public void Constructor_MessagesListInitialized_InlineData(string name, string firstName, string password)
{
// Act
Consultant consultant = new Consultant(name, firstName, password);
// Assert
Assert.NotNull(consultant.MessagesList);
Assert.Empty(consultant.MessagesList);
}
/// <summary>
/// Fournit les données pour le test de l'initialisation de la liste des messages du consultant.
/// </summary>
public static TheoryData<string, string, string> TestData =>
new TheoryData<string, string, string>
{
{ "Cons", "Gérard", "123456" },
};
/// <summary>
/// Teste si la liste des messages du consultant est initialisée correctement en utilisant MemberData.
/// </summary>
/// <param name="name">Nom du consultant.</param>
/// <param name="firstName">Prénom du consultant.</param>
/// <param name="password">Mot de passe du consultant.</param>
[Theory]
[MemberData(nameof(TestData))]
public void Constructor_MessagesListInitialized_MemberData(string name, string firstName, string password)
{
// Act
Consultant consultant = new Consultant(name, firstName, password);
// Assert
Assert.NotNull(consultant.MessagesList);
Assert.Empty(consultant.MessagesList);
}
} }
} }

140
src/Banquale/UnitTest/CustomerTest.cs
Unescape View File

@ -1,78 +1,80 @@
//using System; /// \file
//using Model; /// \brief Définition des tests pour la classe Customer.
/// \author PEREDERII Antoine, LOUVET Titouan
//namespace UnitTest using Xunit;
//{ using System;
// /// \file using Model;
// /// \brief Fichier de tests pour la classe Customer.
// /// \author Votre nom
// /// <summary> namespace UnitTest
// /// Classe de tests pour la classe Customer. {
// /// </summary> /// <summary>
// public class CustomerTests /// Classe de tests pour la classe Customer.
// { /// </summary>
// /// <summary> public class CustomerTests
// /// Teste si la liste des comptes du client est initialisée correctement. {
// /// </summary> /// <summary>
// [Fact] /// Teste si la liste des comptes du client est initialisée correctement.
// public void Constructor_AccountsListInitialized() /// </summary>
// { [Fact]
// // Arrange public void Constructor_AccountsListInitialized()
// string name = "Doe"; {
// string firstName = "John"; // Initialisation
// string password = "123456"; string name = "Cust";
string firstName = "Gérard";
string password = "123456";
// // Act // Act
// Customer customer = new Customer(name, firstName, password); Customer customer = new Customer(name, firstName, password);
// // Assert // Assert
// Assert.NotNull(customer.AccountsList); Assert.NotNull(customer.AccountsList);
// Assert.Empty(customer.AccountsList); Assert.Empty(customer.AccountsList);
// } }
// /// <summary> /// <summary>
// /// Teste l'égalité entre deux clients. /// Teste si la liste des comptes du client est initialisée correctement en utilisant InlineData.
// /// </summary> /// </summary>
// [Fact] /// <param name="name">Nom du client.</param>
// public void Equals_TwoEqualCustomers_ReturnsTrue() /// <param name="firstName">Prénom du client.</param>
// { /// <param name="password">Mot de passe du client.</param>
// // Arrange [Theory]
// string name1 = "Doe"; [InlineData("Cust", "Gérard", "123456")]
// string firstName1 = "John"; public void Constructor_AccountsListInitialized_InlineData(string name, string firstName, string password)
// string password1 = "123456"; {
// string name2 = "Doe"; // Act
// string firstName2 = "John"; Customer customer = new Customer(name, firstName, password);
// string password2 = "123456";
// // Act // Assert
// Customer customer1 = new Customer(name1, firstName1, password1); Assert.NotNull(customer.AccountsList);
// Customer customer2 = new Customer(name2, firstName2, password2); Assert.Empty(customer.AccountsList);
}
// // Assert /// <summary>
// Assert.True(customer1.Equals(customer2)); /// Fournit les données pour le test de l'initialisation de la liste des comptes du client.
// } /// </summary>
public static TheoryData<string, string, string> TestData =>
new TheoryData<string, string, string>
{
{ "Cust", "Gérard", "123456" },
};
// /// <summary> /// <summary>
// /// Teste l'égalité entre deux clients avec des identifiants différents. /// Teste si la liste des comptes du client est initialisée correctement en utilisant MemberData.
// /// </summary> /// </summary>
// [Fact] /// <param name="name">Nom du client.</param>
// public void Equals_TwoDifferentCustomers_ReturnsFalse() /// <param name="firstName">Prénom du client.</param>
// { /// <param name="password">Mot de passe du client.</param>
// // Arrange [Theory]
// string name1 = "Doe"; [MemberData(nameof(TestData))]
// string firstName1 = "John"; public void Constructor_AccountsListInitialized_MemberData(string name, string firstName, string password)
// string password1 = "123456"; {
// string name2 = "Smith"; // Act
// string firstName2 = "Jane"; Customer customer = new Customer(name, firstName, password);
// string password2 = "abcdef";
// // Act // Assert
// Customer customer1 = new Customer(name1, firstName1, password1); Assert.NotNull(customer.AccountsList);
// Customer customer2 = new Customer(name2, firstName2, password2); Assert.Empty(customer.AccountsList);
}
// // Assert }
// Assert.False(customer1.Equals(customer2)); }
// }
// }
//}

Write Preview
Loading…
Cancel
Save