From e27af540d4103909b780ecba32486e958a45b47d Mon Sep 17 00:00:00 2001 From: Nik Zaugg Date: Wed, 13 Mar 2019 14:56:53 +0100 Subject: [PATCH 1/5] create Test Class for ConfirmEmailDataTest IQSS#5634 --- .../confirmemail/ConfirmEmailDataTest.java | 66 +++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 src/test/java/edu/harvard/iq/dataverse/confirmemail/ConfirmEmailDataTest.java diff --git a/src/test/java/edu/harvard/iq/dataverse/confirmemail/ConfirmEmailDataTest.java b/src/test/java/edu/harvard/iq/dataverse/confirmemail/ConfirmEmailDataTest.java new file mode 100644 index 00000000000..45c4162188a --- /dev/null +++ b/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()); + } + +} From 4995045231a60b94b573c9ccaaa65c8a195577ca Mon Sep 17 00:00:00 2001 From: Nik Zaugg Date: Wed, 13 Mar 2019 19:00:04 +0100 Subject: [PATCH 2/5] create Test Class for MyDataUtil IQSS#5634 --- .../iq/dataverse/mydata/MyDataUtilTest.java | 74 +++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 src/test/java/edu/harvard/iq/dataverse/mydata/MyDataUtilTest.java diff --git a/src/test/java/edu/harvard/iq/dataverse/mydata/MyDataUtilTest.java b/src/test/java/edu/harvard/iq/dataverse/mydata/MyDataUtilTest.java new file mode 100644 index 00000000000..3430e6302df --- /dev/null +++ b/src/test/java/edu/harvard/iq/dataverse/mydata/MyDataUtilTest.java @@ -0,0 +1,74 @@ +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; + +@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)); + } + +} \ No newline at end of file From 93801d0e7d6ae95fa8d903f24dac02913ba50b15 Mon Sep 17 00:00:00 2001 From: Nik Zaugg Date: Thu, 14 Mar 2019 10:05:55 +0100 Subject: [PATCH 3/5] create Test class for PasswordValidator in edu.harvard.iq.dataverse.passwordreset IQSS#5634 --- .../passwordreset/PasswordValidatorTest.java | 75 +++++++++++++++++++ 1 file changed, 75 insertions(+) create mode 100644 src/test/java/edu/harvard/iq/dataverse/passwordreset/PasswordValidatorTest.java diff --git a/src/test/java/edu/harvard/iq/dataverse/passwordreset/PasswordValidatorTest.java b/src/test/java/edu/harvard/iq/dataverse/passwordreset/PasswordValidatorTest.java new file mode 100644 index 00000000000..ea6cbb8807d --- /dev/null +++ b/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 minLenght; + public int maxLenght; + + public PasswordValidatorTest(String password, boolean expected, boolean mustContainSpecialCharacters, + boolean mustContainCapitalLetters, boolean mustContainNumbers, int minLenght, int maxLenght) { + this.password = password; + this.expected = expected; + this.mustContainSpecialCharacters = mustContainSpecialCharacters; + this.mustContainCapitalLetters = mustContainCapitalLetters; + this.mustContainNumbers = mustContainNumbers; + this.minLenght = minLenght; + this.maxLenght = maxLenght; + } + + @Parameters + public static Collection 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, minLenght, maxLenght); + boolean isValidPassword = validator.validatePassword(password); + assertEquals(expected, isValidPassword); + } +} From 50c4c7891ef9b77b777e226a730957934ecb7963 Mon Sep 17 00:00:00 2001 From: Nik Zaugg Date: Thu, 14 Mar 2019 10:30:37 +0100 Subject: [PATCH 4/5] fix typo in PasswordValidatorTest IQSS#5634 --- .../passwordreset/PasswordValidatorTest.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/test/java/edu/harvard/iq/dataverse/passwordreset/PasswordValidatorTest.java b/src/test/java/edu/harvard/iq/dataverse/passwordreset/PasswordValidatorTest.java index ea6cbb8807d..f6d02e35ddf 100644 --- a/src/test/java/edu/harvard/iq/dataverse/passwordreset/PasswordValidatorTest.java +++ b/src/test/java/edu/harvard/iq/dataverse/passwordreset/PasswordValidatorTest.java @@ -18,18 +18,18 @@ public class PasswordValidatorTest { public boolean mustContainSpecialCharacters; public boolean mustContainCapitalLetters; public boolean mustContainNumbers; - public int minLenght; - public int maxLenght; + public int minLength; + public int maxLength; public PasswordValidatorTest(String password, boolean expected, boolean mustContainSpecialCharacters, - boolean mustContainCapitalLetters, boolean mustContainNumbers, int minLenght, int maxLenght) { + boolean mustContainCapitalLetters, boolean mustContainNumbers, int minLength, int maxLength) { this.password = password; this.expected = expected; this.mustContainSpecialCharacters = mustContainSpecialCharacters; this.mustContainCapitalLetters = mustContainCapitalLetters; this.mustContainNumbers = mustContainNumbers; - this.minLenght = minLenght; - this.maxLenght = maxLenght; + this.minLength = minLength; + this.maxLength = maxLength; } @Parameters @@ -68,7 +68,7 @@ public static Collection parameters() { @Test public void testValidatePassword() { PasswordValidator validator = PasswordValidator.buildValidator(mustContainSpecialCharacters, - mustContainCapitalLetters, mustContainNumbers, minLenght, maxLenght); + mustContainCapitalLetters, mustContainNumbers, minLength, maxLength); boolean isValidPassword = validator.validatePassword(password); assertEquals(expected, isValidPassword); } From 31f0d38fcd394686e7bf202ee4f7dcbe405bcc54 Mon Sep 17 00:00:00 2001 From: Nik Zaugg Date: Sun, 17 Mar 2019 09:58:19 +0100 Subject: [PATCH 5/5] added a comment about JUnit Theories IQSS#5634 --- .../iq/dataverse/mydata/MyDataUtilTest.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/test/java/edu/harvard/iq/dataverse/mydata/MyDataUtilTest.java b/src/test/java/edu/harvard/iq/dataverse/mydata/MyDataUtilTest.java index 3430e6302df..69996ce71fe 100644 --- a/src/test/java/edu/harvard/iq/dataverse/mydata/MyDataUtilTest.java +++ b/src/test/java/edu/harvard/iq/dataverse/mydata/MyDataUtilTest.java @@ -8,6 +8,20 @@ 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 {