Exclude test

.drone.yml

@@ -7,6 +7,49 @@ trigger:
     - push
 
 steps:
+  - name: build
+    image: mcr.microsoft.com/dotnet/sdk:8.0
+    commands:
+      - cd VeraxShield
+      - dotnet restore VeraxShield.sln
+      - dotnet build VeraxShield.sln -c Release --no-restore
+      - dotnet publish VeraxShield.sln -c Release --no-restore -o $CI_PROJECT_DIR/build/release
+
+  - name: tests
+    image: mcr.microsoft.com/dotnet/sdk:8.0
+    commands:
+      - cd VeraxShield
+      - dotnet restore VeraxShield.sln
+      - dotnet test VeraxShield.sln --no-restore
+    depends_on: [build]
+
+  - name: code-inspection
+    image: hub.codefirst.iut.uca.fr/marc.chevaldonne/codefirst-dronesonarplugin-dotnet8
+    secrets: [ SECRET_SONAR_LOGIN ]
+    environment:
+      sonar_host: https://codefirst.iut.uca.fr/sonar/
+      sonar_token:
+        from_secret: SECRET_SONAR_LOGIN # Secret de Drone
+      project_key: VeraxShield
+      
+    commands:
+      - cd VeraxShield/
+      - dotnet restore VeraxShield.sln
+      - dotnet sonarscanner begin /k:$${project_key} /d:sonar.host.url=$${sonar_host} /d:sonar.coverageReportPaths="coveragereport/SonarQube.xml" /d:sonar.coverage.exclusions="VeraxShield/wwwroot/**","VeraxShield/composants/**","VeraxShield/pages/**","VeraxShield/Properties/**","TestVeraxShield/**","VeraxShield/Program.cs","VeraxShield/services/UtilisateursDataService/UtilisateursDataServiceApi.cs","VeraxShield/services/UtilisateursDataService/UtilisateursDataServiceFactice.cs" /d:sonar.login=$${sonar_token} 
+      - dotnet build VeraxShield.sln -c Release --no-restore
+      - dotnet test VeraxShield.sln --logger trx --no-restore /p:CollectCoverage=true /p:CoverletOutputFormat=cobertura --collect "XPlat Code Coverage"
+      - reportgenerator -reports:"**/coverage.cobertura.xml" -reporttypes:SonarQube -targetdir:"coveragereport"
+      - dotnet publish VeraxShield.sln -c Release --no-restore -o $CI_PROJECT_DIR/build/release
+      - dotnet sonarscanner end /d:sonar.login=$${sonar_token}
+    when:
+      branch:
+        - master
+      event:
+        - push
+        - pull_request
+    depends_on: [build,tests]
+
+
   - name: docker-build-and-push
     image: plugins/docker
     settings:

.gitignore

@@ -6,6 +6,8 @@
 bin/
 obj/
 
+
+
 # Common node modules locations
 /node_modules
 /wwwroot/node_modules

VeraxShield/.idea/.idea.VeraxShield/.idea/indexLayout.xml

@@ -1,7 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="UserContentModel">
-    <attachedFolders />
+    <attachedFolders>
+      <Path>../../Blazor_SAE</Path>
+    </attachedFolders>
     <explicitIncludes />
     <explicitExcludes />
   </component>

VeraxShield/TestVeraxShield/AuthentificationServiceTests.cs

@@ -0,0 +1,105 @@
+using System.Security.Claims;
+using Moq;
+using VeraxShield.composants.formulaires.modeles;
+using VeraxShield.modele.utilisateurs;
+using VeraxShield.services.UtilisateursDataService;
+
+namespace TestVeraxShield;
+
+public class AuthentificationServiceTests
+{
+     private readonly AuthentificationService _authService;
+    private readonly Mock<IUtilisateursDataService> _mockDataService = new Mock<IUtilisateursDataService>();
+
+    public AuthentificationServiceTests()
+    {
+        _authService = new AuthentificationService(_mockDataService.Object);
+    }
+
+    [Fact]
+    public async Task Connexion_WithValidCredentials_ShouldSucceed()
+    {
+        // Arrange
+        var testUser = new Utilisateur("testUser", "Test", "User", "test@user.com", BCrypt.Net.BCrypt.HashPassword("password"), "User", false);
+
+        _mockDataService.Setup(s => s.getAllUtilisateurs())
+            .ReturnsAsync(new List<Utilisateur> { testUser });
+
+        var requete = new RequeteConnexion
+        {
+            Pseudo = "testUser",
+            MotDePasse = "password"
+        };
+
+        // Act & Assert
+        await _authService.Connexion(requete);
+    }
+
+    [Fact]
+    public async Task Connexion_WithInvalidCredentials_ShouldThrowException()
+    {
+        // Arrange
+        _mockDataService.Setup(s => s.getAllUtilisateurs())
+            .ReturnsAsync(new List<Utilisateur>());
+
+        var requete = new RequeteConnexion
+        {
+            Pseudo = "nonExistentUser",
+            MotDePasse = "wrongPassword"
+        };
+
+        // Act & Assert
+        await Assert.ThrowsAsync<Exception>(() => _authService.Connexion(requete));
+    }
+
+    [Fact]
+    public async Task Inscription_ShouldCreateNewUser()
+    {
+        // Arrange
+        var requete = new RequeteInscription
+        {
+            Pseudo = "newUser",
+            Nom = "New",
+            Prenom = "User",
+            Mail = "new@user.com",
+            MotDePasse = "newPassword"
+        };
+
+        // Setup the mock to verify that AjouterUtilisateur is called with a Utilisateur that matches the inscription details
+        _mockDataService.Setup(s => s.AjouterUtilisateur(It.IsAny<Utilisateur>()))
+            .Returns(Task.CompletedTask)
+            .Callback<Utilisateur>(u =>
+            {
+                Assert.Equal(requete.Pseudo, u.Pseudo);
+                Assert.True(BCrypt.Net.BCrypt.Verify(requete.MotDePasse, u.Mdp));
+            });
+
+        // Act
+        await _authService.Inscription(requete);
+
+    }
+    [Fact]
+    public async Task GetUtilisateur_ReturnsCorrectUser_WithClaims()
+    {
+        // Arrange
+        var expectedPseudo = "testUser";
+        var expectedRole = "User";
+        var testUser = new Utilisateur("testUser", "Test", "User", "test@user.com", BCrypt.Net.BCrypt.HashPassword("password"), "User", false);
+        var mockDataService = new Mock<IUtilisateursDataService>();
+        mockDataService.Setup(s => s.getAllUtilisateurs())
+            .ReturnsAsync(new List<Utilisateur> { testUser });
+
+        var authService = new AuthentificationService(mockDataService.Object);
+
+        // Act
+        var utilisateurCourant = await authService.GetUtilisateur(expectedPseudo);
+        utilisateurCourant.Claims.Add(ClaimTypes.Email, "test@user.com");
+
+        // Assert
+        Assert.NotNull(utilisateurCourant);
+        Assert.True(utilisateurCourant.EstAuthentifie);
+        Assert.Equal(expectedPseudo, utilisateurCourant.Pseudo);
+        
+    }
+
+}

VeraxShield/TestVeraxShield/DonneurEtatTests.cs

@@ -0,0 +1,85 @@
+using Moq;
+using System.Collections.Generic;
+using System.Security.Claims;
+using System.Threading.Tasks;
+using VeraxShield.composants.formulaires.modeles;
+using VeraxShield.modele.utilisateurs;
+using VeraxShield.services.UtilisateursDataService;
+using Xunit;
+
+namespace VeraxShield.UnitTests
+{
+    public class DonneurEtatTests
+    {
+        private readonly DonneurEtat _donneurEtat;
+        private readonly Mock<IAuthentificationService> _mockAuthService;
+        private readonly Mock<IUtilisateursDataService> _mockUserDataService;
+
+        public DonneurEtatTests()
+        {
+            _mockAuthService = new Mock<IAuthentificationService>();
+            _mockUserDataService = new Mock<IUtilisateursDataService>();
+            _donneurEtat = new DonneurEtat(_mockAuthService.Object, _mockUserDataService.Object);
+        }
+
+        [Fact]
+        public async Task Connexion_ValidCredentials_SetsCurrentUser()
+        {
+            // Arrange
+            var requeteConnexion = new RequeteConnexion { Pseudo = "testUser", MotDePasse = "testPass" };
+            var utilisateurCourant = new UtilisateurCourant
+            {
+                Pseudo = "testUser",
+                EstAuthentifie = true,
+                Claims = new Dictionary<string, string> { { ClaimTypes.Role, "User" } }
+            };
+
+            _mockAuthService.Setup(x => x.GetUtilisateur(requeteConnexion.Pseudo)).ReturnsAsync(utilisateurCourant);
+            _mockAuthService.Setup(x => x.Connexion(requeteConnexion)).Returns(Task.CompletedTask);
+
+            // Act
+            await _donneurEtat.Connexion(requeteConnexion);
+
+            // Assert
+            Assert.NotNull(_donneurEtat._utilisateurCourant);
+            Assert.True(_donneurEtat._utilisateurCourant.EstAuthentifie);
+            _mockAuthService.Verify(x => x.Connexion(requeteConnexion), Times.Once);
+            _mockAuthService.Verify(x => x.GetUtilisateur(requeteConnexion.Pseudo), Times.Once);
+        }
+
+        [Fact]
+        public async Task Deconnexion_ClearsCurrentUser()
+        {
+            // Arrange - assume user is logged in
+            _donneurEtat._utilisateurCourant = new UtilisateurCourant { EstAuthentifie = true };
+
+            // Act
+            await _donneurEtat.Deconnexion();
+
+            // Assert
+            Assert.Null(_donneurEtat._utilisateurCourant);
+        }
+
+        [Fact]
+        public async Task Inscription_ValidData_RegistersUser()
+        {
+            // Arrange
+            var requeteInscription = new RequeteInscription
+            {
+                Pseudo = "newUser",
+                MotDePasse = "newPass",
+                Mail = "newUser@test.com",
+                Nom = "New",
+                Prenom = "User"
+            };
+
+            _mockAuthService.Setup(x => x.Inscription(requeteInscription)).Returns(Task.CompletedTask);
+
+            // Act
+            await _donneurEtat.Inscription(requeteInscription);
+
+            // Assert - Since Inscription does not automatically log in the user, we check if the method was called.
+            _mockAuthService.Verify(x => x.Inscription(requeteInscription), Times.Once);
+        }
+    }
+}

VeraxShield/TestVeraxShield/IAuthentificationServiceTests.cs

@@ -0,0 +1,45 @@
+using Moq;
+using VeraxShield.modele.utilisateurs;
+using VeraxShield.services.UtilisateursDataService;
+
+namespace TestVeraxShield;
+
+public class IAuthentificationServiceTests
+{
+    private readonly Mock<IUtilisateursDataService> _mockDataService;
+    private readonly AuthentificationService _authService;
+
+    public IAuthentificationServiceTests()
+    {
+        _mockDataService = new Mock<IUtilisateursDataService>();
+        _authService = new AuthentificationService(_mockDataService.Object);
+    }
+
+    [Fact]
+    public async Task GetUtilisateur_ValidUser_ReturnsUser()
+    {
+        // Arrange
+        var expectedUser = new UtilisateurCourant { Pseudo = "user1", EstAuthentifie = true };
+        _mockDataService.Setup(x => x.getAllUtilisateurs()).ReturnsAsync(new List<Utilisateur>
+        {
+            new Utilisateur("user1", "Name", "Surname", "user1@example.com", "password", "User", false)
+        });
+
+        // Act
+        var result = await _authService.GetUtilisateur("user1");
+
+        // Assert
+        Assert.Equal(expectedUser.Pseudo, result.Pseudo);
+        Assert.True(result.EstAuthentifie);
+    }
+
+    [Fact]
+    public async Task GetUtilisateur_NonExistentUser_ThrowsException()
+    {
+        // Arrange
+        _mockDataService.Setup(x => x.getAllUtilisateurs()).ReturnsAsync(new List<Utilisateur>());
+
+        // Act & Assert
+        await Assert.ThrowsAsync<Exception>(() => _authService.GetUtilisateur("user2"));
+    }
+}

VeraxShield/TestVeraxShield/IUtilisateursDataServiceTests.cs

@@ -0,0 +1,25 @@
+using Moq;
+using VeraxShield.modele.utilisateurs;
+using VeraxShield.services.UtilisateursDataService;
+
+namespace TestVeraxShield;
+
+public class IUtilisateursDataServiceTests
+{
+    private readonly Mock<IUtilisateursDataService> _service = new Mock<IUtilisateursDataService>();
+
+    [Fact]
+    public async Task AjouterUtilisateur_AddsUserSuccessfully()
+    {
+        // Arrange
+        var user = new Utilisateur("testUser", "User", "Test", "dez", "password", "User", false);        
+        _service.Setup(s => s.AjouterUtilisateur(It.IsAny<Utilisateur>()))
+            .Returns(Task.CompletedTask)
+            .Callback<Utilisateur>(u => Assert.Equal("testUser", u.Pseudo));
+
+        // Act
+        await _service.Object.AjouterUtilisateur(user);
+
+        // Assert is handled by the Callback
+    }
+}

VeraxShield/TestVeraxShield/TestVeraxShield.csproj

@@ -12,6 +12,8 @@
     <ItemGroup>
         <PackageReference Include="bunit.web" Version="1.27.17" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0"/>
+        <PackageReference Include="Moq" Version="4.20.70" />
+        <PackageReference Include="RichardSzalay.MockHttp" Version="7.0.0" />
         <PackageReference Include="xunit" Version="2.4.2"/>
         <PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

VeraxShield/TestVeraxShield/UtilisateurDataServiceTests.cs

@@ -0,0 +1,56 @@
+using Microsoft.AspNetCore.Components;
+using Moq;
+using Newtonsoft.Json;
+using RichardSzalay.MockHttp;
+using VeraxShield.modele.utilisateurs;
+using VeraxShield.services.UtilisateursDataService;
+
+namespace TestVeraxShield;
+
+public class UtilisateursDataServiceApiTests
+{
+    private readonly MockHttpMessageHandler _mockHttp;
+    private readonly HttpClient _clientHttp;
+    private readonly Mock<NavigationManager> _mockNavigationManager;
+    private readonly UtilisateursDataServiceApi _service;
+
+    public UtilisateursDataServiceApiTests()
+    {
+        _mockHttp = new MockHttpMessageHandler();
+
+        // Mock the response for the API call
+        _mockHttp.When("https://Verax.com/api/utilisateurs/recuperer")
+            .Respond("application/json", JsonConvert.SerializeObject(new List<Utilisateur>
+            {
+                new Utilisateur("testUser", "User", "Test", "dez", "password", "User", false)
+            }));
+
+        _clientHttp = _mockHttp.ToHttpClient();
+        _clientHttp.BaseAddress = new System.Uri("https://Verax.com");
+
+        _mockNavigationManager = new Mock<NavigationManager>();
+        _service = new UtilisateursDataServiceApi(_clientHttp, _mockNavigationManager.Object);
+    }
+
+    [Fact]
+    public async Task GetAllUtilisateurs_ReturnsUsers()
+    {
+        // Act
+        var users = await _service.getAllUtilisateurs();
+
+        // Assert
+        Assert.Single(users);
+        Assert.Equal("testUser", users[0].Pseudo);
+    }
+    
+    [Fact]
+    public async Task GetUtilisateurFromPseudo_ReturnsUser()
+    {
+        // Act
+        var user = await _service.getUtilisateurFromPseudo("testUser");
+
+        // Assert
+        Assert.Equal("testUser", user.Pseudo);
+    }
+    
+}

VeraxShield/TestVeraxShield/UtlisateurFactoryTests.cs

@@ -32,4 +32,25 @@ public class UtilisateursFactoryTests
         // Assert
     }
 
+    
+    
+    
+    [Fact]
+    public void ConvertsToModele_FromUtilisateurs()
+    {
+        // Arrange
+        var utilisateur = new Utilisateur("pseudo", "nom", "prenom", "role", "mdp", "mail", false);
+        
+        // Act
+        var modele = UtilisateursFactory.toModele(utilisateur);
+        
+        // Assert
+        Assert.Equal(utilisateur.Pseudo, modele.Pseudo);
+        Assert.Equal(utilisateur.Nom, modele.Nom);
+        Assert.Equal(utilisateur.Prenom, modele.Prenom);
+        Assert.Equal(utilisateur.Role, modele.Role);
+        Assert.Equal(utilisateur.Mail, modele.Mail);
+        Assert.Equal(utilisateur.IsBan, modele.IsBan);
+    }
+
 }