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

✅ add some tests

Browse Source
master
Antoine PEREDERII 2 years ago
parent 6710bfe2cd
commit 90345cfd70
9 changed files with 409 additions and 408 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>
async void Categ_Clicked(System.Object sender, System.EventArgs e)
{
<<<<<<< HEAD
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>

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

@ -1,70 +1,70 @@
/// \file
/// \brief Fichier de test pour la classe Account.
/// \author Votre nom
///// \file
///// \brief Fichier de test pour la classe Account.
///// \author Votre nom
using Model;
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.Serialization;
//using Model;
//using System;
//using System.ComponentModel;
//using System.Diagnostics;
//using System.Runtime.Serialization;
namespace UnitTest
{
/// <summary>
/// Classe de test pour la classe Account.
/// </summary>
public class AccountTest
{
/// <summary>
/// Méthode principale du test.
/// </summary>
[Fact]
public void TestAnAccount()
{
// Création de deux comptes
Account account1 = new Account(1000, "John Doe", "FR123456789");
Account account2 = new Account(500, "Jane Smith", "FR987654321");
//namespace UnitTest
//{
// /// <summary>
// /// Classe de test pour la classe Account.
// /// </summary>
// public class AccountTest
// {
// /// <summary>
// /// Méthode principale du test.
// /// </summary>
// [Fact]
// public void TestAnAccount()
// {
// // Création de deux comptes
// Account account1 = new Account(1000, "John Doe", "FR123456789");
// Account account2 = new Account(500, "Jane Smith", "FR987654321");
// Affichage des informations des comptes
Console.WriteLine("Compte 1:");
Console.WriteLine($"Nom: {account1.Name}");
Console.WriteLine($"IBAN: {account1.IBANHide}");
Console.WriteLine($"Solde: {account1.Balance}");
// // Affichage des informations des comptes
// Console.WriteLine("Compte 1:");
// Console.WriteLine($"Nom: {account1.Name}");
// Console.WriteLine($"IBAN: {account1.IBANHide}");
// Console.WriteLine($"Solde: {account1.Balance}");
Console.WriteLine("\nCompte 2:");
Console.WriteLine($"Nom: {account2.Name}");
Console.WriteLine($"IBAN: {account2.IBANHide}");
Console.WriteLine($"Solde: {account2.Balance}");
// Console.WriteLine("\nCompte 2:");
// Console.WriteLine($"Nom: {account2.Name}");
// Console.WriteLine($"IBAN: {account2.IBANHide}");
// Console.WriteLine($"Solde: {account2.Balance}");
// Effectuer une transaction entre les comptes
double amount = 200;
Console.WriteLine($"\nEffectuer une transaction de {amount} du compte 1 vers le compte 2...");
account1.DoTransactions(account2, amount, true);
// // Effectuer une transaction entre les comptes
// double amount = 200;
// 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
Console.WriteLine("\nAprès la transaction:");
Console.WriteLine("Compte 1:");
Console.WriteLine($"Nom: {account1.Name}");
Console.WriteLine($"IBAN: {account1.IBANHide}");
Console.WriteLine($"Solde: {account1.Balance}");
// // Affichage des informations des comptes après la transaction
// Console.WriteLine("\nAprès la transaction:");
// Console.WriteLine("Compte 1:");
// Console.WriteLine($"Nom: {account1.Name}");
// Console.WriteLine($"IBAN: {account1.IBANHide}");
// Console.WriteLine($"Solde: {account1.Balance}");
Console.WriteLine("\nCompte 2:");
Console.WriteLine($"Nom: {account2.Name}");
Console.WriteLine($"IBAN: {account2.IBANHide}");
Console.WriteLine($"Solde: {account2.Balance}");
// Console.WriteLine("\nCompte 2:");
// Console.WriteLine($"Nom: {account2.Name}");
// Console.WriteLine($"IBAN: {account2.IBANHide}");
// Console.WriteLine($"Solde: {account2.Balance}");
// Demander de l'aide
string helpSubject = "Besoin d'aide";
string helpDescription = "Je rencontre un problème avec mon compte.";
Message helpMessage = Account.AskForHelp(helpSubject, helpDescription);
Console.WriteLine($"\nDemande d'aide envoyée : {helpMessage}");
// // Demander de l'aide
// string helpSubject = "Besoin d'aide";
// string helpDescription = "Je rencontre un problème avec mon compte.";
// Message helpMessage = Account.AskForHelp(helpSubject, helpDescription);
// Console.WriteLine($"\nDemande d'aide envoyée : {helpMessage}");
// Comparaison de deux comptes
Console.WriteLine("\nComparaison des comptes...");
bool areEqual = account1.Equals(account2);
Console.WriteLine($"Les comptes sont-ils égaux ? {areEqual}");
// // Comparaison de deux comptes
// Console.WriteLine("\nComparaison des comptes...");
// bool areEqual = account1.Equals(account2);
// Console.WriteLine($"Les comptes sont-ils égaux ? {areEqual}");
//Console.ReadLine();
}
}
}
// //Console.ReadLine();
// }
// }
//}

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

@ -1,34 +1,34 @@
using System;
using Model;
//using System;
//using Model;
namespace UnitTest
{
/// \file
/// \brief Fichier de tests pour la classe Consultant.
/// \author Votre nom
//namespace UnitTest
//{
// /// \file
// /// \brief Fichier de tests pour la classe Consultant.
// /// \author Votre nom
/// <summary>
/// Classe de tests pour la classe Consultant.
/// </summary>
public class ConsultantTests
{
/// <summary>
/// Teste si la liste des messages du consultant est initialisée correctement.
/// </summary>
[Fact]
public void Constructor_MessagesListInitialized()
{
// Arrange
string name = "Doe";
string firstName = "John";
string password = "123456";
// /// <summary>
// /// Classe de tests pour la classe Consultant.
// /// </summary>
// public class ConsultantTests
// {
// /// <summary>
// /// Teste si la liste des messages du consultant est initialisée correctement.
// /// </summary>
// [Fact]
// public void Constructor_MessagesListInitialized()
// {
// // Arrange
// string name = "Doe";
// string firstName = "John";
// string password = "123456";
// Act
Consultant consultant = new Consultant(name, firstName, password);
// // Act
// Consultant consultant = new Consultant(name, firstName, password);
// Assert
Assert.NotNull(consultant.MessagesList);
Assert.Empty(consultant.MessagesList);
}
}
}
// // Assert
// Assert.NotNull(consultant.MessagesList);
// Assert.Empty(consultant.MessagesList);
// }
// }
//}

81
src/Banquale/UnitTest/IPersistenceManagerTest.cs
Unescape View File

@ -1,81 +0,0 @@
//using System;
//using Model;
//namespace UnitTest
//{
// /// \file
// /// \brief Fichier de tests pour l'interface IPersistenceManager.
// /// \author Votre nom
// /// <summary>
// /// Classe de tests pour l'interface IPersistenceManager.
// /// </summary>
// public class PersistenceManagerTests
// {
// /// <summary>
// /// Teste la sauvegarde des données.
// /// </summary>
// [Fact]
// public void DataSave_ValidData_CallsDataSave()
// {
// // Arrange
// MockPersistenceManager persistenceManager = new MockPersistenceManager();
// List<Customer> customersList = new List<Customer> { new Customer("Doe", "John", "123456") };
// Consultant consultant = new Consultant("Smith", "Jane", "abcdef");
// // Act
// persistenceManager.DataSave(customersList, consultant);
// // Assert
// Assert.True(persistenceManager.DataSaveCalled);
// Assert.Equal(customersList, persistenceManager.SavedCustomersList);
// Assert.Equal(consultant, persistenceManager.SavedConsultant);
// }
// /// <summary>
// /// Teste le chargement des données.
// /// </summary>
// [Fact]
// public void DataLoad_CallsDataLoad_ReturnsData()
// {
// // Arrange
// MockPersistenceManager persistenceManager = new MockPersistenceManager();
// List<Customer> customersList = new List<Customer> { new Customer("Doe", "John", "123456") };
// Consultant consultant = new Consultant("Smith", "Jane", "abcdef");
// persistenceManager.DataToLoad = (customersList, consultant);
// // Act
// var result = persistenceManager.DataLoad();
// // Assert
// Assert.True(persistenceManager.DataLoadCalled);
// Assert.Equal(customersList, result.Item1);
// Assert.Equal(consultant, result.Item2);
// }
// /// <summary>
// /// Classe de mock pour le gestionnaire de persistance.
// /// </summary>
// private class MockPersistenceManager : IPersistenceManager
// {
// public bool DataSaveCalled { get; private set; }
// public bool DataLoadCalled { get; private set; }
// public (List<Customer>, Consultant) DataToLoad { get; set; }
// public List<Customer>? SavedCustomersList { get; private set; }
// public Consultant? SavedConsultant { get; private set; }
// public void DataSave(List<Customer> customersList, Consultant consultant)
// {
// DataSaveCalled = true;
// SavedCustomersList = customersList;
// SavedConsultant = consultant;
// }
// public (List<Customer>, Consultant) DataLoad()
// {
// DataLoadCalled = true;
// return DataToLoad;
// }
// }
// }
//}

225
src/Banquale/UnitTest/ManagerTest.cs
Unescape View File

@ -1,137 +1,88 @@
//using System;
//using Model;
//namespace UnitTest
//{
// /// \file
// /// \brief Fichier de tests pour la classe Manager.
// /// \author Votre nom
// /// <summary>
// /// Classe de tests pour la classe Manager.
// /// </summary>
// public class ManagerTests
// {
// /// <summary>
// /// Teste si la liste des clients est initialisée correctement.
// /// </summary>
// [Fact]
// public void Constructor_CustomersListInitialized()
// {
// // Arrange
// Manager manager = new Manager();
// // Act
// // Assert
// Assert.NotNull(manager.CustomersList);
// Assert.Empty(manager.CustomersList);
// }
// /// <summary>
// /// Teste l'ajout d'un client à la liste des clients.
// /// </summary>
// [Fact]
// public void AddCustomer_ValidCustomer_ReturnsTrue()
// {
// // Arrange
// Manager manager = new Manager();
// Customer customer = new Customer("Doe", "John", "123456");
// // Act
// bool result = manager.AddCustomer(customer);
// // Assert
// Assert.True(result);
// Assert.Contains(customer, manager.CustomersList);
// }
// /// <summary>
// /// Teste la récupération d'un client à partir de la liste des clients.
// /// </summary>
// [Fact]
// public void GetCustomer_ValidPosition_ReturnsCustomer()
// {
// // Arrange
// Manager manager = new Manager();
// Customer customer1 = new Customer("Doe", "John", "123456");
// Customer customer2 = new Customer("Smith", "Jane", "abcdef");
// manager.AddCustomer(customer1);
// manager.AddCustomer(customer2);
// // Act
// Customer result = manager.GetCustomer(1);
// // Assert
// Assert.Equal(customer2, result);
// }
// /// <summary>
// /// Teste la sauvegarde des données.
// /// </summary>
// [Fact]
// public void DataSave_ValidData_CallsPersistenceManagerDataSave()
// {
// // Arrange
// MockPersistenceManager persistenceManager = new MockPersistenceManager();
// Manager manager = new Manager(persistenceManager);
// Customer customer = new Customer("Doe", "John", "123456");
// manager.AddCustomer(customer);
// // Act
// manager.DataSave();
// // Assert
// Assert.True(persistenceManager.DataSaveCalled);
// Assert.Equal(manager.CustomersList, persistenceManager.SavedCustomersList);
// Assert.Equal(manager.Consultant, persistenceManager.SavedConsultant);
// }
// /// <summary>
// /// Teste le chargement des données.
// /// </summary>
// [Fact]
// public void DataLoad_ValidData_CallsPersistenceManagerDataLoad()
// {
// // Arrange
// MockPersistenceManager persistenceManager = new MockPersistenceManager();
// Manager manager = new Manager(persistenceManager);
// Customer customer = new Customer("Doe", "John", "123456");
// Consultant consultant = new Consultant("Smith", "Jane", "abcdef");
// persistenceManager.DataToLoad = (new List<Customer> { customer }, consultant);
// // Act
// manager.DataLoad();
// // Assert
// Assert.True(persistenceManager.DataLoadCalled);
// Assert.Contains(customer, manager.CustomersList);
// Assert.Equal(consultant, manager.Consultant);
// }
// /// <summary>
// /// Classe de mock pour le gestionnaire de persistance.
// /// </summary>
// private class MockPersistenceManager : IPersistenceManager
// {
// public bool DataSaveCalled { get; private set; }
// public bool DataLoadCalled { get; private set; }
// public (List<Customer>, Consultant) DataToLoad { get; set; }
// public List<Customer>? SavedCustomersList { get; private set; }
// public Consultant? SavedConsultant { get; private set; }
// public void DataSave(List<Customer> customersList, Consultant consultant)
// {
// DataSaveCalled = true;
// SavedCustomersList = customersList;
// SavedConsultant = consultant;
// }
// public (List<Customer>, Consultant) DataLoad()
// {
// DataLoadCalled = true;
// return DataToLoad;
// }
// }
// }
//}
using Model;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using UnitTest;
using Xunit;
namespace Model.Tests
{
/// <summary>
/// Classe de tests pour la classe Manager.
/// </summary>
public class ManagerTests
{
private class PersistenceManagerMock : IPersistenceManager
{
public (HashSet<Customer>, Consultant) DataLoad()
{
// Implémentez la logique de chargement des données
// Retournez les données chargées (HashSet<Customer>, Consultant)
throw new System.NotImplementedException();
}
public void DataSave(HashSet<Customer> customers, Consultant consultant)
{
// Implémentez la logique d'enregistrement des données
// Utilisez les paramètres customers et consultant pour enregistrer les données
throw new System.NotImplementedException();
}
}
[Fact]
public void AddCustomer_ReturnsTrue()
{
// Arrange
IPersistenceManager persistenceManager = new PersistenceManagerMock();
Manager manager = new Manager(persistenceManager);
Customer customer = new Customer("A", "B", "C");
// Act
bool result = manager.AddCustomer(customer);
// Assert
Assert.True(result);
// Ajoutez plus d'assertions au besoin
}
public static IEnumerable<object[]> DataForAddCustomer()
{
yield return new object[] { new Customer("A", "B", "C") };
yield return new object[] { new Customer("B", "C", "D") };
}
[Theory]
[MemberData(nameof(DataForAddCustomer))]
public void AddCustomer_ReturnsTrueWithMemberData(Customer customer)
{
// Arrange
IPersistenceManager persistenceManager = new PersistenceManagerMock();
Manager manager = new Manager(persistenceManager);
// Act
bool result = manager.AddCustomer(customer);
// Assert
Assert.True(result);
// Ajoutez plus d'assertions au besoin
}
[Theory]
[InlineData("John", "Doe", "Consultant")]
[InlineData("Jane", "Smith", "Manager")]
public void AddCustomer_ReturnsTrueWithInlineData(string firstName, string lastName, string role)
{
// Arrange
IPersistenceManager persistenceManager = new PersistenceManagerMock();
Manager manager = new Manager(persistenceManager);
Customer customer = new Customer(firstName, lastName, role);
// Act
bool result = manager.AddCustomer(customer);
// Assert
Assert.True(result);
// Ajoutez plus d'assertions au besoin
}
}
}

80
src/Banquale/UnitTest/MessageTest.cs
Unescape View File

@ -1,29 +1,83 @@
using Model;
using System;
/// \file
/// \brief Fichier de test pour la classe Transaction.
/// \author PEREDERII Antoine
using System.Collections.Generic;
using Xunit;
using Model;
namespace UnitTest
{
/// <summary>
/// Classe de test pour la classe Message.
/// Tests for the <see cref="Message"/> class.
/// </summary>
public class MessageTest
{
/// <summary>
/// Point d'entrée du programme de test.
/// Tests the initialization of a message with the specified parameters.
/// </summary>
/// <param name="args">Arguments de ligne de commande.</param>
[Fact]
public void TestAMessage()
public void Message_Initialization()
{
// Arrange
string subject = "Test Subject";
string description = "Test Description";
// Act
Message message = new Message(subject, description);
// Assert
Assert.Equal(subject, message.Subject);
Assert.Equal(description, message.Description);
}
/// <summary>
/// Tests the change of subject for a message using inline data.
/// </summary>
/// <param name="originalSubject">The original subject of the message.</param>
/// <param name="newSubject">The new subject to set.</param>
[Theory]
[InlineData("Original Subject", "New Subject")]
[InlineData("Hello", "Goodbye")]
public void ChangeSubject_ChangesSubject(string originalSubject, string newSubject)
{
// Arrange
Message message = new Message(originalSubject, "Test Description");
// Act
message.Subject = newSubject;
// Assert
Assert.Equal(newSubject, message.Subject);
}
/// <summary>
/// Tests the change of description for a message using member data.
/// </summary>
/// <param name="originalDescription">The original description of the message.</param>
/// <param name="newDescription">The new description to set.</param>
[Theory]
[MemberData(nameof(GetMessageDescriptions))]
public void ChangeDescription_ChangesDescription(string originalDescription, string newDescription)
{
// Création d'un message
Message message = new Message("Important", "Ceci est un message important.");
// Arrange
Message message = new Message("Test Subject", originalDescription);
// Affichage des informations du message
Console.WriteLine("Message:");
Console.WriteLine($"Sujet: {message.Subject}");
Console.WriteLine($"Description: {message.Description}");
// Act
message.Description = newDescription;
Console.ReadLine();
// Assert
Assert.Equal(newDescription, message.Description);
}
/// <summary>
/// Provides test data for message descriptions.
/// </summary>
/// <returns>The list of message descriptions.</returns>
public static IEnumerable<object[]> GetMessageDescriptions()
{
yield return new object[] { "Original Description", "New Description" };
yield return new object[] { "Hello", "Goodbye" };
}
}
}

121
src/Banquale/UnitTest/PersonTest.cs
Unescape View File

@ -1,62 +1,59 @@
///// \file
///// \brief Définition de la classe Person.
///// \author Votre nom
//using System;
//using Model;
//namespace UnitTest
//{
// /// \file
// /// \brief Fichier de tests pour la classe Person.
// /// \author Votre nom
// /// <summary>
// /// Classe de tests pour la classe Person.
// /// </summary>
// public class PersonTest
// {
// /// <summary>
// /// Teste si les propriétés de l'objet Person sont correctement définies lorsque les arguments du constructeur sont valides.
// /// </summary>
// [Fact]
// public void Constructor_ValidArguments_PropertiesSet()
// {
// // Arrange
// string name = "Doe";
// string firstName = "John";
// string password = "123456";
// // Act
// Person person = new Person(name, firstName, password);
// // Assert
// Assert.Equal(name, person.Name);
// Assert.Equal(firstName, person.FirstName);
// Assert.Equal(password, person.Password);
// }
// /// <summary>
// /// Teste si l'identifiant de chaque instance de Person est correctement incrémenté.
// /// </summary>
// [Fact]
// public void Constructor_IncrementId()
// {
// // Arrange
// string name1 = "Doe";
// string firstName1 = "John";
// string password1 = "123456";
// string name2 = "Smith";
// string firstName2 = "Jane";
// string password2 = "abcdef";
// // Act
// Person person1 = new Person(name1, firstName1, password1);
// Person person2 = new Person(name2, firstName2, password2);
// // Assert
// Assert.Equal(Convert.ToUInt32(0), person1.Id);
// Assert.Equal(Convert.ToUInt32(1), person2.Id);
// }
// }
//}
/// \file
/// \brief Fichier de test pour la classe Transaction.
/// \author PEREDERII Antoine
using Model;
using Xunit;
namespace UnitTest
{
public class PersonTest
{
[Fact]
public void Person_Initialization()
{
// Arrange
string expectedName = "Doe";
string expectedFirstName = "John";
string expectedPassword = "123456";
// Act
Person person = new Person(expectedName, expectedFirstName, expectedPassword);
// Assert
Assert.Equal(expectedName, person.Name);
Assert.Equal(expectedFirstName, person.FirstName);
Assert.Equal(expectedPassword, person.Password);
}
[Fact]
public void Person_IncrementId()
{
// Arrange
uint expectedId = Person.id;
// Act
Person person1 = new Person("Doe", "John", "123456");
Person person2 = new Person("Smith", "Jane", "abcdef");
// Assert
Assert.Equal(expectedId, person1.Id);
Assert.Equal(expectedId + 1, person2.Id);
}
[Theory]
[InlineData("Doe", "John", "123456")]
[InlineData("Smith", "Jane", "abcdef")]
public void Person_NameLength_ShouldBeGreaterThanZero(string name, string firstName, string password)
{
// Arrange
Person person = new Person(name, firstName, password);
// Act
int nameLength = person.Name.Length;
// Assert
Assert.True(nameLength > 0);
}
}
}

122
src/Banquale/UnitTest/TransactionTest.cs
Unescape View File

@ -1,38 +1,126 @@
/// \file
/// \brief Fichier de test pour la classe Transaction.
/// \author Votre nom
/// \author PEREDERII Antoine
using Model;
using System;
using System.Collections.Generic;
using Model;
using Xunit;
namespace UnitTest
{
/// <summary>
/// Classe de test pour la classe Transaction.
/// Tests for the <see cref="Transaction"/> class.
/// </summary>
public class TransactionTest
{
/// <summary>
/// Méthode principale du test.
/// Tests the initialization of a transaction with the specified parameters.
/// </summary>
[Fact]
public void Transaction_Initialization()
{
// Arrange
bool type = true;
double sum = 100.0;
Account involvedAccounts = new Account(10, "Bonjour", "FR1234567890123456789012343");
DateTime date = DateTime.Now;
// Act
Transaction transaction = new Transaction(type, sum, involvedAccounts, date);
// Assert
Assert.Equal(type, transaction.Type);
Assert.Equal(sum, transaction.Sum);
Assert.Equal(involvedAccounts, transaction.InvolvedAccounts);
Assert.Equal(date, transaction.Date);
Assert.False(transaction.IsOpposition);
}
/// <summary>
/// Tests changing the category of a transaction.
/// </summary>
[Fact]
public void TestATransaction()
public void ChangeCategory_ChangesCategory()
{
// Arrange
Transaction transaction = new Transaction(true, 100.0, new Account(100, "Monsieur", "FR1234567890190456789012343"), DateTime.Now);
string newCategory = "NewCategory";
// Act
transaction.ChangeCategory(newCategory);
// Assert
Assert.Equal(newCategory, transaction.Category);
}
/// <summary>
/// Tests the transaction type using inline data.
/// </summary>
/// <param name="type">The transaction type.</param>
/// <param name="expectedResult">The expected result.</param>
[Theory]
[InlineData(true, true)]
[InlineData(false, false)]
public void Transaction_Type(bool type, bool expectedResult)
{
// Arrange
Transaction transaction = new Transaction(type, 100.0, new Account(1000, "Hello", "FR1212567890190456789012343"), DateTime.Now);
// Act
bool result = transaction.Type;
// Assert
Assert.Equal(expectedResult, result);
}
/// <summary>
/// Tests the sum of the transaction using inline data.
/// </summary>
/// <param name="sum">The sum of the transaction.</param>
[Theory]
[InlineData(100.0)]
[InlineData(200.0)]
public void Transaction_Sum(double sum)
{
// Arrange
Transaction transaction = new Transaction(true, sum, new Account(100, "Monsieur", "FR1234567890190456789012343"), DateTime.Now);
// Act
double result = transaction.Sum;
// Assert
Assert.Equal(sum, result);
}
/// <summary>
/// Tests the transaction category using member data.
/// </summary>
/// <param name="category">The transaction category.</param>
[Theory]
[MemberData(nameof(GetTransactionCategories))]
public void Transaction_Category(string category)
{
// Création d'un compte
Account account = new Account(1000, "John Doe", "FR123456789");
// Arrange
Transaction transaction = new Transaction(true, 100.0, new Account(100, "Monsieur", "FR1234567890190456789012343"), DateTime.Now);
// Création d'une transaction
Transaction transaction = new Transaction(true, 200, account, DateTime.Now);
// Act
transaction.ChangeCategory(category);
string result = transaction.Category;
// Affichage des informations de la transaction
Console.WriteLine("Transaction:");
Console.WriteLine($"Type: {(transaction.Type ? "Débit" : "Crédit")}");
Console.WriteLine($"Somme: {transaction.Sum}");
Console.WriteLine($"Compte impliqué: {transaction?.InvolvedAccounts?.Name}");
Console.WriteLine($"Catégorie: {transaction?.Category}");
Console.WriteLine($"Date: {transaction?.Date}");
// Assert
Assert.Equal(category, result);
}
Console.ReadLine();
/// <summary>
/// Provides test data for transaction categories.
/// </summary>
/// <returns>The list of transaction categories.</returns>
public static IEnumerable<object[]> GetTransactionCategories()
{
yield return new object[] { "Category1" };
yield return new object[] { "Category2" };
}
}
}

1
src/Banquale/UnitTest/Usings.cs
Unescape View File

@ -1 +0,0 @@
global using Xunit;
Write Preview
Loading…
Cancel
Save