Added unit tests and improved the code for testability.

wilrikdeloose · wilrikdeloose · commit c840fb98fd51 · 2018-04-14T00:15:45.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -1,3 +1,6 @@
+# IntelliJ
+.idea
+
 # Compiled class file
 *.class
 
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
diff --git a/HashExample.iml b/HashExample.iml
@@ -11,5 +11,9 @@
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="Maven: org.junit.jupiter:junit-jupiter-api:5.1.1" level="project" />
+    <orderEntry type="library" name="Maven: org.apiguardian:apiguardian-api:1.0.0" level="project" />
+    <orderEntry type="library" name="Maven: org.opentest4j:opentest4j:1.0.0" level="project" />
+    <orderEntry type="library" name="Maven: org.junit.platform:junit-platform-commons:1.1.1" level="project" />
   </component>
 </module>
diff --git a/pom.xml b/pom.xml
@@ -7,6 +7,17 @@
     <groupId>nl.fontys.wa5</groupId>
     <artifactId>HashExample</artifactId>
     <version>1.0-SNAPSHOT</version>
-
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>RELEASE</version>
+        </dependency>
+    </dependencies>
+    <plugin>
+        <groupId>org.jacoco</groupId>
+        <artifactId>jacoco-maven-plugin</artifactId>
+        <version>0.8.2-SNAPSHOT</version>
+    </plugin>
 
 </project>
diff --git a/src/main/java/BLL/AccountRepository.java b/src/main/java/BLL/AccountRepository.java
@@ -16,21 +16,23 @@ public class AccountRepository {
     PasswordEncrypter encrypter;
 
     public AccountRepository() {
-        encrypter = EncrypterFactory.getEncrypter(EncryptionAlgorithms.SHA2);
+        encrypter = EncrypterFactory.getEncrypter(EncryptionAlgorithm.SHA2);
     }
 
-    public void login(String username, String passwordString) {
+    public boolean login(String username, String passwordString) {
         byte[] salt = context.getSaltByUsername(username);
         Password password = encrypter.encrypt(passwordString, salt);
 
         if (context.login(username, password)) {
             System.out.println("Login successful!");
+            return true;
         } else {
             System.out.println("Login unsuccessful :(");
+            return false;
         }
     }
 
-    public void register(String username, String passwordString) throws UsernameAlreadyExistsException, UsernameTooShortException, PasswordTooWeakException {
+    public boolean register(String username, String passwordString) throws UsernameAlreadyExistsException, UsernameTooShortException, PasswordTooWeakException {
         if (usernameAlreadyExists(username)) {
             throw new UsernameAlreadyExistsException("ERROR: This username is already taken!");
         }
@@ -46,8 +48,10 @@ public void register(String username, String passwordString) throws UsernameAlre
 
         if (context.register(username, password)) {
             System.out.println("Account successfully registered!");
+            return true;
         } else {
             System.out.println("Account was not registered :(");
+            return false;
         }
     }
 
diff --git a/src/main/java/BLL/Encryption/EncrypterFactory.java b/src/main/java/BLL/Encryption/EncrypterFactory.java
@@ -1,7 +1,7 @@
 package BLL.Encryption;
 
 public class EncrypterFactory {
-    static public PasswordEncrypter getEncrypter(EncryptionAlgorithms algorithm) {
+    static public PasswordEncrypter getEncrypter(EncryptionAlgorithm algorithm) {
         switch (algorithm) {
             default:
             case Simple:
diff --git a/src/main/java/BLL/Encryption/EncryptionAlgorithm.java b/src/main/java/BLL/Encryption/EncryptionAlgorithm.java
@@ -1,6 +1,6 @@
 package BLL.Encryption;
 
-public enum EncryptionAlgorithms {
+public enum EncryptionAlgorithm {
     Simple,
     SHA2
 }
diff --git a/src/main/java/BLL/Encryption/Salt.java b/src/main/java/BLL/Encryption/Salt.java
@@ -0,0 +1,33 @@
+package BLL.Encryption;
+
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.util.Arrays;
+
+public class Salt {
+    private final int SALT_SIZE = 32;
+    private byte[] salt;
+
+    public Salt() {
+        salt = new byte[SALT_SIZE];
+        try {
+            SecureRandom.getInstanceStrong().nextBytes(salt);
+        }  catch (NoSuchAlgorithmException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public byte[] get() {
+        return salt;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || !(o instanceof Salt)) {
+            return false;
+        }
+
+        Salt s = (Salt)o;
+        return Arrays.equals(this.salt, s.get());
+    }
+}
diff --git a/src/main/java/BLL/Encryption/Sha2Encrypter.java b/src/main/java/BLL/Encryption/Sha2Encrypter.java
@@ -4,22 +4,20 @@
 import javax.crypto.SecretKeyFactory;
 import javax.crypto.spec.PBEKeySpec;
 import java.security.NoSuchAlgorithmException;
-import java.security.SecureRandom;
 import java.security.spec.InvalidKeySpecException;
 
 public class Sha2Encrypter implements PasswordEncrypter {
     private final int ITERATIONS = 10000;
     private final int KEYLENGTH = 256;
     private final int SALT_SIZE = 32;
 
-
     @Override
     public Sha2Password encrypt(String password) {
         return this.encrypt(password, null);
     }
 
     public Sha2Password encrypt(String password, byte[] inputSalt) {
-        byte[] salt = inputSalt == null ? generateSalt() : inputSalt;
+        byte[] salt = inputSalt == null ? (new Salt()).get() : inputSalt;
 
         try {
             SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA512");
@@ -28,14 +26,8 @@ public Sha2Password encrypt(String password, byte[] inputSalt) {
             byte[] hash = key.getEncoded();
 
             return new Sha2Password(hash, salt, ITERATIONS, KEYLENGTH);
-        } catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
+        } catch (NoSuchAlgorithmException | InvalidKeySpecException | IllegalArgumentException e) {
             throw new RuntimeException(e);
         }
     }
-
-    private byte[] generateSalt() {
-        byte[] salt = new byte[SALT_SIZE];
-        (new SecureRandom()).nextBytes(salt);
-        return salt;
-    }
 }
diff --git a/src/main/java/BLL/Encryption/SimpleEncrypter.java b/src/main/java/BLL/Encryption/SimpleEncrypter.java
@@ -1,10 +1,6 @@
 package BLL.Encryption;
 
-import java.security.NoSuchAlgorithmException;
-import java.security.SecureRandom;
-
 public class SimpleEncrypter implements PasswordEncrypter {
-    private final int SALT_SIZE = 32;
 
     @Override
     public SimplePassword encrypt(String password) {
@@ -13,7 +9,7 @@ public SimplePassword encrypt(String password) {
 
     @Override
     public SimplePassword encrypt(String password, byte[] inputSalt) {
-        byte[] salt = inputSalt == null ? generateSalt() : inputSalt;
+        byte[] salt = inputSalt == null ? (new Salt()).get() : inputSalt;
         byte[] encryptedPass = new byte[password.length()];
 
         byte s = 0;
@@ -27,15 +23,4 @@ public SimplePassword encrypt(String password, byte[] inputSalt) {
 
         return new SimplePassword(new String(encryptedPass), salt);
     }
-
-    private byte[] generateSalt() {
-        byte[] salt = new byte[SALT_SIZE];
-        try {
-            SecureRandom.getInstanceStrong().nextBytes(salt);
-        }  catch (NoSuchAlgorithmException e) {
-            throw new RuntimeException(e);
-        }
-
-        return salt;
-    }
 }
diff --git a/src/main/java/DAL/AccountMemoryContext.java b/src/main/java/DAL/AccountMemoryContext.java
@@ -5,6 +5,7 @@
 import java.util.ArrayList;
 
 public class AccountMemoryContext implements AccountContext {
+    // static so that it behaves as a sort of centralized database
     static private ArrayList<Account> accounts = new ArrayList<>();
 
     @Override
@@ -44,7 +45,14 @@ public byte[] getSaltByUsername(String username) {
         if (a != null) {
             return a.getPassword().getSalt();
         } else {
-            return new byte[0];
+            return null;
         }
     }
+
+    /*
+    This method clears (empties) the memory context (DB). This is purely for testing purposes.
+     */
+    public void clear() {
+        accounts.clear();
+    }
 }
diff --git a/src/main/java/UI/ConsoleApp.java b/src/main/java/UI/ConsoleApp.java
@@ -18,8 +18,7 @@ public void start() {
 
         while (true) {
             try {
-                ConsoleInput input = getInput();
-                handleInput(input);
+                handleInput(getInput());
             } catch (InvalidInputException | UnknownCommandException | WrongArgumentsException e) {
                 System.out.println(e.getMessage());
             }
diff --git a/src/main/java/UI/ConsoleInput.java b/src/main/java/UI/ConsoleInput.java
@@ -8,13 +8,19 @@ public class ConsoleInput {
     private String[] args;
 
     public ConsoleInput(String input) throws InvalidInputException {
-        if (input == null) {
+        String trimmedInput = input.trim();
+
+        if (trimmedInput == null || trimmedInput.equals("")) {
             throw new InvalidInputException("ERROR: Invalid input!");
         }
 
-        String[] array = input.split("\\s+");
-        command = array[0];
-        args = Arrays.copyOfRange(array, 1, array.length);
+        String[] array = trimmedInput.split("\\s+");
+        if (array.length > 0) {
+            command = array[0];
+            args = Arrays.copyOfRange(array, 1, array.length);
+        } else {
+            throw new InvalidInputException("ERROR: Invalid input!");
+        }
     }
 
     public String getCommand() {
diff --git a/src/test/java/BLL/AccountRepositoryTest.java b/src/test/java/BLL/AccountRepositoryTest.java
@@ -0,0 +1,92 @@
+package BLL;
+
+import BLL.Exceptions.PasswordTooWeakException;
+import BLL.Exceptions.UsernameAlreadyExistsException;
+import BLL.Exceptions.UsernameTooShortException;
+import Models.Account;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class AccountRepositoryTest {
+
+    private AccountRepository repo;
+
+    @BeforeEach
+    public void initialize() {
+        repo = new AccountRepository();
+
+        try {
+            repo.register("abcdef", "1234567890");
+        } catch (UsernameAlreadyExistsException | UsernameTooShortException | PasswordTooWeakException e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    void loginWithKnownUserAndCorrectPassword() {
+        boolean result = repo.login("abcdef", "1234567890");
+        assertTrue(result);
+    }
+
+    @Test
+    void loginWithKnownUserAndWrongPassword() {
+        boolean result = repo.login("abcdef", "9876543210");
+        assertFalse(result);
+    }
+
+    @Test
+    void loginWithUnknownUser() {
+        boolean result = repo.login("username", "password");
+        assertFalse(result);
+    }
+
+    @Test
+    void registerNewUser() throws PasswordTooWeakException, UsernameTooShortException, UsernameAlreadyExistsException {
+        boolean result = repo.register("fedcba", "9876543210");
+        assertTrue(result);
+    }
+
+    @Test
+    void registerNewUserThatAlreadyExists() throws PasswordTooWeakException, UsernameTooShortException {
+        try {
+            repo.register("abcdef", "password");
+            fail("UsernameAlreadyExistsException expected but not thrown");
+        } catch (UsernameAlreadyExistsException e) {
+            // pass
+        }
+    }
+
+    @Test
+    void registerNewUserWithWeakPassword() throws UsernameAlreadyExistsException, UsernameTooShortException {
+        try {
+            repo.register("fedcba", "pwd");
+            fail("PasswordTooWeakException expected but not thrown");
+        } catch (PasswordTooWeakException e) {
+            // pass
+        }
+    }
+
+    @Test
+    void registerNewUserWitShortUsername() throws PasswordTooWeakException, UsernameAlreadyExistsException {
+        try {
+            repo.register("fail", "9876543210");
+            fail("UsernameTooShortException expected but not thrown");
+        } catch (UsernameTooShortException e) {
+            // pass
+        }
+    }
+
+    @Test
+    void registerTwoUsersAndLoginTwice() throws PasswordTooWeakException, UsernameAlreadyExistsException, UsernameTooShortException {
+        repo.register("qwerty", "1234567890");
+        repo.register("asdfgh", "1234567890");
+
+        boolean result1 = repo.login("qwerty", "1234567890");
+        boolean result2 = repo.login("asdfgh", "1234567890");
+
+        assertTrue(result1);
+        assertTrue(result2);
+    }
+}
diff --git a/src/test/java/BLL/Encryption/EncrypterFactoryTest.java b/src/test/java/BLL/Encryption/EncrypterFactoryTest.java
@@ -0,0 +1,33 @@
+package BLL.Encryption;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Type;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class EncrypterFactoryTest {
+
+    class Enc {
+        EncryptionAlgorithm ea;
+        Class type;
+        public Enc(EncryptionAlgorithm ea, Class type) { this.ea = ea; this.type = type; }
+        public EncryptionAlgorithm getEncryptionAlgoritm() { return ea; }
+        public Class getType() { return type;}
+    }
+
+    EncrypterFactory encrypterFactory;
+    Enc[] encs = {
+            new Enc(EncryptionAlgorithm.SHA2, Sha2Encrypter.class),
+            new Enc(EncryptionAlgorithm.Simple, SimpleEncrypter.class)
+    };
+
+    @Test
+    void getEncrypters() {
+        for (Enc e: encs) {
+            PasswordEncrypter passwordEncrypter = encrypterFactory.getEncrypter(e.getEncryptionAlgoritm());
+            assertTrue(e.getType().isInstance(passwordEncrypter));
+        }
+    }
+}
diff --git a/src/test/java/BLL/Encryption/EncrypterTest.java b/src/test/java/BLL/Encryption/EncrypterTest.java
diff --git a/src/test/java/BLL/Encryption/SaltTest.java b/src/test/java/BLL/Encryption/SaltTest.java
diff --git a/src/test/java/DAL/AccountMemoryContextTest.java b/src/test/java/DAL/AccountMemoryContextTest.java
diff --git a/src/test/java/Models/AccountTest.java b/src/test/java/Models/AccountTest.java
diff --git a/src/test/java/UI/ConsoleInputTest.java b/src/test/java/UI/ConsoleInputTest.java

-Original file line number
+Diff line change
@@ @@ -1,3 +1,6 @@ @@
 +# IntelliJ
 +.idea
++
 # Compiled class file
 *.class
Original file line number	Diff line number	Diff line change
`@@ -16,21 +16,23 @@ public class AccountRepository {`
`16`	`16`	`PasswordEncrypter encrypter;`
`17`	`17`
`18`	`18`	`public AccountRepository() {`
`19`		`- encrypter = EncrypterFactory.getEncrypter(EncryptionAlgorithms.SHA2);`
	`19`	`+ encrypter = EncrypterFactory.getEncrypter(EncryptionAlgorithm.SHA2);`
`20`	`20`	`}`
`21`	`21`
`22`		`- public void login(String username, String passwordString) {`
	`22`	`+ public boolean login(String username, String passwordString) {`
`23`	`23`	`byte[] salt = context.getSaltByUsername(username);`
`24`	`24`	`Password password = encrypter.encrypt(passwordString, salt);`
`25`	`25`
`26`	`26`	`if (context.login(username, password)) {`
`27`	`27`	`System.out.println("Login successful!");`
	`28`	`+ return true;`
`28`	`29`	`} else {`
`29`	`30`	`System.out.println("Login unsuccessful :(");`
	`31`	`+ return false;`
`30`	`32`	`}`
`31`	`33`	`}`
`32`	`34`
`33`		`- public void register(String username, String passwordString) throws UsernameAlreadyExistsException, UsernameTooShortException, PasswordTooWeakException {`
	`35`	`+ public boolean register(String username, String passwordString) throws UsernameAlreadyExistsException, UsernameTooShortException, PasswordTooWeakException {`
`34`	`36`	`if (usernameAlreadyExists(username)) {`
`35`	`37`	`throw new UsernameAlreadyExistsException("ERROR: This username is already taken!");`
`36`	`38`	`}`
`@@ -46,8 +48,10 @@ public void register(String username, String passwordString) throws UsernameAlre`
`46`	`48`
`47`	`49`	`if (context.register(username, password)) {`
`48`	`50`	`System.out.println("Account successfully registered!");`
	`51`	`+ return true;`
`49`	`52`	`} else {`
`50`	`53`	`System.out.println("Account was not registered :(");`
	`54`	`+ return false;`
`51`	`55`	`}`
`52`	`56`	`}`
`53`	`57`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`package BLL.Encryption;`
`2`	`2`
`3`		`-public enum EncryptionAlgorithms {`
	`3`	`+public enum EncryptionAlgorithm {`
`4`	`4`	`Simple,`
`5`	`5`	`SHA2`
`6`	`6`	`}`