5634 new unit tests

src/test/java/edu/harvard/iq/dataverse/confirmemail/ConfirmEmailDataTest.java

@@ -0,0 +1,66 @@
+package edu.harvard.iq.dataverse.confirmemail;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import edu.harvard.iq.dataverse.authorization.users.AuthenticatedUser;
+
+public class ConfirmEmailDataTest {
+
+    private ConfirmEmailData instance;
+    private AuthenticatedUser user;
+
+    @Before
+    public void setUp() {
+        this.user = new AuthenticatedUser();
+        this.instance = new ConfirmEmailData(user, 60);
+    }
+
+    @After
+    public void tearDown() {
+        this.instance = null;
+        this.user = null;
+    }
+
+    @Test
+    public void testConfirmEmailDataNotNull() {
+        assertTrue(instance != null);
+    }
+
+    @Test
+    public void testTokenNotNull() {
+        assertTrue(instance.getToken() != null);
+    }
+
+    @Test
+    public void testTokenCreationTimestampNotNull () {
+        assertTrue(instance.getCreated() != null);
+    }
+
+    @Test
+    public void testTokenExpirationTimestampNotNull () {
+        assertTrue(instance.getExpires() != null);
+    }
+
+    @Test
+    public void testTokenNotExpired() {
+        assertFalse(instance.isExpired());
+    }
+
+    @Test
+    public void testAuthenticatedUserAssigned() {
+        assertTrue(user == instance.getAuthenticatedUser());
+    }
+
+    @Test
+    public void testIdAssigned() {
+        long id = 42;
+        instance.setId(id);
+        assertTrue(42 == instance.getId());
+    }
+
+}

src/test/java/edu/harvard/iq/dataverse/mydata/MyDataUtilTest.java

@@ -0,0 +1,88 @@
+package edu.harvard.iq.dataverse.mydata;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+import org.junit.experimental.theories.DataPoints;
+import org.junit.experimental.theories.Theories;
+import org.junit.experimental.theories.Theory;
+import org.junit.runner.RunWith;
+
+/**
+ * Theories allows to add more formal tests to our code. In a way JUnit Theories behave 
+ * much like mathematical theories that hold for every element of a large (infinite) set. 
+ * JUnit will combine every possible combination (cartesian product) of datapoints and 
+ * pass these to the tests annotated with @Theory. The assume statements make sure, only 
+ * valid datapoints are tested in each Theory.
+ * 
+ * @Datapoints - defines an array of values to test on
+ * @Datapoint - stores one single value
+ * 
+ * JUnit will no longer maintain a JUnit 4 Theories equivalent in the JUnit 5 codebase, as 
+ * mentioned in a discussion here: https://github.com/junit-team/junit5/pull/1422#issuecomment-389644868
+ */
+
+@RunWith(Theories.class)
+public class MyDataUtilTest {
+
+    @DataPoints
+    public static String[] userIdentifier = { 
+        "@nzaugg", "nzaugg@", "nzaugg", "123nzaugg", "", " ", null, "@",  "n" };
+
+    @Theory
+    public void testFormatUserIdentifierAsAssigneeIdentifierNull(String userIdentifier) {
+        assumeTrue(userIdentifier == null);
+        String formattedUserIdentifier = MyDataUtil.formatUserIdentifierAsAssigneeIdentifier(userIdentifier);
+        assertTrue(formattedUserIdentifier ==  null);
+    }
+
+    @Theory
+    public void testFormatUserIdentifierAsAssigneeIdentifierOneCharString(String userIdentifier) {
+        assumeTrue(userIdentifier != null);
+        assumeTrue(userIdentifier.startsWith("@"));
+        String formattedUserIdentifier = MyDataUtil.formatUserIdentifierAsAssigneeIdentifier(userIdentifier);
+        assertTrue(formattedUserIdentifier.equals(userIdentifier));
+    }
+
+    @Theory
+    public void testFormatUserIdentifierAsAssigneeIdentifier(String userIdentifier) {
+        assumeTrue(userIdentifier != null);
+        assumeTrue(!userIdentifier.startsWith("@"));
+        String formattedUserIdentifier = MyDataUtil.formatUserIdentifierAsAssigneeIdentifier(userIdentifier);
+        assertTrue(formattedUserIdentifier.equals("@" + userIdentifier));
+    }
+
+    @Theory
+    public void testFormatUserIdentifierForMyDataFormNull(String userIdentifier) {
+        assumeTrue(userIdentifier == null);
+        String formattedUserIdentifier = MyDataUtil.formatUserIdentifierForMyDataForm(userIdentifier);
+        assertTrue(formattedUserIdentifier ==  null);
+    }
+
+    @Theory
+    public void testFormatUserIdentifierForMyDataFormOneCharString(String userIdentifier) {
+        assumeTrue(userIdentifier != null);
+        assumeTrue(userIdentifier.startsWith("@"));
+        assumeTrue(userIdentifier.length() == 1);
+        String formattedUserIdentifier = MyDataUtil.formatUserIdentifierForMyDataForm(userIdentifier);
+        assertTrue(formattedUserIdentifier ==  null);
+    }
+
+    @Theory
+    public void testFormatUserIdentifierForMyDataFormLongerString(String userIdentifier) {
+        assumeTrue(userIdentifier != null);
+        assumeTrue(userIdentifier.startsWith("@"));
+        assumeTrue(userIdentifier.length() > 1);
+        String formattedUserIdentifier = MyDataUtil.formatUserIdentifierForMyDataForm(userIdentifier);
+        assertTrue(formattedUserIdentifier.equals(userIdentifier.substring(1)));
+    }
+
+    @Theory
+    public void testFormatUserIdentifierForMyDataForm(String userIdentifier) {
+        assumeTrue(userIdentifier != null);
+        assumeTrue(!userIdentifier.startsWith("@"));
+        String formattedUserIdentifier = MyDataUtil.formatUserIdentifierForMyDataForm(userIdentifier);
+        assertTrue(formattedUserIdentifier.equals(userIdentifier));
+    }
+
+}

src/test/java/edu/harvard/iq/dataverse/passwordreset/PasswordValidatorTest.java

@@ -0,0 +1,75 @@
+package edu.harvard.iq.dataverse.passwordreset;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class PasswordValidatorTest {
+
+    public String password;
+    public boolean expected;
+    public boolean mustContainSpecialCharacters;
+    public boolean mustContainCapitalLetters;
+    public boolean mustContainNumbers;
+    public int minLength;
+    public int maxLength;
+
+    public PasswordValidatorTest(String password, boolean expected, boolean mustContainSpecialCharacters,
+            boolean mustContainCapitalLetters, boolean mustContainNumbers, int minLength, int maxLength) {
+        this.password = password;
+        this.expected = expected;
+        this.mustContainSpecialCharacters = mustContainSpecialCharacters;
+        this.mustContainCapitalLetters = mustContainCapitalLetters;
+        this.mustContainNumbers = mustContainNumbers;
+        this.minLength = minLength;
+        this.maxLength = maxLength;
+    }
+
+    @Parameters
+    public static Collection<Object[]> parameters() {
+        return Arrays.asList(
+             new Object[][] {
+                // Check if PasswordValidator correctly validates correct passwords
+                // with all combinations of Special Characters,
+                // Capital Letters and Numbers
+                {"abcdefghabcdefgh", true, false, false, false, 8, 30},    
+                {"@bcdefgh@bcdefgh", true, true, false, false, 8, 30},      
+                {"@bAdefgh@bAdefgh", true, true, true, false, 8, 30},      
+                {"abAdefghabAdefgh", true, false, true, false, 8, 30},     
+                {"a1Adefgha1Adefgh", true, false, true, true, 8, 30},      
+                {"ab1defghab1defgh", true, false, false, true, 8, 30},     
+                {"@1cdefgh@1cdefgh", true, true, false, true, 8, 30},      
+                {"@1Adefgh@1Adefgh", true, true, true, true, 8, 30},      
+                // Check if PasswordValidator correctly rejects wrong passwords
+                // with all combinations of Special Characters,
+                // Capital Letters and Numbers
+                {"abcabc", false, false, false, false, 8, 30},
+                {"abcdabcd", false, true, false, false, 8, 30},       
+                {"@bcd@bcd", false, true, true, false, 8, 30},       
+                {"@bc1@bc1", false, false, true, false, 8, 30},      
+                {"a1cda1cd", false, false, true, true, 8, 30},       
+                {"AbcdAbcd", false, false, false, true, 8, 30},      
+                {"@Bcd@Bcd", false, true, false, true, 8, 30},       
+                {"a1Ada1Ad", false, true, true, true, 8, 30},
+                {"", false, false, false, false, 1, 30},
+                {" ", false, false, false, false, 1, 30},
+                {"?!abcdef", false, true, false, false, 8, 30}
+             }
+        );
+    }
+
+    @Test
+    public void testValidatePassword() {
+        PasswordValidator validator = PasswordValidator.buildValidator(mustContainSpecialCharacters,
+                mustContainCapitalLetters, mustContainNumbers, minLength, maxLength);
+        boolean isValidPassword = validator.validatePassword(password);
+        assertEquals(expected, isValidPassword);
+    }
+}