Kitiya: TDD Kata 3 - Password Verifier

.gitignore

@@ -0,0 +1,2 @@
+.idea/
+out/

ComIT-Code-Review.iml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="module-library">
+      <library name="JUnit5.3">
+        <CLASSES>
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.5.1/junit-jupiter-api-5.5.1.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.0/apiguardian-api-1.1.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
+          <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-commons/1.5.1/junit-platform-commons-1.5.1.jar!/" />
+        </CLASSES>
+        <JAVADOC />
+        <SOURCES />
+      </library>
+    </orderEntry>
+  </component>
+</module>

README.md

@@ -1,7 +1,7 @@
 # ComIT-Code-Review
 
 TDD Kata 3
-Create a Password verifications class called “PasswordVerifier”.
+Create a Password verifications class called “main.PasswordVerifier”.
 Add the following verifications to a master function called “Verify()”
 
 - password should be larger than 8 chars

src/main/PasswordVerifier.java

@@ -0,0 +1,110 @@
+package main;
+
+import java.util.regex.Pattern;
+
+public class PasswordVerifier {
+
+    public PasswordVerifier() {
+
+    }
+
+    public boolean verify(String password) {
+        int numValid = 0;
+
+        // password is never OK if item 1.4 (password should have one lowercase letter at least) is not true.
+        try {
+            if (containsLowercase(password)) numValid++;
+        } catch (IllegalArgumentException e) {
+            System.out.println(e);
+            return false;
+        }
+
+        try {
+            if (isNotNull(password)) numValid++;
+        } catch (IllegalArgumentException e) {
+            System.out.println(e);
+        }
+
+        try {
+            if (isLargerThanEight(password)) numValid++;
+        } catch (IllegalArgumentException e) {
+            System.out.println(e);
+        }
+
+        if (numValid >= 3) return true; // for optimization
+
+        try {
+            if (containsUppercase(password)) numValid ++;
+        } catch (IllegalArgumentException e) {
+            System.out.println(e);
+        }
+
+        if (numValid >= 3) return true; // for optimization
+
+        try {
+            if (containsDigit(password)) numValid ++;
+        } catch (IllegalArgumentException e) {
+            System.out.println(e);
+        }
+
+        return numValid >= 3;
+
+        /*
+            Optimization:
+            - The containsLowercase() function is executed first.
+              If a password doesn't contain lowercase, we can return false and skip the other validations.
+
+            - Returns true whenever the value of numValid is three.
+              The if statements are added after the function#3 and #4 are executed.
+
+         */
+    }
+
+    public boolean isLargerThanEight(String password) throws IllegalArgumentException {
+        Boolean isValidPassword = (password != null) && (password.length() > 8);
+
+        if (!isValidPassword)
+            throw new IllegalArgumentException("Password length has to be greater than 8.");
+
+        return true;
+    }
+
+    public boolean isNotNull(String password) throws IllegalArgumentException {
+        Boolean isValidPassword = (password != null);
+
+        if (!isValidPassword)
+            throw new IllegalArgumentException("Password cannot be blank.");
+
+        return true;
+    }
+
+    public boolean containsUppercase(String password) throws IllegalArgumentException {
+        Pattern uppercasePattern = Pattern.compile("^(?=.*[A-Z]).+$");
+        Boolean isValidPassword = (password != null) && uppercasePattern.matcher(password).matches();
+
+        if (!isValidPassword)
+            throw new IllegalArgumentException("Password should have at least one uppercase letter.");
+
+        return true;
+    }
+
+    public boolean containsLowercase(String password) throws IllegalArgumentException {
+        Pattern lowercasePattern = Pattern.compile("^(?=.*[a-z]).+$");
+        Boolean isValidPassword = (password != null) && lowercasePattern.matcher(password).matches();
+
+        if (!isValidPassword)
+            throw new IllegalArgumentException("Password should have at least one lowercase letter.");
+
+        return true;
+    }
+
+    public boolean containsDigit(String password) throws IllegalArgumentException {
+        Pattern digitPattern = Pattern.compile("^(?=.*\\d).+$");
+        Boolean isValidPassword = (password != null) && digitPattern.matcher(password).matches();
+
+        if (!isValidPassword)
+            throw new IllegalArgumentException("Password should contain at least one number.");
+
+        return true;
+    }
+}

src/test/PasswordVerifierTest.java

@@ -0,0 +1,107 @@
+package test;
+
+import main.PasswordVerifier;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class PasswordVerifierTest {
+    private PasswordVerifier tester = new PasswordVerifier();
+
+    @Test
+    void verify() {
+        assertEquals(true, tester.verify("7ShiftComIT"));   // not null, upper, lower, digit, >8
+        assertEquals(true, tester.verify("7Shift"));        // not null, upper, lower, digit
+        assertEquals(true, tester.verify("Shift"));         // not null, upper, lower
+        assertEquals(false, tester.verify("SHIFT"));        // not null, upper
+        assertEquals(false, tester.verify("7SHIFTCOMIT"));  // not null, upper, digit, >8, ** no lowercase **
+        assertEquals(false, tester.verify(null));
+    }
+
+    @Test
+    void isLargerThanEight() {
+        assertEquals(true,tester.isLargerThanEight("abcd56789"));
+        assertEquals(true,tester.isLargerThanEight("1234567890"));
+    }
+
+    @Test
+    void isLargerThanEightShouldThrowIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class,
+                () -> {
+                    tester.isLargerThanEight("abc");
+                    tester.isLargerThanEight("abcd5678");
+                    tester.isLargerThanEight(null);
+                });
+    }
+
+    @Test
+    void isNotNull() {
+        assertEquals(true, tester.isNotNull("abc"));
+        assertEquals(true, tester.isNotNull(""));
+        assertEquals(true, tester.isNotNull("null"));
+    }
+
+    @Test
+    void isNotNullShouldThrowIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class,
+                () -> {
+                    tester.isNotNull(null);
+                });
+    }
+
+    @Test
+    void containsUppercase() {
+        assertEquals(true, tester.containsUppercase("7Shift"));
+        assertEquals(true, tester.containsUppercase("7shifT"));
+        assertEquals(true, tester.containsUppercase("Shift7"));
+    }
+
+    @Test
+    void containsUppercaseShouldThrowIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class,
+                () -> {
+                    tester.containsUppercase("7shift");
+                    tester.containsUppercase("7777777");
+                    tester.containsUppercase("");
+                    tester.isLargerThanEight(null);
+                });
+    }
+
+    @Test
+    void containsLowercase() {
+        assertEquals(true, tester.containsLowercase("7Shift"));
+        assertEquals(true, tester.containsLowercase("7shifT"));
+        assertEquals(true, tester.containsLowercase("Shift7"));
+    }
+
+    @Test
+    void containsLowercaseShouldThrowIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class,
+                () -> {
+                    tester.containsLowercase("7SHIFT");
+                    tester.containsLowercase("7777777");
+                    tester.containsLowercase("");
+                    tester.isLargerThanEight(null);
+                });
+    }
+
+    @Test
+    void containsDigit() {
+        assertEquals(true, tester.containsDigit("7Shift"));
+        assertEquals(true, tester.containsDigit("7shifT"));
+        assertEquals(true, tester.containsDigit("Shift7"));
+        assertEquals(true, tester.containsDigit("7777777"));
+    }
+
+    @Test
+    void containsDigitShouldThrowIllegalArgumentException() {
+        assertThrows(IllegalArgumentException.class,
+                () -> {
+                    tester.containsDigit("SevenShift");
+                    tester.containsDigit("");
+                    tester.isLargerThanEight(null);
+                });
+
+    }
+}