diff --git a/src/test/java/org/tdl/vireo/model/ActionLogTest.java b/src/test/java/org/tdl/vireo/model/ActionLogTest.java new file mode 100644 index 000000000..95e809749 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/ActionLogTest.java @@ -0,0 +1,68 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.Calendar; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class ActionLogTest extends AbstractModelTest { + + @InjectMocks + private ActionLog actionLog; + + /** + * The getPrivate() does not work via getParameterStream() and is manually tested here. + * + * This may be because the method is called "isPrivateFlag()" rather than "getPrivateFlag()". + */ + @Test + public void testGetSettings() { + boolean value = false; + + ReflectionTestUtils.setField(actionLog, "privateFlag", value); + + assertEquals(value, actionLog.isPrivateFlag(), GETTER_MESSAGE); + } + + /** + * The privateFlag() does not work via setParameterStream() and is manually tested here. + */ + @Test + public void testSetSettings() { + boolean value = false; + + // Set the flag to something other than false to confirm setter works. + ReflectionTestUtils.setField(actionLog, "privateFlag", true); + + actionLog.setPrivateFlag(value); + + assertEquals(value, ReflectionTestUtils.getField(getInstance(), "privateFlag"), SETTER_MESSAGE); + } + + @Override + protected ActionLog getInstance() { + return actionLog; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("submissionStatus", new SubmissionStatus()), + Arguments.of("user", new User()), + Arguments.of("actionDate", Calendar.getInstance()), + Arguments.of("entry", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/AddressTest.java b/src/test/java/org/tdl/vireo/model/AddressTest.java new file mode 100644 index 000000000..bc75f82b9 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/AddressTest.java @@ -0,0 +1,36 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class AddressTest extends AbstractModelTest
{ + + @InjectMocks + private Address address; + + @Override + protected Address getInstance() { + return address; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("address1", "value"), + Arguments.of("address2", "value"), + Arguments.of("city", "value"), + Arguments.of("state", "value"), + Arguments.of("postalCode", "value"), + Arguments.of("country", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/ContactInfoTest.java b/src/test/java/org/tdl/vireo/model/ContactInfoTest.java new file mode 100644 index 000000000..0d25fe8d6 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/ContactInfoTest.java @@ -0,0 +1,33 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class ContactInfoTest extends AbstractModelTest { + + @InjectMocks + private ContactInfo contactInfo; + + @Override + protected ContactInfo getInstance() { + return contactInfo; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("address", new Address()), + Arguments.of("phone", "value"), + Arguments.of("email", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/ControlledVocabularyCacheTest.java b/src/test/java/org/tdl/vireo/model/ControlledVocabularyCacheTest.java new file mode 100644 index 000000000..b72836c48 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/ControlledVocabularyCacheTest.java @@ -0,0 +1,45 @@ +package org.tdl.vireo.model; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class ControlledVocabularyCacheTest extends AbstractModelTest { + + @InjectMocks + private ControlledVocabularyCache controlledVocabularyCache; + + @Override + protected ControlledVocabularyCache getInstance() { + return controlledVocabularyCache; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + List words = new ArrayList<>(); + words.add(new VocabularyWord()); + + List wordArrayList = new ArrayList<>(); + VocabularyWord[] wordsArray = { new VocabularyWord() }; + wordArrayList.add(wordsArray); + + return Stream.of( + Arguments.of("timestamp", 123L), + Arguments.of("controlledVocabularyName", "name"), + Arguments.of("newVocabularyWords", words), + Arguments.of("updatingVocabularyWords", wordArrayList), + Arguments.of("duplicateVocabularyWords", words), + Arguments.of("removedVocabularyWords", words) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/ControlledVocabularyTest.java b/src/test/java/org/tdl/vireo/model/ControlledVocabularyTest.java new file mode 100644 index 000000000..03eb9d593 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/ControlledVocabularyTest.java @@ -0,0 +1,42 @@ +package org.tdl.vireo.model; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class ControlledVocabularyTest extends AbstractModelTest { + + @InjectMocks + private ControlledVocabulary controlledVocabulary; + + @Override + protected ControlledVocabulary getInstance() { + return controlledVocabulary; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + List dictionary = new ArrayList<>(); + VocabularyWord vocabularyWord = new VocabularyWord(); + + vocabularyWord.setId(1L); + dictionary.add(vocabularyWord); + + return Stream.of( + Arguments.of("name", "value"), + //Arguments.of("dictionary", dictionary), // FIXME: This is failing on NPE. + Arguments.of("isEntityProperty", true), + Arguments.of("isEntityProperty", false) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/CustomActionDefinitionTest.java b/src/test/java/org/tdl/vireo/model/CustomActionDefinitionTest.java new file mode 100644 index 000000000..3ddb2750d --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/CustomActionDefinitionTest.java @@ -0,0 +1,33 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class CustomActionDefinitionTest extends AbstractModelTest { + + @InjectMocks + private CustomActionDefinition customActionDefinition; + + @Override + protected CustomActionDefinition getInstance() { + return customActionDefinition; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("label", "value"), + Arguments.of("isStudentVisible", true), + Arguments.of("isStudentVisible", false) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/CustomActionValueTest.java b/src/test/java/org/tdl/vireo/model/CustomActionValueTest.java new file mode 100644 index 000000000..85ad4063d --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/CustomActionValueTest.java @@ -0,0 +1,33 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class CustomActionValueTest extends AbstractModelTest { + + @InjectMocks + private CustomActionValue customActionValue; + + @Override + protected CustomActionValue getInstance() { + return customActionValue; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("definition", new CustomActionDefinition()), + Arguments.of("value", true), + Arguments.of("value", false) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/DefaultConfigurationTest.java b/src/test/java/org/tdl/vireo/model/DefaultConfigurationTest.java new file mode 100644 index 000000000..5975a22b4 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/DefaultConfigurationTest.java @@ -0,0 +1,34 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class DefaultConfigurationTest { + + // Warning: The tests fail here due to strange initialization problems and so an explicit assignment is provided. + @InjectMocks + private DefaultConfiguration defaultConfiguration = new DefaultConfiguration("a", "b", "c"); + + @ParameterizedTest + @MethodSource("provideGetterParameters") + public void testGetter(String property, Object value) { + ReflectionTestUtils.setField(defaultConfiguration, property, value); + + assertEquals(value, ReflectionTestUtils.invokeGetterMethod(defaultConfiguration, property), AbstractModelTest.GETTER_MESSAGE); + } + + private static Stream provideGetterParameters() { + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("value", "value"), + Arguments.of("type", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/DefaultPreferencesTest.java b/src/test/java/org/tdl/vireo/model/DefaultPreferencesTest.java new file mode 100644 index 000000000..47f373db9 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/DefaultPreferencesTest.java @@ -0,0 +1,53 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class DefaultPreferencesTest extends AbstractModelTest { + + @InjectMocks + private DefaultPreferences defaultPreferences; + + @Test + public void testDefaultPreferencesInstantiation() { + List preferences = new ArrayList<>(); + preferences.add(new DefaultConfiguration("name", "value", "type")); + + defaultPreferences.setPreferences(preferences); + defaultPreferences.setType("type"); + + DefaultPreferences newDefaultPreferences = new DefaultPreferences(defaultPreferences.getType(), defaultPreferences.getPreferences()); + + assertEquals(newDefaultPreferences.getPreferences(), defaultPreferences.getPreferences(), "Preferences does not match."); + assertEquals(newDefaultPreferences.getType(), defaultPreferences.getType(), "Type does not match."); + } + + @Override + protected DefaultPreferences getInstance() { + return defaultPreferences; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + List preferences = new ArrayList<>(); + + return Stream.of( + Arguments.of("preferences", preferences), + Arguments.of("type", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/DegreeLevelTest.java b/src/test/java/org/tdl/vireo/model/DegreeLevelTest.java new file mode 100644 index 000000000..381b5053c --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/DegreeLevelTest.java @@ -0,0 +1,31 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class DegreeLevelTest extends AbstractModelTest { + + @InjectMocks + private DegreeLevel degreeLevel; + + @Override + protected DegreeLevel getInstance() { + return degreeLevel; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/DegreeTest.java b/src/test/java/org/tdl/vireo/model/DegreeTest.java new file mode 100644 index 000000000..68bf6b89a --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/DegreeTest.java @@ -0,0 +1,70 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class DegreeTest extends AbstractModelTest { + + @InjectMocks + private Degree degree; + + @Test + public void testGetControlledName() { + String name = "name"; + + ReflectionTestUtils.setField(getInstance(), "name", name); + + assertEquals(name, degree.getControlledName(), "Controlled Name does not match."); + } + + @Test + public void testGetControlledDefinition() { + String degreeCode = "degreeCode"; + + ReflectionTestUtils.setField(getInstance(), "degreeCode", degreeCode); + + assertEquals(degreeCode, degree.getControlledDefinition(), "Controlled Definition does not match."); + } + + @Test + public void testGetControlledIdentifier() { + DegreeLevel degreeLevel = new DegreeLevel("level"); + + ReflectionTestUtils.setField(getInstance(), "level", degreeLevel); + + assertEquals(degreeLevel.getName(), degree.getControlledIdentifier(), "Controlled Identifier does not match."); + } + + @Test + public void testGetControlledContacts() { + assertNotNull(degree.getControlledContacts(), "Controlled Contacts is null."); + } + + @Override + protected Degree getInstance() { + return degree; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("degreeCode", "value"), + Arguments.of("level", new DegreeLevel()) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/DepositLocationTest.java b/src/test/java/org/tdl/vireo/model/DepositLocationTest.java new file mode 100644 index 000000000..8c9bfee91 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/DepositLocationTest.java @@ -0,0 +1,42 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.tdl.vireo.model.packager.DSpaceMetsPackager; +import org.tdl.vireo.model.packager.DSpaceSimplePackager; + +public class DepositLocationTest extends AbstractModelTest { + + @InjectMocks + private DepositLocation depositLocation; + + @Override + protected DepositLocation getInstance() { + return depositLocation; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("repository", "value"), + Arguments.of("collection", "value"), + Arguments.of("username", "value"), + Arguments.of("password", "value"), + Arguments.of("onBehalfOf", "value"), + Arguments.of("packager", new DSpaceMetsPackager()), + Arguments.of("packager", new DSpaceSimplePackager()), + Arguments.of("depositorName", "value"), + Arguments.of("timeout", 123) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/DocumentTypeTest.java b/src/test/java/org/tdl/vireo/model/DocumentTypeTest.java new file mode 100644 index 000000000..5c005217f --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/DocumentTypeTest.java @@ -0,0 +1,49 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class DocumentTypeTest extends AbstractModelTest { + + @InjectMocks + private DocumentType documentType; + + @Test + public void testDocumentTypeInstantiation() { + FieldPredicate fieldPredicate = new FieldPredicate(); + + fieldPredicate.setId(1L); + documentType.setName("name"); + documentType.setFieldPredicate(fieldPredicate); + + DocumentType newDocumentType = new DocumentType(documentType.getName(), documentType.getFieldPredicate()); + + assertEquals(newDocumentType.getName(), documentType.getName(), "Name does not match."); + assertEquals(newDocumentType.getFieldPredicate(), documentType.getFieldPredicate(), "Field Predicate does not match."); + } + + @Override + protected DocumentType getInstance() { + return documentType; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("fieldPredicate", new FieldPredicate()) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/EmailRecipientAssigneeTest.java b/src/test/java/org/tdl/vireo/model/EmailRecipientAssigneeTest.java new file mode 100644 index 000000000..10396debc --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/EmailRecipientAssigneeTest.java @@ -0,0 +1,60 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class EmailRecipientAssigneeTest extends AbstractModelTest { + + @InjectMocks + private EmailRecipientAssignee emailRecipientAssignee; + + @Test + public void testGetEmails() { + Submission submission = new Submission(); + User assignee = new User(); + Map settings = new HashMap<>(); + + // Warning: "prefered" is a typo in the functional code (this should instead be "preferred"). + String key = "preferedEmail"; + + settings.put(key, "nobody@example.com"); + assignee.setId(1L); + assignee.setSettings(settings); + + ReflectionTestUtils.setField(submission, "assignee", assignee); + + List got = emailRecipientAssignee.getEmails(submission); + + assertNotNull(got, "E-mails array must not be null."); + assertTrue(got.contains(settings.get(key)), "E-mail is not found."); + } + + @Override + protected EmailRecipientAssignee getInstance() { + return emailRecipientAssignee; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/EmailRecipientContactTest.java b/src/test/java/org/tdl/vireo/model/EmailRecipientContactTest.java new file mode 100644 index 000000000..bc49a0043 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/EmailRecipientContactTest.java @@ -0,0 +1,86 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.springframework.test.util.ReflectionTestUtils; + +public class EmailRecipientContactTest extends AbstractModelTest { + + @InjectMocks + private EmailRecipientContact emailRecipientContact; + + @Mock + private Submission submission; + + @Test + public void testGetEmails() { + List emails = new ArrayList(); + List fieldValues = new ArrayList(); + FieldValue fieldValue = new FieldValue(); + FieldValue otherFieldValue = new FieldValue(); + FieldPredicate fieldPredicate = new FieldPredicate(); + + emails.add("first@example.com"); + emails.add("second@example.com"); + otherFieldValue.setId(1L); + otherFieldValue.setValue("value1"); + fieldValue.setId(2L); + fieldValue.setValue("value2"); + fieldValue.setContacts(emails); + fieldValues.add(fieldValue); + fieldValues.add(otherFieldValue); + fieldPredicate.setId(1L); + + ReflectionTestUtils.setField(emailRecipientContact, "fieldPredicate", fieldPredicate); + + when(submission.getFieldValuesByPredicate(any(FieldPredicate.class))).thenReturn(fieldValues); + + List got = emailRecipientContact.getEmails(submission); + + assertEquals(got.size(), emails.size(), "Emails array does not have the correct length."); + + emails.forEach(email -> { + String found = null; + + for (String e : got) { + if (e == email) { + found = e; + break; + } + } + + assertNotNull(found, "Did not find e-mail '" + email + "' in the returned array."); + }); + } + + @Override + protected EmailRecipientContact getInstance() { + return emailRecipientContact; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("fieldPredicate", new FieldPredicate()) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/EmailRecipientOrganizationTest.java b/src/test/java/org/tdl/vireo/model/EmailRecipientOrganizationTest.java new file mode 100644 index 000000000..8171c5d5f --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/EmailRecipientOrganizationTest.java @@ -0,0 +1,54 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class EmailRecipientOrganizationTest extends AbstractModelTest { + + // Warning: @InjectMocks throws NPE here and so an explicit assignment is provided. + @InjectMocks + private EmailRecipientOrganization emailRecipientOrganization = new EmailRecipientOrganization(); + + @Test + public void testGetEmails() { + Submission submission = new Submission(); + Organization organization = new Organization(); + String email = "nobody@example.com"; + + organization.addEmail(email); + + ReflectionTestUtils.setField(emailRecipientOrganization, "organization", organization); + + List got = emailRecipientOrganization.getEmails(submission); + + assertNotNull(got, "E-mails array must not be null."); + assertTrue(got.contains(email), "E-mail is not found."); + } + + @Override + protected EmailRecipientOrganization getInstance() { + return emailRecipientOrganization; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/EmailRecipientPlainAddressTest.java b/src/test/java/org/tdl/vireo/model/EmailRecipientPlainAddressTest.java new file mode 100644 index 000000000..9dfbca2b1 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/EmailRecipientPlainAddressTest.java @@ -0,0 +1,50 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class EmailRecipientPlainAddressTest extends AbstractModelTest { + + @InjectMocks + private EmailRecipientPlainAddress emailRecipientPlainAddress; + + @Test + public void testGetEmails() { + Submission submission = new Submission(); + String email = "nobody@example.com"; + + ReflectionTestUtils.setField(emailRecipientPlainAddress, "name", email); + + List got = emailRecipientPlainAddress.getEmails(submission); + + assertNotNull(got, "E-mails array must not be null."); + assertTrue(got.contains(email), "E-mail is not found."); + } + + @Override + protected EmailRecipientPlainAddress getInstance() { + return emailRecipientPlainAddress; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/EmailRecipientSubmitterTest.java b/src/test/java/org/tdl/vireo/model/EmailRecipientSubmitterTest.java new file mode 100644 index 000000000..53d5e3127 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/EmailRecipientSubmitterTest.java @@ -0,0 +1,60 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class EmailRecipientSubmitterTest extends AbstractModelTest { + + @InjectMocks + private EmailRecipientSubmitter emailRecipientSubmitter; + + @Test + public void testGetEmails() { + Submission submission = new Submission(); + User submitter = new User(); + Map settings = new HashMap<>(); + + // Warning: "prefered" is a typo in the functional code (this should instead be "preferred"). + String key = "preferedEmail"; + + settings.put(key, "nobody@example.com"); + submitter.setId(1L); + submitter.setSettings(settings); + + ReflectionTestUtils.setField(submission, "submitter", submitter); + + List got = emailRecipientSubmitter.getEmails(submission); + + assertNotNull(got, "E-mails array must not be null."); + assertTrue(got.contains(settings.get(key)), "E-mail is not found."); + } + + @Override + protected EmailRecipientSubmitter getInstance() { + return emailRecipientSubmitter; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/EmailRecipientTypeTest.java b/src/test/java/org/tdl/vireo/model/EmailRecipientTypeTest.java new file mode 100644 index 000000000..45c4dcd5d --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/EmailRecipientTypeTest.java @@ -0,0 +1,19 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; + +public class EmailRecipientTypeTest extends AbstractEnumTest { + + protected static Stream provideEnumParameters() { + return Stream.of( + Arguments.of(EmailRecipientType.ASSIGNEE, "ASSIGNEE", 0), + Arguments.of(EmailRecipientType.ADVISOR, "ADVISOR", 1), + Arguments.of(EmailRecipientType.CONTACT, "CONTACT", 2), + Arguments.of(EmailRecipientType.ORGANIZATION, "ORGANIZATION", 3), + Arguments.of(EmailRecipientType.PLAIN_ADDRESS, "PLAIN_ADDRESS", 4), + Arguments.of(EmailRecipientType.SUBMITTER, "SUBMITTER", 5) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/EmailTemplateTest.java b/src/test/java/org/tdl/vireo/model/EmailTemplateTest.java new file mode 100644 index 000000000..0a463c3e8 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/EmailTemplateTest.java @@ -0,0 +1,35 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class EmailTemplateTest extends AbstractModelTest { + + @InjectMocks + private EmailTemplate emailTemplate; + + @Override + protected EmailTemplate getInstance() { + return emailTemplate; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("subject", "value"), + Arguments.of("message", "value"), + Arguments.of("systemRequired", true), + Arguments.of("systemRequired", false) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/EmailWorkflowRuleTest.java b/src/test/java/org/tdl/vireo/model/EmailWorkflowRuleTest.java new file mode 100644 index 000000000..9b99b02c8 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/EmailWorkflowRuleTest.java @@ -0,0 +1,37 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class EmailWorkflowRuleTest extends AbstractModelTest { + + @InjectMocks + private EmailWorkflowRule emailWorkflowRule; + + @Override + protected EmailWorkflowRule getInstance() { + return emailWorkflowRule; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("isSystem", true), + Arguments.of("isSystem", false), + Arguments.of("isDisabled", true), + Arguments.of("isDisabled", false), + Arguments.of("emailRecipient", new EmailRecipientOrganization()), + Arguments.of("emailRecipient", new EmailRecipientPlainAddress()), + Arguments.of("emailTemplate", new EmailTemplate()) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/EmbargoGuarantorTest.java b/src/test/java/org/tdl/vireo/model/EmbargoGuarantorTest.java new file mode 100644 index 000000000..c8d328772 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/EmbargoGuarantorTest.java @@ -0,0 +1,44 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +public class EmbargoGuarantorTest extends AbstractEnumTest { + + @ParameterizedTest + @MethodSource("provideEnumParameters") + public void testGetValue(EmbargoGuarantor enumeration, String name, int ordinal) { + assertEquals(ordinal, enumeration.getValue(), "Value is incorrect."); + } + + @ParameterizedTest + @MethodSource("provideEnumParameters") + public void testToString(EmbargoGuarantor enumeration, String name, int ordinal) { + assertEquals(name, enumeration.toString(), "Name is incorrect."); + } + + @ParameterizedTest + @MethodSource("provideEnumParameters") + public void testFromString(EmbargoGuarantor enumeration, String name, int ordinal) { + assertEquals(enumeration, EmbargoGuarantor.fromString(name), "Enumeration is incorrect."); + } + + @Test + public void testFromStringReturnsNull() { + assertNull(EmbargoGuarantor.fromString("This cannot exist."), "Did not return null."); + } + + protected static Stream provideEnumParameters() { + return Stream.of( + Arguments.of(EmbargoGuarantor.DEFAULT, "DEFAULT", 0), + Arguments.of(EmbargoGuarantor.PROQUEST, "PROQUEST", 1) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/EmbargoTest.java b/src/test/java/org/tdl/vireo/model/EmbargoTest.java new file mode 100644 index 000000000..5353f40de --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/EmbargoTest.java @@ -0,0 +1,100 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class EmbargoTest extends AbstractModelTest { + + @InjectMocks + private Embargo embargo; + + /** + * The isActive() does not work via getParameterStream() and is manually tested here. + */ + @Test + public void testGetSystemRequired() { + Boolean isActive = true; + + ReflectionTestUtils.setField(embargo, "isActive", isActive); + + assertEquals(isActive, embargo.isActive(), GETTER_MESSAGE); + } + + /** + * The isActive() does not work via setParameterStream() and is manually tested here. + */ + @Test + public void testSetSettings() { + Boolean isActive = true; + + ReflectionTestUtils.setField(embargo, "isActive", false); + + embargo.isActive(isActive); + + assertEquals(isActive, ReflectionTestUtils.getField(embargo, "isActive"), SETTER_MESSAGE); + } + + @Test + public void testGetControlledName() { + String name = "name"; + + ReflectionTestUtils.setField(getInstance(), "name", name); + + assertEquals(name, embargo.getControlledName(), "Controlled Name does not match."); + } + + @Test + public void testGetControlledDefinition() { + String description = "description"; + + ReflectionTestUtils.setField(getInstance(), "description", description); + + assertEquals(description, embargo.getControlledDefinition(), "Controlled Definition does not match."); + } + + @Test + public void testGetControlledIdentifier() { + Long id = 1L; + + ReflectionTestUtils.setField(getInstance(), "id", id); + + assertEquals(String.valueOf(id), embargo.getControlledIdentifier(), "Controlled Identifier does not match."); + } + + @Test + public void testGetControlledContacts() { + assertNotNull(embargo.getControlledContacts(), "Controlled Contacts is null."); + } + + @Override + protected Embargo getInstance() { + return embargo; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("description", "value"), + Arguments.of("duration", 123), + Arguments.of("systemRequired", true), + Arguments.of("systemRequired", false), + Arguments.of("guarantor", EmbargoGuarantor.DEFAULT), + Arguments.of("guarantor", EmbargoGuarantor.PROQUEST) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/EntityCVFilterTest.java b/src/test/java/org/tdl/vireo/model/EntityCVFilterTest.java new file mode 100644 index 000000000..b3c5c153d --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/EntityCVFilterTest.java @@ -0,0 +1,32 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class EntityCVFilterTest extends AbstractModelTest { + + @InjectMocks + private EntityCVFilter entityCVFilter; + + @Override + protected EntityCVFilter getInstance() { + return entityCVFilter; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("path", "value"), + Arguments.of("value", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/FieldPredicateTest.java b/src/test/java/org/tdl/vireo/model/FieldPredicateTest.java new file mode 100644 index 000000000..8535835da --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/FieldPredicateTest.java @@ -0,0 +1,89 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class FieldPredicateTest extends AbstractModelTest { + + @InjectMocks + private FieldPredicate fieldPredicate; + + @ParameterizedTest + @MethodSource("provideSchemaTest") + public void testGetSchema(String value, String expect) { + ReflectionTestUtils.setField(getInstance(), "value", value); + + assertEquals(expect, fieldPredicate.getSchema(), GETTER_MESSAGE); + } + + @ParameterizedTest + @MethodSource("provideElementTest") + public void testGetElement(String value, String expect) { + ReflectionTestUtils.setField(getInstance(), "value", value); + + assertEquals(expect, fieldPredicate.getElement(), GETTER_MESSAGE); + } + + @ParameterizedTest + @MethodSource("provideQualifierTest") + public void testGetQualifier(String value, String expect) { + ReflectionTestUtils.setField(getInstance(), "value", value); + + assertEquals(expect, fieldPredicate.getQualifier(), GETTER_MESSAGE); + } + + @Override + protected FieldPredicate getInstance() { + return fieldPredicate; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("value", "value"), + Arguments.of("documentTypePredicate", true), + Arguments.of("documentTypePredicate", false) + ); + } + + private static Stream provideSchemaTest() { + return Stream.of( + Arguments.of("has.all.three", "has"), + Arguments.of("has.two", "has"), + Arguments.of("one", "one"), + Arguments.of("", "") + ); + } + + private static Stream provideElementTest() { + return Stream.of( + Arguments.of("has.all.three", "all"), + Arguments.of("has.two", "two"), + Arguments.of("one", null), + Arguments.of("", null) + ); + } + + private static Stream provideQualifierTest() { + return Stream.of( + Arguments.of("has.all.three", "three"), + Arguments.of("has.two", null), + Arguments.of("one", null), + Arguments.of("", null) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/FieldProfileTest.java b/src/test/java/org/tdl/vireo/model/FieldProfileTest.java new file mode 100644 index 000000000..67ea3cad1 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/FieldProfileTest.java @@ -0,0 +1,54 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class FieldProfileTest extends AbstractModelTest { + + @InjectMocks + private FieldProfile fieldProfile; + + @Override + protected FieldProfile getInstance() { + return fieldProfile; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("fieldPredicate", new FieldPredicate()), + Arguments.of("inputType", new InputType()), + Arguments.of("repeatable", true), + Arguments.of("repeatable", false), + Arguments.of("optional", true), + Arguments.of("optional", false), + Arguments.of("hidden", true), + Arguments.of("hidden", false), + Arguments.of("logged", true), + Arguments.of("logged", false), + Arguments.of("usage", "value"), + Arguments.of("help", "value"), + Arguments.of("gloss", "value"), + Arguments.of("controlledVocabulary", new ControlledVocabulary()), + Arguments.of("mappedShibAttribute", new ManagedConfiguration()), + Arguments.of("flagged", true), + Arguments.of("flagged", false), + Arguments.of("defaultValue", "value"), + Arguments.of("enabled", true), + Arguments.of("enabled", false), + Arguments.of("originating", new FieldProfile()), + Arguments.of("originatingWorkflowStep", new WorkflowStep()), + Arguments.of("overrideable", true), + Arguments.of("overrideable", false) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/FilterActionTest.java b/src/test/java/org/tdl/vireo/model/FilterActionTest.java new file mode 100644 index 000000000..6bcef34da --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/FilterActionTest.java @@ -0,0 +1,19 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; + +public class FilterActionTest extends AbstractEnumTest { + + protected static Stream provideEnumParameters() { + return Stream.of( + Arguments.of(FilterAction.CLEAR, "CLEAR", 0), + Arguments.of(FilterAction.REFRESH, "REFRESH", 1), + Arguments.of(FilterAction.REMOVE, "REMOVE", 2), + Arguments.of(FilterAction.SAVE, "SAVE", 3), + Arguments.of(FilterAction.SET, "SET", 4), + Arguments.of(FilterAction.SORT, "SORT", 5) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/FilterCriterionTest.java b/src/test/java/org/tdl/vireo/model/FilterCriterionTest.java new file mode 100644 index 000000000..264eab843 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/FilterCriterionTest.java @@ -0,0 +1,46 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class FilterCriterionTest extends AbstractModelTest { + + @InjectMocks + private FilterCriterion filterCriterion; + + @Test + public void testFilterCriterionInstantiation() { + filterCriterion.setValue("value"); + filterCriterion.setGloss("gloss");; + + FilterCriterion newFilterCriterion = new FilterCriterion(filterCriterion.getValue(), filterCriterion.getGloss()); + + assertEquals(newFilterCriterion.getValue(), filterCriterion.getValue(), "Value does not match."); + assertEquals(newFilterCriterion.getGloss(), filterCriterion.getGloss(), "Gloss does not match."); + } + + @Override + protected FilterCriterion getInstance() { + return filterCriterion; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("value", "value"), + Arguments.of("gloss", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/GraduationMonthTest.java b/src/test/java/org/tdl/vireo/model/GraduationMonthTest.java new file mode 100644 index 000000000..d578681dd --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/GraduationMonthTest.java @@ -0,0 +1,60 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class GraduationMonthTest extends AbstractModelTest { + + @InjectMocks + private GraduationMonth graduationMonth; + + @Test + public void testGetControlledName() { + int month = 123; + + ReflectionTestUtils.setField(getInstance(), "month", month); + + assertEquals(String.valueOf(month), graduationMonth.getControlledName(), "Controlled Name does not match."); + } + + @Test + public void testGetControlledDefinition() { + assertEquals("", graduationMonth.getControlledDefinition(), "Controlled Definition does not match."); + } + + @Test + public void testGetControlledIdentifier() { + assertEquals("", graduationMonth.getControlledIdentifier(), "Controlled Identifier does not match."); + } + + @Test + public void testGetControlledContacts() { + assertNotNull(graduationMonth.getControlledContacts(), "Controlled Contacts is null."); + } + + @Override + protected GraduationMonth getInstance() { + return graduationMonth; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("month", 123) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/InputTypeTest.java b/src/test/java/org/tdl/vireo/model/InputTypeTest.java new file mode 100644 index 000000000..68f53f405 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/InputTypeTest.java @@ -0,0 +1,189 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; + +import java.util.HashMap; +import java.util.Map; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class InputTypeTest extends AbstractModelTest { + + @InjectMocks + private InputType inputType; + + @Test + public void testGetValidationMessage() { + Map validations = new HashMap<>(); + Validation validation1 = new Validation(); + Validation validation2 = new Validation(); + String name = "name"; + + validation1.setPattern("Some Pattern."); + validation1.setMessage("something"); + + validation2.setPattern("Another Pattern."); + validation2.setMessage("another"); + + validations.put("other", validation1); + validations.put(name, validation2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "validation", validations); + + assertEquals(validation2.getMessage(), inputType.getValidationMessage(name), GETTER_MESSAGE); + } + + @Test + public void testGetValidationMessageReturnsNull() { + Map validations = new HashMap<>(); + Validation validation1 = new Validation(); + Validation validation2 = new Validation(); + String name = "name"; + + validation1.setPattern("Some Pattern."); + validation1.setMessage("something"); + + validation2.setPattern("Another Pattern."); + validation2.setMessage("another"); + + validations.put("other", validation1); + validations.put(name, validation2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "validation", validations); + + assertNull(inputType.getValidationMessage("Not Found"), "Null must be returned for unknown map name."); + } + + @Test + public void testGetValidationPattern() { + Map validations = new HashMap<>(); + Validation validation1 = new Validation(); + Validation validation2 = new Validation(); + String name = "name"; + + validation1.setPattern("Some Pattern."); + validation1.setMessage("something"); + + validation2.setPattern("Another Pattern."); + validation2.setMessage("another"); + + validations.put("other", validation1); + validations.put(name, validation2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "validation", validations); + + assertEquals(validation2.getPattern(), inputType.getValidationPattern(name), GETTER_MESSAGE); + } + + /** + * The setValidationMessage() does not work via setParameterStream() and is manually tested here. + */ + @Test + public void testSetValidationMessage1() { + String message = "message"; + + inputType.setValidationMessage(message); + + assertEquals(message, ReflectionTestUtils.getField(getInstance(), "validationMessage"), SETTER_MESSAGE); + } + + @Test + public void testSetValidationMessage2() { + Map validations = new HashMap<>(); + Validation validation1 = new Validation(); + Validation validation2 = new Validation(); + String message = "message"; + String name = "name"; + + validation1.setPattern("Some Pattern."); + validation1.setMessage("something"); + + validation2.setPattern("Another Pattern."); + validation2.setMessage("another"); + + validations.put("other", validation1); + validations.put(name, validation2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "validation", validations); + + inputType.setValidationMessage(message, name); + + assertEquals(message, validation2.getMessage(), SETTER_MESSAGE); + } + + /** + * The setValidationPattern() does not work via setParameterStream() and is manually tested here. + */ + @Test + public void testSetValidationPattern1() { + String pattern = "pattern"; + + inputType.setValidationPattern(pattern); + + assertEquals(pattern, ReflectionTestUtils.getField(getInstance(), "validationPattern"), SETTER_MESSAGE); + } + + @Test + public void testSetValidationPattern2() { + Map validations = new HashMap<>(); + Validation validation1 = new Validation(); + Validation validation2 = new Validation(); + String pattern = "pattern"; + String name = "name"; + + validation1.setMessage("Some Message."); + validation1.setPattern("something"); + + validation2.setMessage("Another Message."); + validation2.setPattern("another"); + + validations.put("other", validation1); + validations.put(name, validation2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "validation", validations); + + inputType.setValidationPattern(pattern, name); + + assertEquals(pattern, validation2.getPattern(), SETTER_MESSAGE); + } + + @Override + protected InputType getInstance() { + return inputType; + } + + protected static Stream provideGetterParameters() { + Map validationMap = new HashMap<>(); + Validation validation = new Validation(); + + validation.setMessage("message"); + validation.setMessage("pattern"); + validationMap.put("key", validation); + + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("validationPattern", "pattern"), + Arguments.of("validationMessage", "message"), + Arguments.of("validation", validationMap) + ); + } + + protected static Stream provideSetterParameters() { + Map validationMap = new HashMap<>(); + Validation validation = new Validation(); + + validation.setMessage("message"); + validation.setMessage("pattern"); + validationMap.put("key", validation); + + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("validation", validationMap) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/LanguageTest.java b/src/test/java/org/tdl/vireo/model/LanguageTest.java new file mode 100644 index 000000000..4a24a8b13 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/LanguageTest.java @@ -0,0 +1,60 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; + +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class LanguageTest extends AbstractModelTest { + + @InjectMocks + private Language language; + + @Test + public void testGetControlledName() { + String name = "name"; + + ReflectionTestUtils.setField(getInstance(), "name", name); + + assertEquals(name, language.getControlledName(), "Controlled Name does not match."); + } + + @Test + public void testGetControlledDefinition() { + assertEquals("", language.getControlledDefinition(), "Controlled Definition does not match."); + } + + @Test + public void testGetControlledIdentifier() { + assertEquals("", language.getControlledIdentifier(), "Controlled Identifier does not match."); + } + + @Test + public void testGetControlledContacts() { + assertNotNull(language.getControlledContacts(), "Controlled Contacts is null."); + } + + @Override + protected Language getInstance() { + return language; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/ManagedConfigurationTest.java b/src/test/java/org/tdl/vireo/model/ManagedConfigurationTest.java new file mode 100644 index 000000000..e545adbef --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/ManagedConfigurationTest.java @@ -0,0 +1,33 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class ManagedConfigurationTest extends AbstractModelTest { + + @InjectMocks + private ManagedConfiguration managedConfiguration; + + @Override + protected ManagedConfiguration getInstance() { + return managedConfiguration; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("value", "value"), + Arguments.of("type", "value"), + Arguments.of("name", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/NamedSearchFilterGroupTest.java b/src/test/java/org/tdl/vireo/model/NamedSearchFilterGroupTest.java new file mode 100644 index 000000000..b6bbbded8 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/NamedSearchFilterGroupTest.java @@ -0,0 +1,201 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class NamedSearchFilterGroupTest extends AbstractModelTest { + + @InjectMocks + private NamedSearchFilterGroup namedSearchFilterGroup; + + @Test + public void testAddSavedColumnWhenNotInArray() { + List savedColumns = new ArrayList<>(); + SubmissionListColumn submissionListColumn1 = new SubmissionListColumn(); + SubmissionListColumn submissionListColumn2 = new SubmissionListColumn(); + + submissionListColumn1.setId(1L); + submissionListColumn2.setId(2L); + + savedColumns.add(submissionListColumn1); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "savedColumns", savedColumns); + + namedSearchFilterGroup.addSavedColumn(submissionListColumn2); + + assertTrue(savedColumns.contains(submissionListColumn2), "Submission List Column is not added to the Saved Columns array."); + } + + @Test + public void testAddSavedColumnWhenInArray() { + List savedColumns = new ArrayList<>(); + SubmissionListColumn submissionListColumn1 = new SubmissionListColumn(); + SubmissionListColumn submissionListColumn2 = new SubmissionListColumn(); + + submissionListColumn1.setId(1L); + submissionListColumn2.setId(2L); + + savedColumns.add(submissionListColumn1); + savedColumns.add(submissionListColumn2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "savedColumns", savedColumns); + + namedSearchFilterGroup.addSavedColumn(submissionListColumn2); + + assertEquals(2, savedColumns.size(), "Submission List Column is added to the Saved Columns array multiple times."); + } + + @Test + public void testRemoveSavedColumn() { + List savedColumns = new ArrayList<>(); + SubmissionListColumn submissionListColumn1 = new SubmissionListColumn(); + SubmissionListColumn submissionListColumn2 = new SubmissionListColumn(); + + submissionListColumn1.setId(1L); + submissionListColumn2.setId(2L); + + savedColumns.add(submissionListColumn1); + savedColumns.add(submissionListColumn2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "savedColumns", savedColumns); + + namedSearchFilterGroup.removeSavedColumn(submissionListColumn2); + + assertFalse(savedColumns.contains(submissionListColumn2), "Submission List Column is still in the Saved Columns array."); + } + + @Test + public void testAddNamedSearchFilterWhenNotInArray() { + Set namedSearchFilters = new HashSet<>(); + NamedSearchFilter filterCriterion1 = new NamedSearchFilter(); + NamedSearchFilter filterCriterion2 = new NamedSearchFilter(); + + filterCriterion1.setId(1L); + filterCriterion2.setId(2L); + + namedSearchFilters.add(filterCriterion1); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "namedSearchFilters", namedSearchFilters); + + namedSearchFilterGroup.addFilterCriterion(filterCriterion2); + + assertTrue(namedSearchFilters.contains(filterCriterion2), "Filter Criterion is not added to the Named Search Filters array."); + } + + @Test + public void testAddNamedSearchFilterWhenInArray() { + Set namedSearchFilters = new HashSet<>(); + NamedSearchFilter filterCriterion1 = new NamedSearchFilter(); + NamedSearchFilter filterCriterion2 = new NamedSearchFilter(); + + filterCriterion1.setId(1L); + filterCriterion2.setId(2L); + + namedSearchFilters.add(filterCriterion1); + namedSearchFilters.add(filterCriterion2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "namedSearchFilters", namedSearchFilters); + + namedSearchFilterGroup.addFilterCriterion(filterCriterion2); + + assertEquals(2, namedSearchFilters.size(), "Filter Criterion is added to the Named Search Filters array multiple times."); + } + + @Test + public void testRemoveNamedSearchFilter() { + Set namedSearchFilters = new HashSet<>(); + NamedSearchFilter filterCriterion1 = new NamedSearchFilter(); + NamedSearchFilter filterCriterion2 = new NamedSearchFilter(); + + filterCriterion1.setId(1L); + filterCriterion2.setId(2L); + + namedSearchFilters.add(filterCriterion1); + namedSearchFilters.add(filterCriterion2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "namedSearchFilters", namedSearchFilters); + + namedSearchFilterGroup.removeNamedSearchFilter(filterCriterion2); + + assertFalse(namedSearchFilters.contains(filterCriterion2), "Filter Criterion is still in the Named Search Filters array."); + } + + @Test + public void testGetNamedSearchFilterWhenInArray() { + Set namedSearchFilters = new HashSet<>(); + NamedSearchFilter filterCriterion1 = new NamedSearchFilter(); + NamedSearchFilter filterCriterion2 = new NamedSearchFilter(); + + filterCriterion1.setId(1L); + filterCriterion2.setId(2L); + + namedSearchFilters.add(filterCriterion1); + namedSearchFilters.add(filterCriterion2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "namedSearchFilters", namedSearchFilters); + + assertEquals(filterCriterion2, namedSearchFilterGroup.getNamedSearchFilter(filterCriterion2.getId()), "Filter Criterion is not returned."); + } + + @Test + public void testGetNamedSearchFilterWhenNotInArray() { + Set namedSearchFilters = new HashSet<>(); + NamedSearchFilter filterCriterion1 = new NamedSearchFilter(); + NamedSearchFilter filterCriterion2 = new NamedSearchFilter(); + + filterCriterion1.setId(1L); + filterCriterion2.setId(2L); + + namedSearchFilters.add(filterCriterion1); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "namedSearchFilters", namedSearchFilters); + + assertNull(namedSearchFilterGroup.getNamedSearchFilter(filterCriterion2.getId()), "Filter Criterion is returned."); + } + + @Override + protected NamedSearchFilterGroup getInstance() { + return namedSearchFilterGroup; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + List savedColumns = new ArrayList<>(); + Set namedSearchFilters = new HashSet<>(); + + return Stream.of( + Arguments.of("user", new User()), + Arguments.of("name", "value"), + Arguments.of("publicFlag", true), + Arguments.of("publicFlag", false), + Arguments.of("columnsFlag", true), + Arguments.of("columnsFlag", false), + Arguments.of("umiRelease", true), + Arguments.of("umiRelease", false), + Arguments.of("sortColumnTitle", "value"), + Arguments.of("sortDirection", Sort.ASC), + Arguments.of("savedColumns", savedColumns), + Arguments.of("namedSearchFilters", namedSearchFilters) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/NamedSearchFilterTest.java b/src/test/java/org/tdl/vireo/model/NamedSearchFilterTest.java new file mode 100644 index 000000000..3f14d27ef --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/NamedSearchFilterTest.java @@ -0,0 +1,36 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class NamedSearchFilterTest extends AbstractModelTest { + + @InjectMocks + private NamedSearchFilter namedSearchFilter; + + @Override + protected NamedSearchFilter getInstance() { + return namedSearchFilter; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("submissionListColumn", new SubmissionListColumn()), + Arguments.of("allColumnSearch", true), + Arguments.of("allColumnSearch", false), + Arguments.of("exactMatch", true), + Arguments.of("exactMatch", false) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/NoteTest.java b/src/test/java/org/tdl/vireo/model/NoteTest.java new file mode 100644 index 000000000..16a0c3609 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/NoteTest.java @@ -0,0 +1,38 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class NoteTest extends AbstractModelTest { + + @InjectMocks + private Note note; + + @Override + protected Note getInstance() { + return note; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + WorkflowStep workflowStep = new WorkflowStep(); + + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("text", "value"), + Arguments.of("originating", new Note(workflowStep, "name", "text", false)), + Arguments.of("originatingWorkflowStep", workflowStep), + Arguments.of("overrideable", true), + Arguments.of("overrideable", false) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/OrganizationCategoryTest.java b/src/test/java/org/tdl/vireo/model/OrganizationCategoryTest.java new file mode 100644 index 000000000..b014e154a --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/OrganizationCategoryTest.java @@ -0,0 +1,31 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class OrganizationCategoryTest extends AbstractModelTest { + + @InjectMocks + private OrganizationCategory organizationCategory; + + @Override + protected OrganizationCategory getInstance() { + return organizationCategory; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/OrganizationTest.java b/src/test/java/org/tdl/vireo/model/OrganizationTest.java new file mode 100644 index 000000000..a38abe56b --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/OrganizationTest.java @@ -0,0 +1,50 @@ +package org.tdl.vireo.model; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class OrganizationTest extends AbstractModelTest { + + @InjectMocks + private Organization organization; + + @Override + protected Organization getInstance() { + return organization; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + List originalWorkflowSteps = new ArrayList<>(); + List aggregateWorkflowSteps = new ArrayList<>(); + List emails = new ArrayList<>(); + List emailWorkflowRules = new ArrayList<>(); + Set childrenOrganizations = new HashSet<>(); + + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("category", new OrganizationCategory()), + Arguments.of("acceptsSubmissions", true), + Arguments.of("acceptsSubmissions", false), + Arguments.of("originalWorkflowSteps", originalWorkflowSteps), + Arguments.of("aggregateWorkflowSteps", aggregateWorkflowSteps), + Arguments.of("parentOrganization", new Organization()), + Arguments.of("childrenOrganizations", childrenOrganizations), + Arguments.of("emails", emails), + Arguments.of("emailWorkflowRules", emailWorkflowRules) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/RoleTest.java b/src/test/java/org/tdl/vireo/model/RoleTest.java new file mode 100644 index 000000000..182d6bebe --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/RoleTest.java @@ -0,0 +1,18 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; + +public class RoleTest extends AbstractEnumTest { + + protected static Stream provideEnumParameters() { + return Stream.of( + Arguments.of(Role.ROLE_ADMIN, "ROLE_ADMIN", 0), + Arguments.of(Role.ROLE_MANAGER, "ROLE_MANAGER", 1), + Arguments.of(Role.ROLE_REVIEWER, "ROLE_REVIEWER", 2), + Arguments.of(Role.ROLE_STUDENT, "ROLE_STUDENT", 3), + Arguments.of(Role.ROLE_ANONYMOUS, "ROLE_ANONYMOUS", 4) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/SortTest.java b/src/test/java/org/tdl/vireo/model/SortTest.java new file mode 100644 index 000000000..cbbc80f00 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/SortTest.java @@ -0,0 +1,16 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; + +public class SortTest extends AbstractEnumTest { + + protected static Stream provideEnumParameters() { + return Stream.of( + Arguments.of(Sort.ASC, "ASC", 0), + Arguments.of(Sort.DESC, "DESC", 1), + Arguments.of(Sort.NONE, "NONE", 2) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/SubmissionFieldProfileTest.java b/src/test/java/org/tdl/vireo/model/SubmissionFieldProfileTest.java new file mode 100644 index 000000000..2b3be0aa7 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/SubmissionFieldProfileTest.java @@ -0,0 +1,50 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class SubmissionFieldProfileTest extends AbstractModelTest { + + @InjectMocks + private SubmissionFieldProfile submissionFieldProfile; + + @Override + protected SubmissionFieldProfile getInstance() { + return submissionFieldProfile; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("fieldPredicate", new FieldPredicate()), + Arguments.of("inputType", new InputType()), + Arguments.of("repeatable", true), + Arguments.of("repeatable", false), + Arguments.of("optional", true), + Arguments.of("optional", false), + Arguments.of("hidden", true), + Arguments.of("hidden", false), + Arguments.of("logged", true), + Arguments.of("logged", false), + Arguments.of("usage", "value"), + Arguments.of("help", "value"), + Arguments.of("gloss", "value"), + Arguments.of("controlledVocabulary", new ControlledVocabulary()), + Arguments.of("mappedShibAttribute", new ManagedConfiguration()), + Arguments.of("flagged", true), + Arguments.of("flagged", false), + Arguments.of("defaultValue", "value"), + Arguments.of("enabled", true), + Arguments.of("enabled", false) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/SubmissionListColumnTest.java b/src/test/java/org/tdl/vireo/model/SubmissionListColumnTest.java new file mode 100644 index 000000000..95dc06864 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/SubmissionListColumnTest.java @@ -0,0 +1,53 @@ +package org.tdl.vireo.model; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class SubmissionListColumnTest extends AbstractModelTest { + + @InjectMocks + private SubmissionListColumn submissionListColumn; + + @Override + protected SubmissionListColumn getInstance() { + return submissionListColumn; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + List valuePath = new ArrayList<>(); + valuePath.add("value"); + + Set filters = new HashSet<>(); + filters.add("value"); + + return Stream.of( + Arguments.of("inputType", new InputType()), + Arguments.of("title", "value"), + Arguments.of("predicate", "value"), + Arguments.of("valuePath", valuePath), + Arguments.of("filters", filters), + Arguments.of("sortOrder", 123), + Arguments.of("visible", true), + Arguments.of("visible", false), + Arguments.of("exactMatch", true), + Arguments.of("exactMatch", false), + Arguments.of("sort", Sort.ASC), + Arguments.of("sort", Sort.DESC), + Arguments.of("status", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/SubmissionNoteTest.java b/src/test/java/org/tdl/vireo/model/SubmissionNoteTest.java new file mode 100644 index 000000000..8d2e1ba40 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/SubmissionNoteTest.java @@ -0,0 +1,32 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class SubmissionNoteTest extends AbstractModelTest { + + @InjectMocks + private SubmissionNote submissionNote; + + @Override + protected SubmissionNote getInstance() { + return submissionNote; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("text", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/SubmissionStateTest.java b/src/test/java/org/tdl/vireo/model/SubmissionStateTest.java new file mode 100644 index 000000000..1332c743a --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/SubmissionStateTest.java @@ -0,0 +1,42 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +public class SubmissionStateTest extends AbstractEnumTest { + + @ParameterizedTest + @MethodSource("provideEnumParameters") + public void testGetValue(SubmissionState enumeration, String name, int ordinal) { + assertEquals(ordinal, enumeration.getValue(), "Value is incorrect."); + } + + @ParameterizedTest + @MethodSource("provideEnumParameters") + public void testToString(SubmissionState enumeration, String name, int ordinal) { + assertEquals(name, enumeration.toString(), "Name is incorrect."); + } + + protected static Stream provideEnumParameters() { + return Stream.of( + Arguments.of(SubmissionState.NONE, "NONE", 0), + Arguments.of(SubmissionState.IN_PROGRESS, "IN_PROGRESS", 1), + Arguments.of(SubmissionState.SUBMITTED, "SUBMITTED", 2), + Arguments.of(SubmissionState.UNDER_REVIEW, "UNDER_REVIEW", 3), + Arguments.of(SubmissionState.NEEDS_CORRECTIONS, "NEEDS_CORRECTIONS", 4), + Arguments.of(SubmissionState.CORRECTIONS_RECIEVED, "CORRECTIONS_RECIEVED", 5), + Arguments.of(SubmissionState.WAITING_ON_REQUIREMENTS, "WAITING_ON_REQUIREMENTS", 6), + Arguments.of(SubmissionState.APPROVED, "APPROVED", 7), + Arguments.of(SubmissionState.PENDING_PUBLICATION, "PENDING_PUBLICATION", 8), + Arguments.of(SubmissionState.PUBLISHED, "PUBLISHED", 9), + Arguments.of(SubmissionState.ON_HOLD, "ON_HOLD", 10), + Arguments.of(SubmissionState.WITHDRAWN, "WITHDRAWN", 11), + Arguments.of(SubmissionState.CANCELED, "CANCELED", 12) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/SubmissionStatusTest.java b/src/test/java/org/tdl/vireo/model/SubmissionStatusTest.java new file mode 100644 index 000000000..6f11f3ea5 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/SubmissionStatusTest.java @@ -0,0 +1,190 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class SubmissionStatusTest extends AbstractModelTest { + + @InjectMocks + private SubmissionStatus submissionStatus; + + /** + * The isArchived() does not work via getParameterStream() and is manually tested here. + */ + @Test + public void testGetArchived() { + Boolean isArchived = true; + + ReflectionTestUtils.setField(submissionStatus, "isArchived", isArchived); + + assertEquals(isArchived, submissionStatus.isArchived(), GETTER_MESSAGE); + } + + /** + * The isArchived() does not work via setParameterStream() and is manually tested here. + */ + @Test + public void testSetArchived() { + Boolean isArchived = true; + + ReflectionTestUtils.setField(submissionStatus, "isArchived", false); + + submissionStatus.isArchived(isArchived); + + assertEquals(isArchived, ReflectionTestUtils.getField(getInstance(), "isArchived"), SETTER_MESSAGE); + } + + /** + * The isDeletable() does not work via getParameterStream() and is manually tested here. + */ + @Test + public void testGetDeletable() { + Boolean isDeletable = true; + + ReflectionTestUtils.setField(submissionStatus, "isDeletable", isDeletable); + + assertEquals(isDeletable, submissionStatus.isDeletable(), GETTER_MESSAGE); + } + + /** + * The isDeletable() does not work via setParameterStream() and is manually tested here. + */ + @Test + public void testSetDeletable() { + Boolean isDeletable = true; + + ReflectionTestUtils.setField(submissionStatus, "isDeletable", false); + + submissionStatus.isDeletable(isDeletable); + + assertEquals(isDeletable, ReflectionTestUtils.getField(getInstance(), "isDeletable"), SETTER_MESSAGE); + } + + /** + * The isEditableByReviewer() does not work via getParameterStream() and is manually tested here. + */ + @Test + public void testGetEditableByReviewer() { + Boolean isEditableByReviewer = true; + + ReflectionTestUtils.setField(submissionStatus, "isEditableByReviewer", isEditableByReviewer); + + assertEquals(isEditableByReviewer, submissionStatus.isEditableByReviewer(), GETTER_MESSAGE); + } + + /** + * The isEditableByReviewer() does not work via setParameterStream() and is manually tested here. + */ + @Test + public void testSetEditableByReviewer() { + Boolean isEditableByReviewer = true; + + ReflectionTestUtils.setField(submissionStatus, "isEditableByReviewer", false); + + submissionStatus.isEditableByReviewer(isEditableByReviewer); + + assertEquals(isEditableByReviewer, ReflectionTestUtils.getField(getInstance(), "isEditableByReviewer"), SETTER_MESSAGE); + } + + /** + * The isEditableByStudent() does not work via getParameterStream() and is manually tested here. + */ + @Test + public void testGetEditableByStudent() { + Boolean isEditableByStudent = true; + + ReflectionTestUtils.setField(submissionStatus, "isEditableByStudent", isEditableByStudent); + + assertEquals(isEditableByStudent, submissionStatus.isEditableByStudent(), GETTER_MESSAGE); + } + + /** + * The isEditableByStudent() does not work via setParameterStream() and is manually tested here. + */ + @Test + public void testSetEditableByStudent() { + Boolean isEditableByStudent = true; + + ReflectionTestUtils.setField(submissionStatus, "isEditableByStudent", false); + + submissionStatus.isEditableByStudent(isEditableByStudent); + + assertEquals(isEditableByStudent, ReflectionTestUtils.getField(getInstance(), "isEditableByStudent"), SETTER_MESSAGE); + } + + @Test + public void testAddSubmissionStatusWhenInArray() { + List submissionStatuses = new ArrayList<>(); + SubmissionStatus submissionStatus1 = new SubmissionStatus(); + SubmissionStatus submissionStatus2 = new SubmissionStatus(); + + submissionStatus1.setId(1L); + submissionStatus2.setId(2L); + + submissionStatuses.add(submissionStatus1); + submissionStatuses.add(submissionStatus2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "transitionSubmissionStatuses", submissionStatuses); + + submissionStatus.addTransitionSubmissionStatus(submissionStatus2); + + assertEquals(3, submissionStatuses.size(), "Submission Status is not added to the Submission Statuseses array."); + } + + @Test + public void testRemoveSubmissionStatus() { + List submissionStatuses = new ArrayList<>(); + SubmissionStatus submissionStatus1 = new SubmissionStatus(); + SubmissionStatus submissionStatus2 = new SubmissionStatus(); + + submissionStatus1.setId(1L); + submissionStatus2.setId(2L); + + submissionStatuses.add(submissionStatus1); + submissionStatuses.add(submissionStatus2); + + ReflectionTestUtils.invokeSetterMethod(getInstance(), "transitionSubmissionStatuses", submissionStatuses); + + submissionStatus.removeTransitionSubmissionStatus(submissionStatus2); + + assertFalse(submissionStatuses.contains(submissionStatus2), "Submission Status is still in the Submission Statuses array."); + } + + @Override + protected SubmissionStatus getInstance() { + return submissionStatus; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + List transitionSubmissionStatuses = new ArrayList<>(); + transitionSubmissionStatuses.add(new SubmissionStatus()); + + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("isPublishable", true), + Arguments.of("isPublishable", false), + Arguments.of("isActive", true), + Arguments.of("isActive", false), + Arguments.of("submissionState", SubmissionState.APPROVED), + Arguments.of("submissionState", SubmissionState.CANCELED), + Arguments.of("transitionSubmissionStatuses", transitionSubmissionStatuses) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/SubmissionTest.java b/src/test/java/org/tdl/vireo/model/SubmissionTest.java new file mode 100644 index 000000000..df8fcb948 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/SubmissionTest.java @@ -0,0 +1,198 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.Calendar; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; + +public class SubmissionTest extends AbstractModelTest { + + @InjectMocks + private Submission submission; + + /** + * The isApproveApplication() does not work via getParameterStream() and is manually tested here. + */ + @Test + public void testGetApproveApplication() { + boolean value = false; + + ReflectionTestUtils.setField(submission, "approveApplication", value); + + assertEquals(value, submission.isApproveApplication(), GETTER_MESSAGE); + } + + /** + * The setApproveApplication() does not work via setParameterStream() and is manually tested here. + */ + @Test + public void testSetApproveApplication() { + boolean value = false; + + // Set the flag to something other than false to confirm setter works. + ReflectionTestUtils.setField(submission, "approveApplication", true); + + submission.setApproveApplication(value); + + assertEquals(value, ReflectionTestUtils.getField(getInstance(), "approveApplication"), SETTER_MESSAGE); + } + + @Test + public void testClearApproveApplication() { + ReflectionTestUtils.setField(submission, "approveApplicationDate", Calendar.getInstance()); + ReflectionTestUtils.setField(submission, "approveApplication", true); + + submission.clearApproveApplication(); + + assertEquals(false, ReflectionTestUtils.getField(getInstance(), "approveApplication"), "Approve Application is not false."); + assertNull(ReflectionTestUtils.getField(getInstance(), "approveApplicationDate"), "Approve Application Date is not null."); + } + + @Test + public void testClearApproveAdvisor() { + ReflectionTestUtils.setField(submission, "approveAdvisorDate", Calendar.getInstance()); + ReflectionTestUtils.setField(submission, "approveAdvisor", true); + + submission.clearApproveAdvisor(); + + assertEquals(false, ReflectionTestUtils.getField(getInstance(), "approveAdvisor"), "Approve Advisor is not false."); + assertNull(ReflectionTestUtils.getField(getInstance(), "approveAdvisorDate"), "Approve Advisor Date is not null."); + } + + @Test + public void testClearApproveEmbargo() { + ReflectionTestUtils.setField(submission, "approveEmbargoDate", Calendar.getInstance()); + ReflectionTestUtils.setField(submission, "approveEmbargo", true); + + submission.clearApproveEmbargo(); + + assertEquals(false, ReflectionTestUtils.getField(getInstance(), "approveEmbargo"), "Approve Embargo is not false."); + assertNull(ReflectionTestUtils.getField(getInstance(), "approveEmbargoDate"), "Approve Embargo Date is not null."); + } + + @Test + public void testGenerateAdvisorAccessHash() { + ReflectionTestUtils.setField(getInstance(), "advisorAccessHash", ""); + + ReflectionTestUtils.invokeGetterMethod(submission, "generateAdvisorAccessHash"); + + String got = (String) ReflectionTestUtils.getField(getInstance(), "advisorAccessHash"); + + assertNotNull(got, "Advisor Access Hash is null."); + assertTrue(got.length() > 0, "Advisor Access Hash is an empty string."); + } + + @Test + public void testGetCommitteeContactEmail() { + Set fieldValues = new HashSet<>(); + List contacts = new ArrayList<>(); + FieldPredicate fieldPredicate1 = new FieldPredicate(); + FieldPredicate fieldPredicate2 = new FieldPredicate(); + FieldValue fieldValue1 = new FieldValue(); + FieldValue fieldValue2 = new FieldValue(); + + contacts.add("contact"); + fieldPredicate1.setId(1L); + fieldPredicate2.setId(1L); + fieldPredicate1.setValue("dc.contributor.advisor"); + fieldPredicate2.setValue("not.advisor"); + fieldValue1.setId(1L); + fieldValue2.setId(2L); + fieldValue1.setContacts(contacts); + fieldValue1.setValue("value1"); + fieldValue2.setValue("value2"); + fieldValue1.setFieldPredicate(fieldPredicate1); + fieldValue2.setFieldPredicate(fieldPredicate2); + fieldValues.add(fieldValue1); + fieldValues.add(fieldValue2); + + ReflectionTestUtils.setField(submission, "fieldValues", fieldValues); + + assertNotNull(submission.getCommitteeContactEmail(), "Committee Contact E-mail is null."); + assertEquals(contacts.get(0), submission.getCommitteeContactEmail(), "Committee Contact E-mail does not match."); + } + + @Test + public void testGetCommitteeContactEmailReturnsNull() { + Set fieldValues = new HashSet<>(); + List contacts = new ArrayList<>(); + FieldPredicate fieldPredicate1 = new FieldPredicate(); + FieldPredicate fieldPredicate2 = new FieldPredicate(); + FieldValue fieldValue1 = new FieldValue(); + FieldValue fieldValue2 = new FieldValue(); + + contacts.add("contact"); + fieldPredicate1.setId(1L); + fieldPredicate2.setId(1L); + fieldPredicate1.setValue("not.advisor"); + fieldPredicate2.setValue("not.advisor"); + fieldValue1.setId(1L); + fieldValue2.setId(2L); + fieldValue1.setContacts(contacts); + fieldValue1.setValue("value1"); + fieldValue2.setValue("value2"); + fieldValue1.setFieldPredicate(fieldPredicate1); + fieldValue2.setFieldPredicate(fieldPredicate2); + fieldValues.add(fieldValue1); + fieldValues.add(fieldValue2); + + ReflectionTestUtils.setField(submission, "fieldValues", fieldValues); + + assertNull(submission.getCommitteeContactEmail(), "Committee Contact E-mail is not null."); + } + + @Override + protected Submission getInstance() { + return submission; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + Set fieldValues = new HashSet<>(); + List submissionWorkflowSteps = new ArrayList<>(); + Set customActionValues = new HashSet<>(); + Set actionLogs = new HashSet<>(); + + return Stream.of( + Arguments.of("submitter", new User()), + Arguments.of("assignee", new User()), + Arguments.of("submissionStatus", new SubmissionStatus()), + Arguments.of("organization", new Organization()), + Arguments.of("fieldValues", fieldValues), + Arguments.of("submissionWorkflowSteps", submissionWorkflowSteps), + Arguments.of("approveEmbargoDate", Calendar.getInstance()), + Arguments.of("approveApplicationDate", Calendar.getInstance()), + Arguments.of("submissionDate", Calendar.getInstance()), + Arguments.of("approveAdvisorDate", Calendar.getInstance()), + Arguments.of("approveEmbargo", true), + Arguments.of("approveEmbargo", false), + Arguments.of("approveAdvisor", true), + Arguments.of("approveAdvisor", false), + Arguments.of("customActionValues", customActionValues), + Arguments.of("actionLogs", actionLogs), + Arguments.of("reviewerNotes", "value"), + Arguments.of("advisorAccessHash", "value"), + Arguments.of("advisorReviewURL", "value"), + Arguments.of("depositURL", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/SubmissionWorkflowStepTest.java b/src/test/java/org/tdl/vireo/model/SubmissionWorkflowStepTest.java new file mode 100644 index 000000000..86b5e50a5 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/SubmissionWorkflowStepTest.java @@ -0,0 +1,149 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import edu.tamu.weaver.data.model.WeaverEntity; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; +import org.tdl.vireo.model.inheritance.HeritableComponent; + +public class SubmissionWorkflowStepTest extends AbstractModelTest { + + @InjectMocks + private SubmissionWorkflowStep submissionWorkflowStep; + + @Test + public void testReorderAggregateFieldProfile() { + List fieldProfiles = new ArrayList<>(); + FieldProfile fieldProfile1 = new FieldProfile(); + FieldProfile fieldProfile2 = new FieldProfile(); + FieldPredicate fieldPredicate1 = new FieldPredicate(); + FieldPredicate fieldPredicate2 = new FieldPredicate(); + + fieldProfile1.setId(1L); + fieldProfile2.setId(2L); + + fieldPredicate1.setId(1L); + fieldPredicate2.setId(2L); + + fieldPredicate1.setValue("value1"); + fieldPredicate2.setValue("value2"); + + fieldProfile1.setFieldPredicate(fieldPredicate1); + fieldProfile2.setFieldPredicate(fieldPredicate2); + + fieldProfiles.add(fieldProfile1); + fieldProfiles.add(fieldProfile2); + + ReflectionTestUtils.setField(getInstance(), "aggregateFieldProfiles", fieldProfiles); + + // Warning: The re-order parameters use index + 1 location logic such that 1 represents index 0 and 2 represents index 1. + submissionWorkflowStep.reorderAggregateFieldProfile(1, 2); + + assertEquals(fieldProfiles.get(0), fieldProfile2, "Did not correctly re-order Aggregate Field Profile."); + assertEquals(fieldProfiles.get(1), fieldProfile1, "Did not correctly re-order Aggregate Field Profile."); + } + + @Test + public void testReorderAggregateNote() { + List notes = new ArrayList<>(); + Note note1 = new Note(); + Note note2 = new Note(); + + note1.setId(1L); + note2.setId(2L); + + notes.add(note1); + notes.add(note2); + + ReflectionTestUtils.setField(getInstance(), "aggregateNotes", notes); + + // Warning: The re-order parameters use index + 1 location logic such that 1 represents index 0 and 2 represents index 1. + submissionWorkflowStep.reorderAggregateNote(1, 2); + + assertEquals(notes.get(0), note2, "Did not correctly re-order Aggregate Note."); + assertEquals(notes.get(1), note1, "Did not correctly re-order Aggregate Note."); + } + + @Override + protected SubmissionWorkflowStep getInstance() { + return submissionWorkflowStep; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + List fieldProfiles = new ArrayList<>(); + fieldProfiles.add(new FieldProfile()); + + List notes = new ArrayList<>(); + notes.add(new Note()); + + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("overrideable", true), + Arguments.of("overrideable", false), + Arguments.of("aggregateFieldProfiles", fieldProfiles), + Arguments.of("aggregateNotes", notes), + Arguments.of("instructions", "instruction") + ); + } + + protected class OtherComponent implements HeritableComponent { + private Long id = 0L; + + @Override + public int compareTo(WeaverEntity arg0) { + return 0; + } + + @Override + public Long getId() { + return id; + } + + @Override + public void setId(Long arg0) { + this.id = arg0; + } + + @Override + public void setOriginating(Object originatingHeritableModel) { + } + + @Override + public Object getOriginating() { + return null; + } + + @Override + public void setOriginatingWorkflowStep(WorkflowStep originatingWorkflowStep) { + } + + @Override + public WorkflowStep getOriginatingWorkflowStep() { + return null; + } + + @Override + public Boolean getOverrideable() { + return null; + } + + @Override + public Object clone() { + return new Object(); + } + } +} diff --git a/src/test/java/org/tdl/vireo/model/UserTest.java b/src/test/java/org/tdl/vireo/model/UserTest.java new file mode 100644 index 000000000..dea9bfeaf --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/UserTest.java @@ -0,0 +1,239 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.TreeSet; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.security.core.GrantedAuthority; +import org.springframework.test.util.ReflectionTestUtils; + +public class UserTest extends AbstractModelTest { + + @InjectMocks + private User user; + + @Test + public void testUserInstantiation() { + user.setEmail("email"); + user.setFirstName("firstName"); + user.setLastName("lastName"); + user.setRole(Role.ROLE_ADMIN); + + User newUser = new User(user); + + assertEquals(newUser.getEmail(), user.getEmail(), "E-mail does not match."); + assertEquals(newUser.getFirstName(), user.getFirstName(), "First Name does not match."); + assertEquals(newUser.getLastName(), user.getLastName(), "Last Name does not match."); + assertEquals(newUser.getRole(), user.getRole(), "Role does not match."); + } + + /** + * The getSettings() does not work via getParameterStream() and is manually tested here. + */ + @Test + public void testGetSettings() { + Map settings = new HashMap<>(); + + ReflectionTestUtils.setField(user, "settings", settings); + + assertEquals(settings, user.getSettings(), GETTER_MESSAGE); + } + + /** + * The setSettings() does not work via setParameterStream() and is manually tested here. + */ + @Test + public void testSetSettings() { + Map settings = new HashMap<>(); + + user.setSettings(settings); + + assertEquals(settings, ReflectionTestUtils.getField(getInstance(), "settings"), SETTER_MESSAGE); + } + + @Test + public void testPutSetting() { + Map settings = new HashMap<>(); + String key = "key"; + String value = "value"; + + ReflectionTestUtils.setField(user, "settings", settings); + + user.putSetting(key, value); + + assertTrue(settings.containsKey(key), "Could not find key in the settings."); + assertEquals(settings.get(key), value, "The value for the key does not match the expected value."); + } + + @Test + public void testRemoveShibbolethAffiliation() { + TreeSet shibbolethAffiliations = new TreeSet<>(); + String shibbolethAffiliation = "affiliation"; + shibbolethAffiliations.add(shibbolethAffiliation); + + ReflectionTestUtils.setField(user, "shibbolethAffiliations", shibbolethAffiliations); + + user.removeShibbolethAffiliation(shibbolethAffiliation); + + assertFalse(shibbolethAffiliations.contains(shibbolethAffiliation), "The Shibboleth Affiliation is not removed."); + } + + @Test + public void testAddSubmissionViewColumn() { + List submissionViewColumns = new ArrayList<>(); + SubmissionListColumn submissionListColumn = new SubmissionListColumn(); + + submissionListColumn.setId(1L); + + ReflectionTestUtils.setField(user, "submissionViewColumns", submissionViewColumns); + + user.addSubmissionViewColumn(submissionListColumn); + + assertTrue(submissionViewColumns.contains(submissionListColumn), "The Submission View Column is not added."); + } + + @Test + public void testRemoveSubmissionViewColumn() { + List submissionViewColumns = new ArrayList<>(); + SubmissionListColumn submissionListColumn = new SubmissionListColumn(); + + submissionListColumn.setId(1L); + submissionViewColumns.add(submissionListColumn); + + ReflectionTestUtils.setField(user, "submissionViewColumns", submissionViewColumns); + + user.removeSubmissionViewColumn(submissionListColumn); + + assertFalse(submissionViewColumns.contains(submissionListColumn), "The Submission View Column is not removed."); + } + + @Test + public void testAddSavedFilter() { + List savedFilters = new ArrayList<>(); + NamedSearchFilterGroup namedSearchFilterGroup = new NamedSearchFilterGroup(); + + namedSearchFilterGroup.setId(1L); + + ReflectionTestUtils.setField(user, "savedFilters", savedFilters); + + user.addSavedFilter(namedSearchFilterGroup); + + assertTrue(savedFilters.contains(namedSearchFilterGroup), "The Saved Filter is not added."); + } + + @Test + public void testRemoveSavedFilter() { + List savedFilters = new ArrayList<>(); + NamedSearchFilterGroup namedSearchFilterGroup = new NamedSearchFilterGroup(); + + namedSearchFilterGroup.setId(1L); + savedFilters.add(namedSearchFilterGroup); + + ReflectionTestUtils.setField(user, "savedFilters", savedFilters); + + user.removeSavedFilter(namedSearchFilterGroup); + + assertFalse(savedFilters.contains(namedSearchFilterGroup), "The Saved Filter is not removed."); + } + + @Test + public void testLoadActiveFilter() { + NamedSearchFilterGroup activeFilter = new NamedSearchFilterGroup(); + NamedSearchFilterGroup namedSearchFilterGroup = new NamedSearchFilterGroup(); + List savedColumns = new ArrayList(); + Set namedSearchFilters = new HashSet<>(); + SubmissionListColumn submissionListColumn = new SubmissionListColumn(); + NamedSearchFilter namedSearchFilter = new NamedSearchFilter(); + + submissionListColumn.setId(1L); + savedColumns.add(submissionListColumn); + + namedSearchFilter.setId(1L); + namedSearchFilters.add(namedSearchFilter); + + activeFilter.setId(1L); + activeFilter.setPublicFlag(false); + activeFilter.setColumnsFlag(false); + + namedSearchFilterGroup.setId(2L); + namedSearchFilterGroup.setSavedColumns(savedColumns); + namedSearchFilterGroup.setNamedSearchFilters(namedSearchFilters); + namedSearchFilterGroup.setPublicFlag(true); + namedSearchFilterGroup.setColumnsFlag(true); + + ReflectionTestUtils.setField(user, "activeFilter", activeFilter); + + user.loadActiveFilter(namedSearchFilterGroup); + + assertEquals(activeFilter.getSavedColumns(), savedColumns, "The Saved Columns is not added."); + assertEquals(activeFilter.getNamedSearchFilters(), namedSearchFilters, "The Named Search Filters is not added."); + assertEquals(activeFilter.getPublicFlag(), namedSearchFilterGroup.getPublicFlag(), "The Public Flag is not set correctly."); + assertEquals(activeFilter.getColumnsFlag(), namedSearchFilterGroup.getColumnsFlag(), "The Columns Flag is not set correctly."); + } + + @SuppressWarnings("unchecked") + @Test + public void testGetAuthorities() { + Role role = Role.ROLE_MANAGER; + user.setRole(role); + + List authority = (List) user.getAuthorities(); + + assertEquals(authority.get(0).getAuthority(), role.toString(), "The expected role is not set as the authority."); + } + + @Override + protected User getInstance() { + return user; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + Set shibbolethAffiliations = new HashSet<>(); + List submissionViewColumns = new ArrayList<>(); + List filterColumns = new ArrayList<>(); + List savedFilters = new ArrayList<>(); + shibbolethAffiliations.add("value"); + + return Stream.of( + Arguments.of("netid", "value"), + Arguments.of("email", "value"), + Arguments.of("password", "value"), + Arguments.of("firstName", "value"), + Arguments.of("lastName", "value"), + Arguments.of("middleName", "value"), + Arguments.of("name", "value"), + Arguments.of("birthYear", 123), + Arguments.of("shibbolethAffiliations", shibbolethAffiliations), + Arguments.of("currentContactInfo", new ContactInfo()), + Arguments.of("permanentContactInfo", new ContactInfo()), + Arguments.of("role", Role.ROLE_ADMIN), + Arguments.of("role", Role.ROLE_ANONYMOUS), + Arguments.of("orcid", "value"), + Arguments.of("pageSize", 123), + Arguments.of("submissionViewColumns", submissionViewColumns), + Arguments.of("filterColumns", filterColumns), + Arguments.of("activeFilter", new NamedSearchFilterGroup()), + Arguments.of("savedFilters", savedFilters) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/ValidationTest.java b/src/test/java/org/tdl/vireo/model/ValidationTest.java new file mode 100644 index 000000000..568333d69 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/ValidationTest.java @@ -0,0 +1,32 @@ +package org.tdl.vireo.model; + +import java.util.stream.Stream; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; + +public class ValidationTest extends AbstractModelTest { + + @InjectMocks + private Validation validation; + + @Override + protected Validation getInstance() { + return validation; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + return Stream.of( + Arguments.of("pattern", "value"), + Arguments.of("message", "value") + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/VocabularyWordTest.java b/src/test/java/org/tdl/vireo/model/VocabularyWordTest.java new file mode 100644 index 000000000..4b7a3f84c --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/VocabularyWordTest.java @@ -0,0 +1,97 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.mockito.Mockito; +import org.springframework.test.util.ReflectionTestUtils; + +public class VocabularyWordTest extends AbstractModelTest { + + @InjectMocks + private VocabularyWord vocabularyWord; + + @Test + public void testVocabularyWordInstantiation1() { + List contacts = new ArrayList<>(); + contacts.add("contact"); + + vocabularyWord.setName("name"); + vocabularyWord.setDefinition("definition"); + vocabularyWord.setIdentifier("identifier"); + vocabularyWord.setContacts(contacts); + + VocabularyWord newVocabularyWord = new VocabularyWord(vocabularyWord.getName(), vocabularyWord.getDefinition(), vocabularyWord.getIdentifier(), vocabularyWord.getContacts()); + + assertEquals(newVocabularyWord.getName(), vocabularyWord.getName(), "Name does not match."); + assertEquals(newVocabularyWord.getDefinition(), vocabularyWord.getDefinition(), "Definition does not match."); + assertEquals(newVocabularyWord.getIdentifier(), vocabularyWord.getIdentifier(), "Identifier does not match."); + assertEquals(newVocabularyWord.getContacts(), vocabularyWord.getContacts(), "Contacts does not match."); + } + + @Test + public void testVocabularyWordInstantiation2() { + ControlledVocabulary controlledVocabulary = new ControlledVocabulary(); + List contacts = new ArrayList<>(); + + controlledVocabulary.setId(1L); + contacts.add("contact"); + + vocabularyWord.setControlledVocabulary(controlledVocabulary); + vocabularyWord.setName("name"); + vocabularyWord.setDefinition("definition"); + vocabularyWord.setIdentifier("identifier"); + vocabularyWord.setContacts(contacts); + + VocabularyWord newVocabularyWord = new VocabularyWord(controlledVocabulary, vocabularyWord.getName(), vocabularyWord.getDefinition(), vocabularyWord.getIdentifier(), vocabularyWord.getContacts()); + + assertEquals(newVocabularyWord.getControlledVocabulary(), vocabularyWord.getControlledVocabulary(), "Controlled Vocabulary does not match."); + assertEquals(newVocabularyWord.getName(), vocabularyWord.getName(), "Name does not match."); + assertEquals(newVocabularyWord.getDefinition(), vocabularyWord.getDefinition(), "Definition does not match."); + assertEquals(newVocabularyWord.getIdentifier(), vocabularyWord.getIdentifier(), "Identifier does not match."); + assertEquals(newVocabularyWord.getContacts(), vocabularyWord.getContacts(), "Contacts does not match."); + } + + @Test + public void testSetContactsPassingNull() { + List contacts = Mockito.spy(new ArrayList<>()); + + ReflectionTestUtils.setField(vocabularyWord, "contacts", contacts); + + vocabularyWord.setContacts(null); + + Mockito.verifyNoInteractions(contacts); + } + + @Override + protected VocabularyWord getInstance() { + return vocabularyWord; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + List contacts = new ArrayList<>(); + contacts.add("contact"); + + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("definition", "value"), + Arguments.of("identifier", "value"), + Arguments.of("contacts", contacts), + Arguments.of("controlledVocabulary", new ControlledVocabulary()) + ); + } + +} diff --git a/src/test/java/org/tdl/vireo/model/WorkflowStepTest.java b/src/test/java/org/tdl/vireo/model/WorkflowStepTest.java new file mode 100644 index 000000000..34ad0c6c7 --- /dev/null +++ b/src/test/java/org/tdl/vireo/model/WorkflowStepTest.java @@ -0,0 +1,490 @@ +package org.tdl.vireo.model; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import edu.tamu.weaver.data.model.WeaverEntity; +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Stream; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.provider.Arguments; +import org.mockito.InjectMocks; +import org.springframework.test.util.ReflectionTestUtils; +import org.tdl.vireo.model.inheritance.HeritableComponent; + +public class WorkflowStepTest extends AbstractModelTest { + + @InjectMocks + private WorkflowStep workflowStep; + + @Test + public void testReplaceOriginalFieldProfileOnFound() { + List originalFPs = new ArrayList<>(); + FieldProfile originalFP1 = new FieldProfile(); + FieldProfile originalFP2 = new FieldProfile(); + FieldProfile newFP = new FieldProfile(); + + originalFP1.setId(1L); + originalFP2.setId(2L); + newFP.setId(3L); + + originalFPs.add(originalFP1); + originalFPs.add(originalFP2); + + workflowStep.setOriginalFieldProfiles(originalFPs); + workflowStep.setAggregateFieldProfiles(originalFPs); + + Boolean found = workflowStep.replaceOriginalFieldProfile(originalFP2, newFP); + + assertTrue(found, "The Field Profile did not get replaced."); + + assertTrue(workflowStep.getOriginalFieldProfiles().contains(newFP), "The new Field Profile is not found."); + assertFalse(workflowStep.getOriginalFieldProfiles().contains(originalFP2), "The old Field Profile is found."); + + assertTrue(workflowStep.getAggregateFieldProfiles().contains(newFP), "The new Field Profile is not found in the Aggregate Field Profiles."); + assertFalse(workflowStep.getAggregateFieldProfiles().contains(originalFP2), "The old Field Profile is found in the Aggregate Field Profiles."); + } + + @Test + public void testReplaceOriginalFieldProfileOnNotFound() { + List originalFPs = new ArrayList<>(); + FieldProfile originalFP1 = new FieldProfile(); + FieldProfile originalFP2 = new FieldProfile(); + FieldProfile newFP = new FieldProfile(); + FieldProfile otherFP = new FieldProfile(); + + originalFP1.setId(1L); + originalFP2.setId(2L); + newFP.setId(3L); + otherFP.setId(4L); + + originalFPs.add(originalFP1); + originalFPs.add(originalFP2); + + workflowStep.setOriginalFieldProfiles(originalFPs); + workflowStep.setAggregateFieldProfiles(originalFPs); + + Boolean found = workflowStep.replaceOriginalFieldProfile(otherFP, newFP); + + assertFalse(found, "The Field Profile did get replaced."); + + assertFalse(workflowStep.getOriginalFieldProfiles().contains(newFP), "The new Field Profile is found."); + assertFalse(workflowStep.getOriginalFieldProfiles().contains(otherFP), "The old Field Profile is found."); + + assertFalse(workflowStep.getAggregateFieldProfiles().contains(newFP), "The new Field Profile is found in the Aggregate Field Profiles."); + assertFalse(workflowStep.getAggregateFieldProfiles().contains(otherFP), "The old Field Profile is found in the Aggregate Field Profiles."); + } + + @Test + public void testGetFieldProfileByPredicateOnFound() { + List fieldProfiles = new ArrayList<>(); + FieldProfile fieldProfile1 = new FieldProfile(); + FieldProfile fieldProfile2 = new FieldProfile(); + FieldPredicate fieldPredicate1 = new FieldPredicate(); + FieldPredicate fieldPredicate2 = new FieldPredicate(); + + fieldProfile1.setId(1L); + fieldProfile2.setId(2L); + + fieldPredicate1.setId(1L); + fieldPredicate2.setId(2L); + + fieldPredicate1.setValue("value1"); + fieldPredicate2.setValue("value2"); + + fieldProfile1.setFieldPredicate(fieldPredicate1); + fieldProfile2.setFieldPredicate(fieldPredicate2); + + fieldProfiles.add(fieldProfile1); + fieldProfiles.add(fieldProfile2); + + workflowStep.setOriginalFieldProfiles(fieldProfiles); + workflowStep.setAggregateFieldProfiles(fieldProfiles); + + FieldProfile got = workflowStep.getFieldProfileByPredicate(fieldPredicate2); + + assertEquals(got, fieldProfile2, "Did not correctly find Field Profile."); + } + + @Test + public void testGetFieldProfileByPredicateOnNotFound() { + List fieldProfiles = new ArrayList<>(); + FieldProfile fieldProfile1 = new FieldProfile(); + FieldProfile fieldProfile2 = new FieldProfile(); + FieldProfile fieldProfile3 = new FieldProfile(); + FieldPredicate fieldPredicate1 = new FieldPredicate(); + FieldPredicate fieldPredicate2 = new FieldPredicate(); + FieldPredicate fieldPredicate3 = new FieldPredicate(); + + fieldProfile1.setId(1L); + fieldProfile2.setId(2L); + fieldProfile3.setId(3L); + + fieldPredicate1.setId(1L); + fieldPredicate2.setId(2L); + fieldPredicate3.setId(3L); + + fieldPredicate1.setValue("value1"); + fieldPredicate2.setValue("value2"); + fieldPredicate3.setValue("value3"); + + fieldProfile1.setFieldPredicate(fieldPredicate1); + fieldProfile2.setFieldPredicate(fieldPredicate2); + fieldProfile3.setFieldPredicate(fieldPredicate3); + + fieldProfiles.add(fieldProfile1); + fieldProfiles.add(fieldProfile2); + + workflowStep.setOriginalFieldProfiles(fieldProfiles); + workflowStep.setAggregateFieldProfiles(fieldProfiles); + + FieldProfile got = workflowStep.getFieldProfileByPredicate(fieldPredicate3); + + assertNull(got, "Must not find Field Profile."); + } + + @Test + public void testReplaceOriginalNoteOnFound() { + List originalNotes = new ArrayList<>(); + Note originalNote1 = new Note(); + Note originalNote2 = new Note(); + Note newNote = new Note(); + + originalNote1.setId(1L); + originalNote2.setId(2L); + newNote.setId(3L); + + originalNotes.add(originalNote1); + originalNotes.add(originalNote2); + + workflowStep.setOriginalNotes(originalNotes); + workflowStep.setAggregateNotes(originalNotes); + + Boolean found = workflowStep.replaceOriginalNote(originalNote2, newNote); + + assertTrue(found, "The Field Profile did not get replaced."); + + assertTrue(workflowStep.getOriginalNotes().contains(newNote), "The new Note is not found."); + assertFalse(workflowStep.getOriginalNotes().contains(originalNote2), "The old Note is found."); + + assertTrue(workflowStep.getAggregateNotes().contains(newNote), "The new Note is not found in the Aggregate Notes."); + assertFalse(workflowStep.getAggregateNotes().contains(originalNote2), "The old Note is found in the Aggregate Notes."); + } + + @Test + public void testReplaceOriginalNoteOnNotFound() { + List originalNotes = new ArrayList<>(); + Note originalNote1 = new Note(); + Note originalNote2 = new Note(); + Note newNote = new Note(); + Note otherNote = new Note(); + + originalNote1.setId(1L); + originalNote2.setId(2L); + newNote.setId(3L); + otherNote.setId(4L); + + originalNotes.add(originalNote1); + originalNotes.add(originalNote2); + + workflowStep.setOriginalNotes(originalNotes); + workflowStep.setAggregateNotes(originalNotes); + + Boolean found = workflowStep.replaceOriginalNote(otherNote, newNote); + + assertFalse(found, "The Note did get replaced."); + + assertFalse(workflowStep.getOriginalNotes().contains(newNote), "The new Note is found."); + assertFalse(workflowStep.getOriginalNotes().contains(otherNote), "The old Note is found."); + + assertFalse(workflowStep.getAggregateNotes().contains(newNote), "The new Note is found in the Aggregate Notes."); + assertFalse(workflowStep.getAggregateNotes().contains(otherNote), "The old Note is found in the Aggregate Notes."); + } + + @Test + public void testAddOriginalHeritableModelUsingNote() { + List originalNotes = new ArrayList<>(); + List aggregateNotes = new ArrayList<>(); + List originalFieldProfiles = new ArrayList<>(); + List aggregateFieldProfiles = new ArrayList<>(); + Note newNote = new Note(); + + newNote.setId(1L); + + workflowStep.setOriginalNotes(originalNotes); + workflowStep.setAggregateNotes(aggregateNotes); + + workflowStep.setOriginalFieldProfiles(originalFieldProfiles); + workflowStep.setAggregateFieldProfiles(aggregateFieldProfiles); + + workflowStep.addOriginalHeritableModel(newNote); + + assertTrue(workflowStep.getOriginalNotes().contains(newNote), "The new Note is not found."); + assertEquals(workflowStep.getOriginalFieldProfiles().size(), 0, "The Original Field Profiles have a non-zero length."); + + assertTrue(workflowStep.getAggregateNotes().contains(newNote), "The new Note is not found in the Aggregate Notes."); + assertEquals(workflowStep.getAggregateFieldProfiles().size(), 0, "The Aggregate Field Profiles have a non-zero length."); + } + + @Test + public void testAddOriginalHeritableModelUsingFieldProfile() { + List originalNotes = new ArrayList<>(); + List aggregateNotes = new ArrayList<>(); + List originalFieldProfiles = new ArrayList<>(); + List aggregateFieldProfiles = new ArrayList<>(); + FieldProfile newFieldProfile = new FieldProfile(); + + newFieldProfile.setId(1L); + + workflowStep.setOriginalNotes(originalNotes); + workflowStep.setAggregateNotes(aggregateNotes); + + workflowStep.setOriginalFieldProfiles(originalFieldProfiles); + workflowStep.setAggregateFieldProfiles(aggregateFieldProfiles); + + workflowStep.addOriginalHeritableModel(newFieldProfile); + + assertTrue(workflowStep.getOriginalFieldProfiles().contains(newFieldProfile), "The new Note is not found."); + assertEquals(workflowStep.getOriginalNotes().size(), 0, "The Original Notes have a non-zero length."); + + assertTrue(workflowStep.getAggregateFieldProfiles().contains(newFieldProfile), "The new Note is not found in the Aggregate Notes."); + assertEquals(workflowStep.getAggregateNotes().size(), 0, "The Aggregate Notes have a non-zero length."); + } + + @Test + public void testAddOriginalHeritableModelUsingOther() { + List originalNotes = new ArrayList<>(); + List aggregateNotes = new ArrayList<>(); + List originalFieldProfiles = new ArrayList<>(); + List aggregateFieldProfiles = new ArrayList<>(); + OtherComponent newComponent = new OtherComponent(); + + newComponent.setId(1L); + + workflowStep.setOriginalNotes(originalNotes); + workflowStep.setAggregateNotes(aggregateNotes); + + workflowStep.setOriginalFieldProfiles(originalFieldProfiles); + workflowStep.setAggregateFieldProfiles(aggregateFieldProfiles); + + workflowStep.addOriginalHeritableModel(newComponent); + + assertEquals(workflowStep.getOriginalFieldProfiles().size(), 0, "The Original Field Profiles have a non-zero length."); + assertEquals(workflowStep.getOriginalNotes().size(), 0, "The Original Notes have a non-zero length."); + + assertEquals(workflowStep.getAggregateFieldProfiles().size(), 0, "The Aggregate Field Profiles have a non-zero length."); + assertEquals(workflowStep.getAggregateNotes().size(), 0, "The Aggregate Notes have a non-zero length."); + } + + @Test + public void testAddAggregateHeritableModelUsingNote() { + List originalNotes = new ArrayList<>(); + List aggregateNotes = new ArrayList<>(); + List originalFieldProfiles = new ArrayList<>(); + List aggregateFieldProfiles = new ArrayList<>(); + Note newNote = new Note(); + + newNote.setId(1L); + + workflowStep.setOriginalNotes(originalNotes); + workflowStep.setAggregateNotes(aggregateNotes); + + workflowStep.setOriginalFieldProfiles(originalFieldProfiles); + workflowStep.setAggregateFieldProfiles(aggregateFieldProfiles); + + workflowStep.addAggregateHeritableModel(newNote); + + assertEquals(workflowStep.getOriginalNotes().size(), 0, "The Original Notes have a non-zero length."); + assertEquals(workflowStep.getOriginalFieldProfiles().size(), 0, "The Original Field Profiles have a non-zero length."); + + assertTrue(workflowStep.getAggregateNotes().contains(newNote), "The new Note is not found in the Aggregate Notes."); + assertEquals(workflowStep.getAggregateFieldProfiles().size(), 0, "The Aggregate Field Profiles have a non-zero length."); + } + + @Test + public void testAddAggregateHeritableModelUsingFieldProfile() { + List originalNotes = new ArrayList<>(); + List aggregateNotes = new ArrayList<>(); + List originalFieldProfiles = new ArrayList<>(); + List aggregateFieldProfiles = new ArrayList<>(); + FieldProfile newFieldProfile = new FieldProfile(); + + newFieldProfile.setId(1L); + + workflowStep.setOriginalNotes(originalNotes); + workflowStep.setAggregateNotes(aggregateNotes); + + workflowStep.setOriginalFieldProfiles(originalFieldProfiles); + workflowStep.setAggregateFieldProfiles(aggregateFieldProfiles); + + workflowStep.addAggregateHeritableModel(newFieldProfile); + + assertEquals(workflowStep.getOriginalFieldProfiles().size(), 0, "The Original Field Profiles have a non-zero length."); + assertEquals(workflowStep.getOriginalNotes().size(), 0, "The Original Notes have a non-zero length."); + + assertTrue(workflowStep.getAggregateFieldProfiles().contains(newFieldProfile), "The new Note is not found in the Aggregate Notes."); + assertEquals(workflowStep.getAggregateNotes().size(), 0, "The Aggregate Notes have a non-zero length."); + } + + @Test + public void testAddAggregateHeritableModelUsingOther() { + List originalNotes = new ArrayList<>(); + List aggregateNotes = new ArrayList<>(); + List originalFieldProfiles = new ArrayList<>(); + List aggregateFieldProfiles = new ArrayList<>(); + OtherComponent newComponent = new OtherComponent(); + + newComponent.setId(1L); + + workflowStep.setOriginalNotes(originalNotes); + workflowStep.setAggregateNotes(aggregateNotes); + + workflowStep.setOriginalFieldProfiles(originalFieldProfiles); + workflowStep.setAggregateFieldProfiles(aggregateFieldProfiles); + + workflowStep.addAggregateHeritableModel(newComponent); + + assertEquals(workflowStep.getOriginalFieldProfiles().size(), 0, "The Original Field Profiles have a non-zero length."); + assertEquals(workflowStep.getOriginalNotes().size(), 0, "The Original Notes have a non-zero length."); + + assertEquals(workflowStep.getAggregateFieldProfiles().size(), 0, "The Aggregate Field Profiles have a non-zero length."); + assertEquals(workflowStep.getAggregateNotes().size(), 0, "The Aggregate Notes have a non-zero length."); + } + + @Test + public void testReorderAggregateFieldProfile() { + List fieldProfiles = new ArrayList<>(); + FieldProfile fieldProfile1 = new FieldProfile(); + FieldProfile fieldProfile2 = new FieldProfile(); + FieldPredicate fieldPredicate1 = new FieldPredicate(); + FieldPredicate fieldPredicate2 = new FieldPredicate(); + + fieldProfile1.setId(1L); + fieldProfile2.setId(2L); + + fieldPredicate1.setId(1L); + fieldPredicate2.setId(2L); + + fieldPredicate1.setValue("value1"); + fieldPredicate2.setValue("value2"); + + fieldProfile1.setFieldPredicate(fieldPredicate1); + fieldProfile2.setFieldPredicate(fieldPredicate2); + + fieldProfiles.add(fieldProfile1); + fieldProfiles.add(fieldProfile2); + + ReflectionTestUtils.setField(getInstance(), "aggregateFieldProfiles", fieldProfiles); + + // Warning: The re-order parameters use index + 1 location logic such that 1 represents index 0 and 2 represents index 1. + workflowStep.reorderAggregateFieldProfile(1, 2); + + assertEquals(fieldProfiles.get(0), fieldProfile2, "Did not correctly re-order Aggregate Field Profile."); + assertEquals(fieldProfiles.get(1), fieldProfile1, "Did not correctly re-order Aggregate Field Profile."); + } + + @Test + public void testReorderAggregateNote() { + List notes = new ArrayList<>(); + Note note1 = new Note(); + Note note2 = new Note(); + + note1.setId(1L); + note2.setId(2L); + + notes.add(note1); + notes.add(note2); + + ReflectionTestUtils.setField(getInstance(), "aggregateNotes", notes); + + // Warning: The re-order parameters use index + 1 location logic such that 1 represents index 0 and 2 represents index 1. + workflowStep.reorderAggregateNote(1, 2); + + assertEquals(notes.get(0), note2, "Did not correctly re-order Aggregate Note."); + assertEquals(notes.get(1), note1, "Did not correctly re-order Aggregate Note."); + } + + @Override + protected WorkflowStep getInstance() { + return workflowStep; + } + + protected static Stream provideGetterParameters() { + return getParameterStream(); + } + + protected static Stream provideSetterParameters() { + return getParameterStream(); + } + + private static Stream getParameterStream() { + List fieldProfiles = new ArrayList<>(); + fieldProfiles.add(new FieldProfile()); + + List notes = new ArrayList<>(); + notes.add(new Note()); + + return Stream.of( + Arguments.of("name", "value"), + Arguments.of("overrideable", true), + Arguments.of("overrideable", false), + Arguments.of("aggregateFieldProfiles", fieldProfiles), + Arguments.of("aggregateNotes", notes), + Arguments.of("instructions", "instruction"), + Arguments.of("originatingOrganization", new Organization()), + Arguments.of("originatingWorkflowStep", new WorkflowStep()), + Arguments.of("originalFieldProfiles", fieldProfiles), + Arguments.of("originalNotes", notes) + ); + } + + protected class OtherComponent implements HeritableComponent { + private Long id = 0L; + + @Override + public int compareTo(WeaverEntity arg0) { + return 0; + } + + @Override + public Long getId() { + return id; + } + + @Override + public void setId(Long arg0) { + this.id = arg0; + } + + @Override + public void setOriginating(Object originatingHeritableModel) { + } + + @Override + public Object getOriginating() { + return null; + } + + @Override + public void setOriginatingWorkflowStep(WorkflowStep originatingWorkflowStep) { + } + + @Override + public WorkflowStep getOriginatingWorkflowStep() { + return null; + } + + @Override + public Boolean getOverrideable() { + return null; + } + + @Override + public Object clone() { + return new Object(); + } + } +}