debut etape 2

TP3/src/main/java/automaticmocking/AuthenticationByBiometryService.java

+package automaticmocking;
+
+import authentication.AuthenticationService;
+import authentication.Strength;
+import interfacemanualmocking.DirectoryInterface;
+
+public class AuthenticationByBiometryService  implements AuthenticationService {
+    private interfacemanualmocking.DirectoryInterface directory;
+    private Strength strength;
+
+    public AuthenticationByBiometryService(interfacemanualmocking.DirectoryInterface directory, Strength strength) {
+        this.directory = directory;
+        this.strength = strength;
+    }
+
+    public void setDirectory(DirectoryInterface directory) {
+        this.directory = directory;
+    }
+
+    @Override
+    public boolean isAMatch(String identifier, String autenthicationData) {
+        String match = directory.getMatch(identifier);
+        return match.equals(autenthicationData);
+    }
+
+    @Override
+    public Strength dataStrenth(String autenthicationData) {
+        return Strength.STRONG;
+    }
+}

TP3/src/main/java/automaticmocking/AuthenticationByPasswordService.java

+package automaticmocking;
+
+import authentication.AuthenticationService;
+import authentication.Strength;
+import interfacemanualmocking.DirectoryInterface;
+import interfacemanualmocking.StrengthEstimationServiceInterface;
+
+public class AuthenticationByPasswordService implements AuthenticationService {
+    private interfacemanualmocking.DirectoryInterface directory;
+
+
+
+    private interfacemanualmocking.StrengthEstimationServiceInterface strengthEstimationService;
+
+    public void setStrengthEstimationService(interfacemanualmocking.StrengthEstimationServiceInterface strengthEstimationService) {
+        this.strengthEstimationService = strengthEstimationService;
+    }
+
+    public AuthenticationByPasswordService(interfacemanualmocking.DirectoryInterface directory, StrengthEstimationServiceInterface strengthEstimationService) {
+        this.directory = directory;
+        this.strengthEstimationService = strengthEstimationService;
+    }
+
+
+    @Override
+    public boolean isAMatch(String identifier, String autenthicationData) {
+        String match = directory.getMatch(identifier);
+        return match.equals(autenthicationData);
+    }
+
+    @Override
+    public Strength dataStrenth(String autenthicationData) {
+        int datasize = autenthicationData.length();
+        int alphabetSize = 142;
+        int strength = strengthEstimationService.equivalentBitLength(alphabetSize,datasize);
+
+        Strength result = null ;
+        if( strength >= 0 && strength <= 49 ) {
+            result = Strength.VERY_WEAK;
+        }
+        else if ( strength >= 50 && strength <= 79 ) {
+            result = Strength.WEAK;
+        }
+        else if ( strength >= 80 && strength <= 99 ) {
+            result = Strength.REGULAR;
+        }
+        else if ( strength >= 100 ) {
+            result = Strength.STRONG;
+        }
+        return result;
+    }
+    public void setDirectory(DirectoryInterface directory) {
+        this.directory = directory;
+    }
+
+
+}
+
+
+    //private StrengthEstimationServiceInterface dataStrenth(String autenthicationData) {
+     //   int alphabetSize = 0;
+       // int datasize = autenthicationData.length();
+        //return strengthEstimationService.equivalentBitLength(alphabetSize, datasize);
+    //}
+

TP3/src/main/java/automaticmocking/AuthenticationService.java

+package automaticmocking;
+
+import authentication.Strength;
+
+public interface AuthenticationService {
+    boolean isAMatch(String identifier, String autenthicationData);
+    Strength dataStrenth(String autenthicationData);
+}

TP3/src/main/java/automaticmocking/DirectoryInterface.java

+package automaticmocking;
+
+public interface DirectoryInterface {
+    String getMatch(String identifier);
+}

TP3/src/main/java/automaticmocking/StrengthEstimationServiceInterface.java

+package automaticmocking;
+
+public interface StrengthEstimationServiceInterface {
+    int equivalentBitLength(int alphabetSize, int datasize);
+}

TP3/src/test/java/AuthenticationByBiometryServiceTest.java

+import static authentication.Strength.STRONG;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.*;
+import org.junit.jupiter.api.extension.ExtendWith;
+
 import interfacemanualmocking.AuthenticationByBiometryService;
-import interfacemanualmocking.AuthenticationByPasswordService;
 import interfacemanualmocking.MockDirectory;
-import interfacemanualmocking.MockStrengthEstimationService;
 import org.junit.jupiter.api.*;
 
-import static authentication.Strength.*;
-import static authentication.Strength.STRONG;
-import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+//import org.mockito.junit.jupiter.MockitoExtension;
+
 
 public class AuthenticationByBiometryServiceTest {
+
+    @Mock
     private MockDirectory directory;
+
+    @InjectMocks
     private AuthenticationByBiometryService authenticationByBiometryService;
 
     @BeforeAll
@@ -24,12 +33,10 @@ public class AuthenticationByBiometryServiceTest {
 
     @BeforeEach
     void setUp() {
-        directory = new MockDirectory();
+        // Pas besoin de créer le mock manuellement, Mockito le fait pour vous avec @Mock
         authenticationByBiometryService = new AuthenticationByBiometryService(directory, STRONG);
-        authenticationByBiometryService.setDirectory(directory);
     }
 
-
     @AfterEach
     void tearDown() throws Exception {
         System.out.println("After each");
@@ -37,13 +44,41 @@ public class AuthenticationByBiometryServiceTest {
 
     @Test
     void testIsAMatch() {
+        // Définir un comportement attendu sur le mock
+        when(authenticationByBiometryService.isAMatch("regix", "azerty")).thenReturn(true);
+
         assertThat(authenticationByBiometryService.isAMatch("regix", "azerty")).isTrue();
 
+        // Vérifier que la méthode du mock a été appelée avec les bons arguments
+        verify(authenticationByBiometryService, times(1)).isAMatch("regix", "azerty");
+
+        // Vérifier qu'aucune autre méthode du mock n'a été appelée
+        verifyNoMoreInteractions(directory);
     }
 
     @Test
-    void testDataStrenth() {
+    void testDataStrength() {
+        // Définir un comportement attendu sur le mock
+        when(authenticationByBiometryService.dataStrenth("azerty")).thenReturn(STRONG);
+
         assertThat(authenticationByBiometryService.dataStrenth("azerty")).isEqualTo(STRONG);
+
+        // Vérifier que la méthode du mock a été appelée avec les bons arguments
+        verify(authenticationByBiometryService, times(1)).dataStrenth("azerty");
+
+        // Vérifier qu'aucune autre méthode du mock n'a été appelée
+        verifyNoMoreInteractions(directory);
+
+        // Ajouter un autre cas de test avec des données différentes
+        when(authenticationByBiometryService.dataStrenth("azertyuiopqsdfghjklmwxcvbn1234567890")).thenReturn(STRONG);
+
         assertThat(authenticationByBiometryService.dataStrenth("azertyuiopqsdfghjklmwxcvbn1234567890")).isEqualTo(STRONG);
+
+        // Vérifier que la méthode du mock a été appelée avec les bons arguments
+        verify(authenticationByBiometryService, times(1)).dataStrenth("azertyuiopqsdfghjklmwxcvbn1234567890");
+
+        // Vérifier qu'aucune autre méthode du mock n'a été appelée
+        verifyNoMoreInteractions(directory);
     }
 }
+