Merge remote-tracking branch 'origin/feature-credential' into feature-credential

Implements and tests function to delete entries

@TODO: catch index left-shift after deleting an item

src/main/java/Vault.java

@@ -0,0 +1,171 @@
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Scanner;
+
+public class Vault implements VaultInterface {
+
+    public boolean config;
+    public int PWLength;
+    public boolean haveCapitals;
+    public boolean hasSpecialChars;
+    public boolean hasNumbers;
+    public boolean credentialM;
+    public String userName;
+    public String password;
+    public boolean isInt = false;
+    InputStream inputS = System.in;
+    OutputStream outputS = System.out;
+
+    private void println(String output) {
+        try {
+            outputS.write((output + "\n").getBytes(StandardCharsets.UTF_8));
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void configure(){
+        StringBuilder sbcm = new StringBuilder();
+        Scanner scan = new Scanner(inputS);
+        config = true;
+
+        sbcm.append("Configure:\n");
+        sbcm.append("- Password length: l\n");
+        sbcm.append("- Have capitals: h\n");
+        sbcm.append("- Have special characters: s\n");
+        sbcm.append("- Have Numbers: n\n");
+        sbcm.append("- exit: e\n");
+
+        println(sbcm.toString());
+
+        String input = scan.nextLine();
+
+        if (input.equals("e")) {
+            config = false;
+        } else if (input.equals("l")) {
+            println("Set PW length:");
+            String inputPw = scan.nextLine();
+            setPWLength(inputPw);
+        } else if (input.equals("h")) {
+            println("Should your PW have capitals? Type in yes or no.");
+            String inputC = scan.nextLine();
+            setCapital(inputC);
+        } else if (input.equals("s")){
+            println("Should you PW have special characters? Type in yes or no.");
+            String inputS = scan.nextLine();
+            setSpecialChar(inputS);
+        } else if (input.equals("n")) {
+            println("Should you PW have numbers? Type in yes or no.");
+            String inputN = scan.nextLine();
+            setNumbers(inputN);
+        }
+    }
+
+    public void setPWLength(String pwLength){
+        try {
+            PWLength = Integer.parseInt(pwLength);
+        } catch (NumberFormatException e) {
+            println("Please enter valid number.");
+        }
+
+        println("\nNew password length is now: ");
+    }
+
+
+    public void addCredential(){
+        Scanner scan = new Scanner(inputS);
+        println("Type in username");
+        userName = scan.nextLine();
+
+        println("Type in password");
+        password = scan.nextLine();
+        //createNewCredential(userName, password);
+
+    }
+
+    public void showCredential(){
+        Scanner scan = new Scanner(inputS);
+        println("Type in ID or username");
+
+        String str = scan.nextLine();
+
+        if(str.matches("[0-9]+")) {
+            isInt = true;
+            //getCredentialsViaId(Integer.parseInt(str));
+        } else {
+            isInt = false;
+            //getCredentialsViaName(str);
+        }
+
+    }
+
+    public void getAsJson(){
+
+    }
+
+    public void loadFromJson(){
+
+    }
+
+    public void setCapital(String input) {
+
+        if(input.equals("yes")){
+            haveCapitals = true;
+            println("Your PWs contain now capitals.");
+        }else if(input.equals("no")){
+            haveCapitals = false;
+            println("Your PWs don´t have capitals anymore.");
+        }
+    }
+
+
+    public void setSpecialChar(String input) {
+
+        if(input.equals("yes")){
+            hasSpecialChars = true;
+            println("Your PWs contain now special characters.");
+        }else if(input.equals("no")){
+            hasSpecialChars = false;
+            println("Your PWs don´t have special characters anymore.");
+        }
+    }
+
+    public void setNumbers(String input) {
+
+        if(input.equals("yes")){
+            hasNumbers = true;
+            println("Your PWs contains now numbers.");
+        }else if(input.equals("no")){
+            hasNumbers = false;
+            println("Your PWs don´t have numbers anymore.");
+        }
+    }
+
+    public void credentialMenu() {
+        StringBuilder sbcm = new StringBuilder();
+        Scanner scan = new Scanner(inputS);
+        credentialM = true;
+
+        sbcm.append("Configure credentials:\n");
+        sbcm.append("- add credential: a\n");
+        sbcm.append("- show credential: c\n");
+        sbcm.append("- edit credential: l\n");
+        sbcm.append("- exit: e\n");
+
+        println(sbcm.toString());
+
+        String input = scan.nextLine();
+
+        if (input.equals("e")) {
+            credentialM = false;
+        } else if (input.equals("a")) {
+            println("Type username:");
+        } else if (input.equals("c")) {
+            println("Type username or ID to show credential:");
+        } else if (input.equals("l")) {
+            println("Type username or ID to select credential:");
+        }
+    }
+}

src/main/java/VaultInterface.java

@@ -0,0 +1,10 @@
+
+
+public interface VaultInterface {
+
+    void configure();
+    void addCredential();
+    void showCredential();
+    void getAsJson();
+    void loadFromJson();
+}

src/test/java/PasswordManagerTest.java

@@ -55,7 +55,7 @@ class PasswordManagerTest {
         pm.inputStream = new ByteArrayInputStream("v 0\n".getBytes(StandardCharsets.UTF_8));
         pm.outputStream = outputStream;
         pm.showMenu();
-        assertTrue(outputStream.toString().endsWith("-- vaults not implemented yet\n"));
+        assertFalse(outputStream.toString().endsWith("-- vaults not implemented yet\n"));
     }
 
     @Test

src/test/java/VaultTest.java

@@ -0,0 +1,238 @@
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.NoSuchElementException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class VaultTest {
+
+    //Vault vlt = new Vault();
+
+    static Vault vlt;
+
+    @BeforeAll
+    static void init() {
+        vlt = new Vault();
+    }
+
+    @BeforeEach
+    void reset() {
+        vlt.outputS = System.out;
+        vlt.inputS = System.in;
+    }
+
+    @Test
+    void openCredentialMenu() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.inputS = new ByteArrayInputStream("__\n".getBytes(StandardCharsets.UTF_8));
+        vlt.outputS = outputStream;
+        vlt.credentialMenu();
+        assertTrue(vlt.credentialM);
+        assertTrue(outputStream.toString().startsWith("Configure"));
+    }
+
+    @Test
+    void exitConfigureMenu(){
+        vlt.inputS = new ByteArrayInputStream("e".getBytes(StandardCharsets.UTF_8));
+        vlt.credentialMenu();
+        assertFalse(vlt.credentialM);
+    }
+
+    @Test
+    void openAddCredentialMenuItem() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.inputS = new ByteArrayInputStream("a".getBytes(StandardCharsets.UTF_8));
+        vlt.outputS = outputStream;
+        vlt.credentialMenu();
+        assertTrue(outputStream.toString().contains("Type"));
+    }
+
+    @Test
+    void openShowCredentialMenuItem() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.inputS = new ByteArrayInputStream("c".getBytes(StandardCharsets.UTF_8));
+        vlt.outputS = outputStream;
+        vlt.credentialMenu();
+        assertTrue(outputStream.toString().contains("Type"));
+    }
+
+    @Test
+    void openEditCredentialMenuItem() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.inputS = new ByteArrayInputStream("l".getBytes(StandardCharsets.UTF_8));
+        vlt.outputS = outputStream;
+        vlt.credentialMenu();
+        assertTrue(outputStream.toString().contains("Type"));
+    }
+
+    @Test
+    void addCredentialTest() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.outputS = outputStream;
+        vlt.inputS = new ByteArrayInputStream("peter\npassword".getBytes(StandardCharsets.UTF_8));
+        vlt.addCredential();
+
+        assertTrue(outputStream.toString().contains("username"));
+        assertEquals("peter", vlt.userName);
+        assertTrue(outputStream.toString().contains("password"));
+        assertEquals("password",vlt.password);
+    }
+
+    @Test
+    void showCredentialTest() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.outputS = outputStream;
+        vlt.inputS = new ByteArrayInputStream("1".getBytes(StandardCharsets.UTF_8));
+        vlt.showCredential();
+
+        assertTrue(outputStream.toString().contains("Type"));
+        assertTrue(vlt.isInt);
+
+        vlt.outputS = outputStream;
+        vlt.inputS = new ByteArrayInputStream("peter".getBytes(StandardCharsets.UTF_8));
+        vlt.showCredential();
+
+        assertTrue(outputStream.toString().contains("Type"));
+        assertFalse(vlt.isInt);
+    }
+
+    @Test
+    void getAsJson() {vlt.getAsJson();}
+
+    @Test
+    void loadFromJson() {vlt.loadFromJson();}
+
+    @Test
+    void openConfigureMenu() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.inputS = new ByteArrayInputStream("__\n".getBytes(StandardCharsets.UTF_8));
+        vlt.outputS = outputStream;
+        vlt.configure();
+        assertTrue(outputStream.toString().startsWith("Configure:"));
+    }
+
+    @Test
+    void exitConfigurationMenu(){
+        vlt.inputS = new ByteArrayInputStream("e".getBytes(StandardCharsets.UTF_8));
+        vlt.configure();
+        assertFalse(vlt.config);
+    }
+
+    @Test
+    void doNotExitConfigAfterWrongInput() {
+        vlt.inputS = new ByteArrayInputStream("__\n".getBytes(StandardCharsets.UTF_8));
+        vlt.configure();
+        assertTrue(vlt.config);
+
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.inputS = getEmptyStringInputStream();
+        vlt.outputS = outputStream;
+
+        assertThrowsExactly(NoSuchElementException.class, () -> vlt.configure());
+        assertTrue(outputStream.toString().startsWith("Configure:"));
+    }
+
+    @Test
+    void openSetPWLengthMenuItem() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.inputS = new ByteArrayInputStream("l\n7".getBytes(StandardCharsets.UTF_8));
+        vlt.outputS = outputStream;
+        vlt.configure();
+        assertEquals(7, vlt.PWLength);
+        assertTrue(outputStream.toString().contains("Set"));
+    }
+
+    @Test
+    void setPWLength() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.outputS = outputStream;
+        vlt.setPWLength("7");
+
+        assertEquals(7, vlt.PWLength);
+        assertTrue(outputStream.toString().contains("now:"));
+    }
+
+    @Test
+    void openSetCapitalsMenuItem() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.inputS = new ByteArrayInputStream("h\nyes".getBytes(StandardCharsets.UTF_8));
+        vlt.outputS = outputStream;
+        vlt.configure();
+        assertTrue(vlt.haveCapitals = true);
+    }
+
+    @Test
+    void setCapitals() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.outputS = outputStream;
+        vlt.setCapital("yes");
+
+        assertTrue(vlt.haveCapitals = true);
+        assertTrue(outputStream.toString().contains("contain"));
+
+        vlt.outputS = outputStream;
+        vlt.setCapital("no");
+
+        assertFalse(vlt.haveCapitals = false);
+        assertTrue(outputStream.toString().contains("don´t"));
+    }
+
+    @Test
+    void openSetSpecialCharsMenuItem() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.inputS = new ByteArrayInputStream("h\nyes".getBytes(StandardCharsets.UTF_8));
+        vlt.outputS = outputStream;
+        vlt.configure();
+        assertTrue(vlt.hasSpecialChars = true);
+    }
+
+    @Test
+    void setSpecialCharTest() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.outputS = outputStream;
+        vlt.setSpecialChar("yes");
+
+        assertTrue(vlt.hasSpecialChars = true);
+
+        vlt.outputS = outputStream;
+        vlt.setSpecialChar("no");
+
+        assertFalse(vlt.hasSpecialChars = false);
+        assertTrue(outputStream.toString().contains("don´t"));
+    }
+
+    @Test
+    void openSetNumbersMenuItem() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.inputS = new ByteArrayInputStream("h\nyes".getBytes(StandardCharsets.UTF_8));
+        vlt.outputS = outputStream;
+        vlt.configure();
+        assertTrue(vlt.hasNumbers = true);
+    }
+
+    @Test
+    void setNumbersTest() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        vlt.outputS = outputStream;
+        vlt.setNumbers("yes");
+
+        assertTrue(vlt.hasNumbers = true);
+        assertTrue(outputStream.toString().contains("contain"));
+
+        vlt.outputS = outputStream;
+        vlt.setNumbers("no");
+
+        assertFalse(vlt.hasNumbers = false);
+        assertTrue(outputStream.toString().contains("don´t"));
+    }
+
+    private ByteArrayInputStream getEmptyStringInputStream() {
+        return new ByteArrayInputStream("".getBytes(StandardCharsets.UTF_8));
+    }
+}