@Test
public void isTemplateInUse() {
// create the template owned by ident1
final PortfolioStructureMap template =
epStructureManager.createPortfolioMapTemplate(
ident1, "Template in user", "Template in use");
dbInstance.saveObject(template);
dbInstance.commitAndCloseSession();
// add a page to it
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(template, "Page title", "Page description");
assertNotNull(page1);
dbInstance.commitAndCloseSession();
// check: the template is not in use
assertFalse(epFrontendManager.isTemplateInUse(template, null, null, null));
// use the template: assign the template to ident2
final PortfolioStructureMap map =
epFrontendManager.assignStructuredMapToUser(ident2, template, null, null, null, null);
assertNotNull(map);
dbInstance.commitAndCloseSession();
// check: the template is in use
assertTrue(epFrontendManager.isTemplateInUse(template, null, null, null));
}
@Test
public void allUserPolicies() {
// create a map
final PortfolioStructureMap map =
epFrontendManager.createAndPersistPortfolioDefaultMap(ident1, "Policies", "Description");
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(map, "Page policies", "Page description");
assertNotNull(page1);
dbInstance.commitAndCloseSession();
// check visiblity (is owner)
assertTrue(epFrontendManager.isMapVisible(ident1, map.getOlatResource()));
// check visibility (no policy)
assertFalse(epFrontendManager.isMapVisible(ident2, map.getOlatResource()));
// check not visible (no policy)
assertFalse(epFrontendManager.isMapVisible(ident3, map.getOlatResource()));
// add all user policy
final EPMapPolicy userPolicy = new EPMapPolicy();
userPolicy.setType(Type.allusers);
epFrontendManager.updateMapPolicies(map, Collections.singletonList(userPolicy));
dbInstance.commitAndCloseSession();
// one policy
final List<EPMapPolicy> policies1 = epFrontendManager.getMapPolicies(map);
assertEquals(1, policies1.size());
// check visiblity (is owner)
assertTrue(epFrontendManager.isMapVisible(ident1, map.getOlatResource()));
// check visibility (is user)
assertTrue(epFrontendManager.isMapVisible(ident2, map.getOlatResource()));
// check not visible (is user)
assertTrue(epFrontendManager.isMapVisible(ident3, map.getOlatResource()));
}
/** testGetAllResourceTypeNames */
@Test
public void testGetAllResourceTypeNames() {
// create resource, identity and group
OLATResource ores = JunitTestHelper.createRandomResource();
Identity identity =
JunitTestHelper.createAndPersistIdentityAsUser("prop-3-" + UUID.randomUUID().toString());
BusinessGroup group =
businessGroupService.createBusinessGroup(
identity, "a buddygroup", "a desc", -1, -1, false, false, null);
dbInstance.commitAndCloseSession();
// create a property
Property p =
pm.createPropertyInstance(
identity,
group,
ores,
"catall",
"TestProperty",
new Float(1.1),
new Long(123456),
"stringValue",
"textValue");
pm.saveProperty(p);
dbInstance.commitAndCloseSession();
Assert.assertNotNull(p.getResourceTypeName());
List<String> resTypeNames = pm.getAllResourceTypeNames();
assertTrue(resTypeNames.contains(ores.getResourceableTypeName()));
}
/**
* Create 2 pseudo nodes in a course, and delete the task of the first node and check that the
* task of second are always there.
*/
@Test
public void deleteTaskList_parano() {
Identity coach = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-9");
Identity participant = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-10");
BusinessGroup businessGroup =
businessGroupDao.createAndPersist(
coach, "gdao", "gdao-desc", -1, -1, false, false, false, false, false);
businessGroupRelationDao.addRole(participant, businessGroup, GroupRole.participant.name());
dbInstance.commit();
RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry("", false);
// node 1
GTACourseNode node1 = new GTACourseNode();
node1.getModuleConfiguration().setStringValue(GTACourseNode.GTASK_TYPE, GTAType.group.name());
TaskList tasks1 = gtaManager.createIfNotExists(re, node1);
File taskFile = new File("bg.txt");
Assert.assertNotNull(tasks1);
dbInstance.commit();
// node 2
GTACourseNode node2 = new GTACourseNode();
node2.getModuleConfiguration().setStringValue(GTACourseNode.GTASK_TYPE, GTAType.group.name());
TaskList tasks2 = gtaManager.createIfNotExists(re, node2);
Assert.assertNotNull(tasks2);
dbInstance.commit();
// select node 1
AssignmentResponse response1 = gtaManager.selectTask(businessGroup, tasks1, node1, taskFile);
dbInstance.commitAndCloseSession();
Assert.assertNotNull(response1);
// select node 2
AssignmentResponse response2 = gtaManager.selectTask(businessGroup, tasks2, node2, taskFile);
dbInstance.commitAndCloseSession();
Assert.assertNotNull(response2);
// check that there is tasks
List<Task> assignedTasks1 = gtaManager.getTasks(participant, re, node1);
Assert.assertNotNull(assignedTasks1);
Assert.assertEquals(1, assignedTasks1.size());
List<Task> assignedTasks2 = gtaManager.getTasks(participant, re, node2);
Assert.assertNotNull(assignedTasks2);
Assert.assertEquals(1, assignedTasks2.size());
// delete
int numOfDeletedObjects = gtaManager.deleteTaskList(re, node1);
Assert.assertEquals(2, numOfDeletedObjects);
dbInstance.commitAndCloseSession();
// check that there isn't any tasks in node 1
List<Task> deletedAssignedTasks = gtaManager.getTasks(participant, re, node1);
Assert.assertNotNull(deletedAssignedTasks);
Assert.assertEquals(0, deletedAssignedTasks.size());
// but always in node 2
List<Task> notDeletedAssignedTasks2 = gtaManager.getTasks(participant, re, node2);
Assert.assertNotNull(notDeletedAssignedTasks2);
Assert.assertEquals(1, notDeletedAssignedTasks2.size());
}
@Test
public void removePolicyWithInvitation() {
// create a map
final PortfolioStructureMap map =
epFrontendManager.createAndPersistPortfolioDefaultMap(
ident1, "Remove policies", "Description");
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(map, "Page policies", "Page description");
assertNotNull(page1);
dbInstance.commitAndCloseSession();
// save a list of policies
final List<EPMapPolicy> policies = new ArrayList<EPMapPolicy>();
// invitation
final Invitation invitation = securityManager.createAndPersistInvitation();
invitation.setFirstName("John");
invitation.setLastName("Doe");
invitation.setMail("*****@*****.**");
final EPMapPolicy invitationPolicy = new EPMapPolicy();
invitationPolicy.setType(Type.invitation);
invitationPolicy.setInvitation(invitation);
policies.add(invitationPolicy);
epFrontendManager.updateMapPolicies(map, policies);
dbInstance.commitAndCloseSession();
// remove the policy
policies.clear();
epFrontendManager.updateMapPolicies(map, policies);
dbInstance.commitAndCloseSession();
// check if the policies and the invitation are deleted
final List<EPMapPolicy> deletedPolicies = epFrontendManager.getMapPolicies(map);
assertNotNull(deletedPolicies);
assertTrue(deletedPolicies.isEmpty());
}
@Test
public void searchOwnedBinders() {
Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("binder-owner-");
Binder binder =
portfolioService.createNewBinder("Binder 2", "Binder with one section.", null, owner);
dbInstance.commitAndCloseSession();
portfolioService.appendNewSection("First section", "My first section.", null, null, binder);
dbInstance.commitAndCloseSession();
portfolioService.appendNewSection("Second section", "My second section.", null, null, binder);
dbInstance.commitAndCloseSession();
List<Section> sections = portfolioService.getSections(binder);
for (int i = 0; i < 2; i++) {
Section section = sections.get(1);
portfolioService.appendNewPage(owner, "Page-1-" + i, "", null, null, section);
portfolioService.appendNewPage(owner, "Page-2-" + i, "", null, null, section);
}
List<BinderStatistics> rows = portfolioService.searchOwnedBinders(owner);
Assert.assertNotNull(rows);
Assert.assertEquals(1, rows.size());
BinderStatistics myBinder = rows.get(0);
Assert.assertEquals(2, myBinder.getNumOfSections());
Assert.assertEquals(4, myBinder.getNumOfPages());
}
/** testUserInsertFindDelete */
@Test
public void testUserInsertFindDelete() {
// create identity and property
Identity id =
JunitTestHelper.createAndPersistIdentityAsUser("user-prop-" + UUID.randomUUID().toString());
Property p =
pm.createUserPropertyInstance(
id,
"catuser",
"TestProperty",
new Float(1.1),
new Long(123456),
"stringValue",
"textValue");
pm.saveProperty(p);
dbInstance.commitAndCloseSession();
p = pm.findUserProperty(id, "catuser", "TestProperty");
assertNotNull(p);
assertEquals(p.getStringValue(), "stringValue");
assertEquals(p.getFloatValue(), new Float(1.1));
assertEquals(p.getTextValue(), "textValue");
pm.deleteProperty(p);
p = pm.findUserProperty(id, "catuser", "TestProperty");
assertNull(p);
dbInstance.commitAndCloseSession();
}
/** Same workflow as the repository. This workflow is pretty critical. */
@Test
public void isStructuredMapOwner() {
final OLATResource resource = epStructureManager.createPortfolioMapTemplateResource();
// create a repository entry
final RepositoryEntry addedEntry =
repositoryManager.createRepositoryEntryInstance(ident1.getName());
addedEntry.setCanDownload(false);
addedEntry.setCanLaunch(true);
addedEntry.setDisplayname("test repo");
addedEntry.setResourcename("-");
addedEntry.setAccess(RepositoryEntry.ACC_OWNERS);
// Set the resource on the repository entry and save the entry.
final OLATResource ores = resourceManager.findOrPersistResourceable(resource);
addedEntry.setOlatResource(ores);
// create security group
final SecurityGroup newGroup = securityManager.createAndPersistSecurityGroup();
securityManager.createAndPersistPolicy(newGroup, Constants.PERMISSION_ACCESS, newGroup);
securityManager.createAndPersistPolicy(
newGroup, Constants.PERMISSION_HASROLE, EPStructureManager.ORES_MAPOWNER);
securityManager.addIdentityToSecurityGroup(ident1, newGroup);
addedEntry.setOwnerGroup(newGroup);
repositoryManager.saveRepositoryEntry(addedEntry);
dbInstance.commitAndCloseSession();
// create the template owned by ident1
final PortfolioStructureMap template =
epStructureManager.createAndPersistPortfolioMapTemplateFromEntry(ident1, addedEntry);
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(template, "Page title", "Page description");
assertNotNull(page1);
dbInstance.commitAndCloseSession();
// assign the template to ident2
final PortfolioStructureMap map =
epFrontendManager.assignStructuredMapToUser(ident2, template, null, null, null, null);
assertNotNull(map);
dbInstance.commitAndCloseSession();
// check if ident2 is owner of the map
assertTrue(epFrontendManager.isMapOwner(ident2, map.getOlatResource()));
// check if ident1 is not the owner of the map
assertFalse(epFrontendManager.isMapOwner(ident1, map.getOlatResource()));
// check if ident1 is owner of the template
assertTrue(epFrontendManager.isMapOwner(ident1, template.getOlatResource()));
}
@Test
public void mergeTwoUserPolicies() {
// create a map
final PortfolioStructureMap map =
epFrontendManager.createAndPersistPortfolioDefaultMap(
ident1, "Remove policies", "Description");
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(map, "Page policies", "Page description");
assertNotNull(page1);
dbInstance.commitAndCloseSession();
// save a list of policies
final List<EPMapPolicy> policies = new ArrayList<EPMapPolicy>();
// first user policy
final EPMapPolicy userPolicy1 = new EPMapPolicy();
userPolicy1.setType(Type.user);
userPolicy1.getIdentities().add(ident2);
userPolicy1.getIdentities().add(ident3);
policies.add(userPolicy1);
// second user policy
final EPMapPolicy userPolicy2 = new EPMapPolicy();
userPolicy2.setType(Type.user);
userPolicy2.getIdentities().add(ident1);
policies.add(userPolicy2);
epFrontendManager.updateMapPolicies(map, policies);
dbInstance.commitAndCloseSession();
// check if the policies are correctly merged
final List<EPMapPolicy> mergedPolicies = epFrontendManager.getMapPolicies(map);
assertNotNull(mergedPolicies);
assertEquals(1, mergedPolicies.size());
final EPMapPolicy mergedPolicy = mergedPolicies.get(0);
final List<Identity> identities = mergedPolicy.getIdentities();
assertEquals(3, identities.size());
int count1, count2, count3;
count1 = count2 = count3 = 0;
for (final Identity identity : identities) {
if (identity.equalsByPersistableKey(ident1)) {
count1++;
} else if (identity.equalsByPersistableKey(ident2)) {
count2++;
} else if (identity.equalsByPersistableKey(ident3)) {
count3++;
}
}
assertEquals(1, count1);
assertEquals(1, count2);
assertEquals(1, count3);
}
@Test
public void testRemoveCoach_withBusinessGroups() {
RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry();
// create a group with members
Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("remp-proc-1");
Identity member = JunitTestHelper.createAndPersistIdentityAsRndUser("remp-proc-2");
Identity coach = JunitTestHelper.createAndPersistIdentityAsRndUser("mbr-proc-3");
repositoryEntryRelationDao.addRole(owner, re, GroupRoles.owner.name());
repositoryEntryRelationDao.addRole(member, re, GroupRoles.coach.name());
repositoryEntryRelationDao.addRole(coach, re, GroupRoles.coach.name());
BusinessGroup businessGroup =
businessGroupDao.createAndPersist(
coach, "mbr-proc-1", "mbr-proc-desc", -1, -1, false, false, false, false, false);
businessGroupRelationDao.addRelationToResource(businessGroup, re);
// create a publisher
SubscriptionContext context = new SubscriptionContext(re.getOlatResource(), "");
PublisherData publisherData = new PublisherData("testGroupPublishers", "e.g. something", null);
Publisher publisher = notificationManager.getOrCreatePublisher(context, publisherData);
Assert.assertNotNull(publisher);
dbInstance.commitAndCloseSession();
// subscribe
notificationManager.subscribe(owner, context, publisherData);
notificationManager.subscribe(member, context, publisherData);
notificationManager.subscribe(coach, context, publisherData);
dbInstance.commitAndCloseSession();
// remove member and coach as coach of the repo entry
List<Identity> removeIdentities = new ArrayList<>(2);
removeIdentities.add(member);
removeIdentities.add(coach);
repositoryManager.removeTutors(owner, removeIdentities, re);
// wait for the remove of subscription
waitForCondition(
new CheckUnsubscription(member, context, dbInstance, notificationManager), 5000);
sleep(1000);
// check that subscription of id1 was deleted but not the ones of id2 and coach
boolean subscribedMember = notificationManager.isSubscribed(member, context);
Assert.assertFalse(subscribedMember);
boolean subscribedCoach = notificationManager.isSubscribed(coach, context);
Assert.assertTrue(subscribedCoach);
boolean subscribedOwner = notificationManager.isSubscribed(owner, context);
Assert.assertTrue(subscribedOwner);
}
@Test
public void getTasks() {
Identity coach = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-3");
Identity participant = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-4");
BusinessGroup businessGroup =
businessGroupDao.createAndPersist(
coach, "gdao", "gdao-desc", -1, -1, false, false, false, false, false);
businessGroupRelationDao.addRole(participant, businessGroup, GroupRole.participant.name());
dbInstance.commit();
RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry("", false);
GTACourseNode node = new GTACourseNode();
node.getModuleConfiguration().setStringValue(GTACourseNode.GTASK_TYPE, GTAType.group.name());
TaskList tasks = gtaManager.createIfNotExists(re, node);
File taskFile = new File("bg.txt");
Assert.assertNotNull(tasks);
dbInstance.commit();
// select
AssignmentResponse response = gtaManager.selectTask(businessGroup, tasks, node, taskFile);
dbInstance.commitAndCloseSession();
Assert.assertNotNull(response);
List<Task> assignedTasks = gtaManager.getTasks(participant, re, node);
Assert.assertNotNull(assignedTasks);
Assert.assertEquals(1, assignedTasks.size());
}
@Test
public void isTaskInProcess() {
// prepare
Identity participant = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-11");
RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry("", false);
GTACourseNode node = new GTACourseNode();
node.getModuleConfiguration()
.setStringValue(GTACourseNode.GTASK_TYPE, GTAType.individual.name());
TaskList tasks = gtaManager.createIfNotExists(re, node);
File taskFile = new File("solo.txt");
Assert.assertNotNull(tasks);
dbInstance.commit();
// select
AssignmentResponse response = gtaManager.selectTask(participant, tasks, node, taskFile);
dbInstance.commitAndCloseSession();
Assert.assertNotNull(response);
Assert.assertNotNull(response.getTask());
// check
boolean inProcess = gtaManager.isTaskInProcess(re, node, taskFile.getName());
Assert.assertTrue(inProcess);
// check dummy file name which cannot be in process
boolean notInProcess = gtaManager.isTaskInProcess(re, node, "qwertz");
Assert.assertFalse(notInProcess);
}
@Test
public void createAndLoadRepositoryEntry() {
Identity initialAuthor = JunitTestHelper.createAndPersistIdentityAsRndUser("auth-1");
String displayName = "Service test 2";
String resourceName = "ServiceTest";
String description = "Test the brand new service";
RepositoryEntry re =
repositoryService.create(
initialAuthor, null, resourceName, displayName, description, null, 0);
dbInstance.commitAndCloseSession();
Assert.assertNotNull(re);
RepositoryEntry loadedEntry = repositoryService.loadByKey(re.getKey());
Assert.assertNotNull(loadedEntry);
Assert.assertNotNull(re.getCreationDate());
Assert.assertNotNull(re.getLastModified());
Assert.assertNotNull(re.getOlatResource());
Assert.assertNotNull(loadedEntry.getGroups());
Assert.assertEquals(1, loadedEntry.getGroups().size());
// saved?
Assert.assertEquals(displayName, re.getDisplayname());
Assert.assertEquals(resourceName, re.getResourcename());
Assert.assertEquals(description, re.getDescription());
// default value
Assert.assertFalse(re.getCanCopy());
Assert.assertFalse(re.getCanDownload());
Assert.assertFalse(re.getCanReference());
Assert.assertEquals(0, re.getAccess());
}
@Test
public void updateTaskName() {
// create an individual task
Identity id1 = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-7");
Identity id2 = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-8");
RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry("", false);
GTACourseNode node = new GTACourseNode();
node.getModuleConfiguration()
.setStringValue(GTACourseNode.GTASK_TYPE, GTAType.individual.name());
TaskList taskList = gtaManager.createIfNotExists(re, node);
dbInstance.commit();
Assert.assertNotNull(taskList);
// select
gtaManager.selectTask(id1, taskList, node, new File("work_1.txt"));
gtaManager.selectTask(id2, taskList, node, new File("work_2.txt"));
dbInstance.commit();
// change a name
int rowUpdated = gtaManager.updateTaskName(taskList, "work_1.txt", "changed_work.txt");
dbInstance.commitAndCloseSession();
Assert.assertEquals(1, rowUpdated);
// check
Task assignedTaskToId1 = gtaManager.getTask(id1, taskList);
Assert.assertNotNull(assignedTaskToId1);
Assert.assertEquals("changed_work.txt", assignedTaskToId1.getTaskName());
List<Task> assignedTaskToId2 = gtaManager.getTasks(id2, re, node);
Assert.assertNotNull(assignedTaskToId2);
Assert.assertEquals(1, assignedTaskToId2.size());
Assert.assertEquals("work_2.txt", assignedTaskToId2.get(0).getTaskName());
}
@Test
public void deleteBinder() {
Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("del-binder-");
Binder binder = portfolioService.createNewBinder("Binder to delete", "Deletion", "", owner);
SectionRef sectionRef1 =
portfolioService.appendNewSection("1. section ", "Section 1", null, null, binder);
dbInstance.commit();
SectionRef sectionRef2 =
portfolioService.appendNewSection("2. section ", "Section 2", null, null, binder);
dbInstance.commit();
portfolioService.updateBinderUserInformations(binder, owner);
dbInstance.commit();
Section reloadedSection1 = portfolioService.getSection(sectionRef1);
Page page1 =
portfolioService.appendNewPage(
owner, "New page", "A brand new page.", null, null, reloadedSection1);
Section reloadedSection2 = portfolioService.getSection(sectionRef2);
Page page2 =
portfolioService.appendNewPage(
owner, "New page", "A brand new page.", null, null, reloadedSection2);
Assert.assertNotNull(page1);
Assert.assertNotNull(page2);
dbInstance.commitAndCloseSession();
// delete
boolean deleted = portfolioService.deleteBinder(binder);
dbInstance.commit();
Assert.assertTrue(deleted);
}
@Test
public void selectTask_identity() {
// prepare
Identity participant = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-1");
RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry("", false);
GTACourseNode node = new GTACourseNode();
node.getModuleConfiguration()
.setStringValue(GTACourseNode.GTASK_TYPE, GTAType.individual.name());
TaskList tasks = gtaManager.createIfNotExists(re, node);
File taskFile = new File("solo.txt");
Assert.assertNotNull(tasks);
dbInstance.commit();
// select
AssignmentResponse response = gtaManager.selectTask(participant, tasks, node, taskFile);
dbInstance.commitAndCloseSession();
// check
Assert.assertNotNull(response);
Assert.assertNotNull(response.getTask());
Assert.assertEquals(AssignmentResponse.Status.ok, response.getStatus());
Task task = response.getTask();
Assert.assertNotNull(task.getKey());
Assert.assertNull(task.getBusinessGroup());
Assert.assertNotNull(task.getCreationDate());
Assert.assertNotNull(task.getLastModified());
Assert.assertEquals(tasks, task.getTaskList());
Assert.assertEquals("solo.txt", task.getTaskName());
Assert.assertEquals(participant, task.getIdentity());
}
@Test
public void testRemoveParticipant() {
RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry();
// create a group with members
Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("remp-proc-1");
Identity member = JunitTestHelper.createAndPersistIdentityAsRndUser("remp-proc-2");
Identity participant = JunitTestHelper.createAndPersistIdentityAsRndUser("mbr-proc-3");
repositoryEntryRelationDao.addRole(owner, re, GroupRoles.owner.name());
repositoryEntryRelationDao.addRole(member, re, GroupRoles.coach.name());
repositoryEntryRelationDao.addRole(member, re, GroupRoles.participant.name());
repositoryEntryRelationDao.addRole(participant, re, GroupRoles.participant.name());
// create a publisher
SubscriptionContext context = new SubscriptionContext(re.getOlatResource(), "");
PublisherData publisherData = new PublisherData("testGroupPublishers", "e.g. something", null);
Publisher publisher = notificationManager.getOrCreatePublisher(context, publisherData);
Assert.assertNotNull(publisher);
dbInstance.commitAndCloseSession();
// subscribe
notificationManager.subscribe(owner, context, publisherData);
notificationManager.subscribe(member, context, publisherData);
notificationManager.subscribe(participant, context, publisherData);
dbInstance.commitAndCloseSession();
// remove member and participant as participant of the repo entry
List<Identity> removeIdentities = new ArrayList<>(2);
removeIdentities.add(member);
removeIdentities.add(participant);
MailPackage mailing = new MailPackage(false);
repositoryManager.removeParticipants(owner, removeIdentities, re, mailing, false);
// wait for the remove of subscription
waitForCondition(
new CheckUnsubscription(participant, context, dbInstance, notificationManager), 5000);
sleep(1000);
// check that subscription of id1 was deleted but not the ones of id2 and coach
boolean subscribedPart = notificationManager.isSubscribed(participant, context);
Assert.assertFalse(subscribedPart);
boolean subscribedMember = notificationManager.isSubscribed(member, context);
Assert.assertTrue(subscribedMember);
boolean subscribedOwner = notificationManager.isSubscribed(owner, context);
Assert.assertTrue(subscribedOwner);
}
@Test
public void testCopyMap() {
// create two artefacts
final AbstractArtefact artefact1 = epFrontendManager.createAndPersistArtefact(ident1, "text");
assertNotNull(artefact1);
final AbstractArtefact artefact2 = epFrontendManager.createAndPersistArtefact(ident1, "bc");
assertNotNull(artefact2);
dbInstance.commitAndCloseSession();
// create a map with a page and the page has two artefacts
final PortfolioStructureMap originalMap =
epFrontendManager.createAndPersistPortfolioDefaultMap(ident1, "Title", "Description");
final PortfolioStructure newPage =
epFrontendManager.createAndPersistPortfolioPage(
originalMap, "Page title", "Page description");
final boolean successfullLink1 =
epFrontendManager.addArtefactToStructure(ident1, artefact1, newPage);
assertTrue(successfullLink1);
final boolean successfullLink2 =
epFrontendManager.addArtefactToStructure(ident1, artefact2, newPage);
assertTrue(successfullLink2);
dbInstance.commitAndCloseSession();
// 1 test: copy the map one shoot
final PortfolioStructureMap copyMap =
epFrontendManager.createAndPersistPortfolioDefaultMap(
ident1, "Title copy", "Description copy");
epFrontendManager.copyStructureRecursively(originalMap, copyMap, true);
assertNotNull(copyMap.getKey());
dbInstance.commitAndCloseSession();
// 2 test: copy the map two shoota
final PortfolioStructureMap copyMap2 =
epFrontendManager.createAndPersistPortfolioDefaultMap(
ident1, "Title copy 2", "Description copy 2");
dbInstance.commitAndCloseSession();
assertNotNull(copyMap2.getKey());
epFrontendManager.copyStructureRecursively(originalMap, copyMap2, true);
dbInstance.commitAndCloseSession();
}
@Test
public void testTaggingOfArtefacts() {
final AbstractArtefact artefact = epFrontendManager.createAndPersistArtefact(ident1, "Forum");
dbInstance.commitAndCloseSession();
assertNotNull(artefact);
epFrontendManager.setArtefactTag(ident1, artefact, "Hello");
epFrontendManager.setArtefactTag(ident2, artefact, "Hello");
epFrontendManager.setArtefactTag(ident2, artefact, "Tchao");
dbInstance.commitAndCloseSession();
final List<String> tags = (List<String>) epFrontendManager.getArtefactTags(artefact);
assertNotNull(tags);
assertEquals(2, tags.size());
assertTrue(tags.get(0).equals("Hello") || tags.get(1).equals("Hello"));
assertTrue(tags.get(0).equals("Tchao") || tags.get(1).equals("Tchao"));
}
@Test
public void testDelete_deletable() {
String licenseKey = "gpl-" + UUID.randomUUID().toString();
QLicense license = qpoolLicenseDao.create(licenseKey, null, true);
dbInstance.commitAndCloseSession();
// delete it
boolean deleted = qpoolLicenseDao.delete(license);
dbInstance.commitAndCloseSession();
Assert.assertTrue(deleted);
// check that the type is really, really deleted
QLicense reloadedLicense = qpoolLicenseDao.loadById(license.getKey());
Assert.assertNull(reloadedLicense);
List<QLicense> licenses = qpoolLicenseDao.getLicenses();
Assert.assertFalse(licenses.contains(license));
}
@Test
public void allMapPolicies() {
// create a map
final PortfolioStructureMap map =
epFrontendManager.createAndPersistPortfolioDefaultMap(ident1, "Policies", "Description");
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(map, "Page policies", "Page description");
assertNotNull(page1);
dbInstance.commitAndCloseSession();
// save a list of policies
final List<EPMapPolicy> policies = new ArrayList<EPMapPolicy>();
// user policy
final EPMapPolicy userPolicy = new EPMapPolicy();
userPolicy.setType(Type.user);
userPolicy.getIdentities().add(ident2);
userPolicy.getIdentities().add(ident3);
policies.add(userPolicy);
// invitation
final Invitation invitation = securityManager.createAndPersistInvitation();
invitation.setFirstName("John");
invitation.setLastName("Doe");
invitation.setMail("*****@*****.**");
final EPMapPolicy invitationPolicy = new EPMapPolicy();
invitationPolicy.setType(Type.invitation);
invitationPolicy.setInvitation(invitation);
policies.add(invitationPolicy);
epFrontendManager.updateMapPolicies(map, policies);
dbInstance.commitAndCloseSession();
// check visiblity (is owner)
assertTrue(epFrontendManager.isMapVisible(ident1, map.getOlatResource()));
// check visibility (is in policy)
assertTrue(epFrontendManager.isMapVisible(ident2, map.getOlatResource()));
// check visible (is in policy)
assertTrue(epFrontendManager.isMapVisible(ident3, map.getOlatResource()));
// retrieved policies
final List<EPMapPolicy> savedPolicies = epFrontendManager.getMapPolicies(map);
assertTrue(!savedPolicies.isEmpty());
}
@Test
public void assignTemplate() {
Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-7");
Identity id = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-8");
// create a template
String title = "Template binder";
String summary = "Binder used as a template";
Binder template = portfolioService.createNewBinder(title, summary, null, owner);
dbInstance.commit();
for (int i = 0; i < 4; i++) {
portfolioService.appendNewSection("Section " + i, "Section " + i, null, null, template);
dbInstance.commit();
}
dbInstance.commitAndCloseSession();
List<Section> templateSections = portfolioService.getSections(template);
Assert.assertNotNull(templateSections);
Assert.assertEquals(4, templateSections.size());
// user copy the template
Binder binder = portfolioService.assignBinder(id, template, null, null, new Date());
dbInstance.commitAndCloseSession();
Assert.assertNotNull(binder);
Assert.assertNotNull(binder.getKey());
Assert.assertNotNull(binder.getCopyDate());
Assert.assertNotNull(template.getTitle(), binder.getTitle());
List<Section> reloadedSections = portfolioService.getSections(binder);
Assert.assertNotNull(reloadedSections);
Assert.assertEquals(4, reloadedSections.size());
Assert.assertEquals(templateSections.get(0).getTitle(), reloadedSections.get(0).getTitle());
Assert.assertEquals("Section 1", reloadedSections.get(1).getTitle());
Assert.assertEquals(templateSections.get(2).getTitle(), reloadedSections.get(2).getTitle());
Assert.assertEquals("Section 3", reloadedSections.get(3).getTitle());
Assert.assertEquals(
templateSections.get(0), ((SectionImpl) reloadedSections.get(0)).getTemplateReference());
Assert.assertEquals(
templateSections.get(1), ((SectionImpl) reloadedSections.get(1)).getTemplateReference());
Assert.assertEquals(
templateSections.get(2), ((SectionImpl) reloadedSections.get(2)).getTemplateReference());
Assert.assertEquals(
templateSections.get(3), ((SectionImpl) reloadedSections.get(3)).getTemplateReference());
}
@Test
public void testFindProperties() {
// create identities, group and resource
OLATResource res = JunitTestHelper.createRandomResource();
Identity id1 =
JunitTestHelper.createAndPersistIdentityAsUser("prop-8-" + UUID.randomUUID().toString());
Identity id2 =
JunitTestHelper.createAndPersistIdentityAsUser("prop-9-" + UUID.randomUUID().toString());
BusinessGroup group =
businessGroupService.createBusinessGroup(
id1, "a buddygroup", "a desc", -1, -1, false, false, null);
dbInstance.commitAndCloseSession();
String category = "cat3";
String propertyName = "TestProperty3";
String textValue = "textValue3";
Property p =
pm.createPropertyInstance(
id1,
group,
res,
category,
propertyName,
new Float(1.1),
new Long(123456),
"stringValue",
textValue);
pm.saveProperty(p);
p =
pm.createPropertyInstance(
id2,
group,
res,
category,
propertyName,
new Float(1.1),
new Long(123456),
"stringValue",
textValue);
pm.saveProperty(p);
List<Property> propertyList =
pm.findProperties(
id1,
group,
res.getResourceableTypeName(),
res.getResourceableId(),
category,
propertyName);
assertEquals(1, propertyList.size());
assertEquals(propertyName, propertyList.get(0).getName());
assertEquals(textValue, propertyList.get(0).getTextValue());
int deletedCount1 = pm.deleteProperties(id1, group, res, category, propertyName);
Assert.assertEquals(1, deletedCount1);
int deletedCount2 = pm.deleteProperties(id2, group, res, category, propertyName);
Assert.assertEquals(1, deletedCount2);
}
@Test
public void testFindWithResourceIdList() {
// create resource, identity
OLATResource ores = JunitTestHelper.createRandomResource();
Identity identity =
JunitTestHelper.createAndPersistIdentityAsUser("prop-2-" + UUID.randomUUID().toString());
dbInstance.commitAndCloseSession();
// create the property
Property p =
pm.createPropertyInstance(
identity,
null,
ores,
"catidlist",
"TestProperty",
new Float(1.1),
new Long(123456),
"stringValue",
"textValue");
pm.saveProperty(p);
dbInstance.commitAndCloseSession();
// check with empty list
List<Property> emptyProps =
pm.findProperties(
ores.getResourceableTypeName(),
Collections.<Long>emptyList(),
"catidlist",
"TestProperty");
assertNotNull(emptyProps);
Assert.assertTrue(emptyProps.isEmpty());
// check with a real value and a dummy
List<Long> resIds = new ArrayList<Long>();
resIds.add(ores.getResourceableId());
resIds.add(2456l); // dummy
List<Property> props =
pm.findProperties(ores.getResourceableTypeName(), resIds, "catidlist", "TestProperty");
assertNotNull(props);
Assert.assertEquals(1, props.size());
Assert.assertEquals(p, props.get(0));
}
@Test
public void deleteCoursePermanently() {
Identity initialAuthor = JunitTestHelper.createAndPersistIdentityAsRndUser("auth-del-1");
RepositoryEntry re = JunitTestHelper.deployDemoCourse(initialAuthor);
dbInstance.commitAndCloseSession();
Roles roles = new Roles(false, false, false, true, false, false, false);
ErrorList errors =
repositoryService.deletePermanently(re, initialAuthor, roles, Locale.ENGLISH);
Assert.assertNotNull(errors);
Assert.assertFalse(errors.hasErrors());
}
/** testListProperties */
@Test
public void testListProperties() {
// create resource, identity and group
OLATResource ores = JunitTestHelper.createRandomResource();
Identity identity =
JunitTestHelper.createAndPersistIdentityAsUser("prop-4-" + UUID.randomUUID().toString());
BusinessGroup group =
businessGroupService.createBusinessGroup(
identity, "a buddygroup", "a desc", -1, -1, false, false, null);
dbInstance.commitAndCloseSession();
Property p =
pm.createPropertyInstance(
identity,
group,
ores,
"cat",
"TestProperty",
new Float(1.1),
new Long(123456),
"stringValue",
"textValue");
pm.saveProperty(p);
List<Property> entries =
PropertyManager.getInstance()
.listProperties(
identity,
group,
ores.getResourceableTypeName(),
ores.getResourceableId(),
"cat",
"TestProperty");
Assert.assertNotNull(entries);
Assert.assertEquals(1, entries.size());
Property prop = entries.get(0);
assertEquals(ores.getResourceableTypeName(), prop.getResourceTypeName());
assertEquals(ores.getResourceableId(), prop.getResourceTypeId());
int numOfEntries =
PropertyManager.getInstance()
.countProperties(
identity,
group,
ores.getResourceableTypeName(),
ores.getResourceableId(),
"cat",
"TestProperty",
null,
null);
Assert.assertEquals(entries.size(), numOfEntries);
}
@Test
public void closedArtefacts() {
// create two artefacts
final AbstractArtefact artefact1 = epFrontendManager.createAndPersistArtefact(ident1, "text");
assertNotNull(artefact1);
final AbstractArtefact artefact2 = epFrontendManager.createAndPersistArtefact(ident1, "bc");
assertNotNull(artefact2);
dbInstance.commitAndCloseSession();
// create a map with a page and the page has two artefacts
final PortfolioStructureMap originalMap =
epFrontendManager.createAndPersistPortfolioDefaultMap(ident1, "Title", "Description");
final PortfolioStructure newPage =
epFrontendManager.createAndPersistPortfolioPage(
originalMap, "Page title", "Page description");
final boolean successfullLink1 =
epFrontendManager.addArtefactToStructure(ident1, artefact1, newPage);
assertTrue(successfullLink1);
final boolean successfullLink2 =
epFrontendManager.addArtefactToStructure(ident1, artefact2, newPage);
assertTrue(successfullLink2);
dbInstance.commitAndCloseSession();
// check if the artefact is in a closed map
assertFalse(epFrontendManager.isArtefactClosed(artefact1));
assertFalse(epFrontendManager.isArtefactClosed(artefact2));
// closed the map artificially
((EPDefaultMap) originalMap).setStatus(StructureStatusEnum.CLOSED);
dbInstance.updateObject(originalMap);
dbInstance.commitAndCloseSession();
// check if the artefact is in a closed map
assertTrue(epFrontendManager.isArtefactClosed(artefact1));
assertTrue(epFrontendManager.isArtefactClosed(artefact2));
}
@Test
public void deleteAllTaskLists() {
Identity coach = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-9");
Identity participant = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-10");
dbInstance.commit();
RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry("", false);
repositoryEntryRelationDao.addRole(coach, re, GroupRoles.coach.name());
repositoryEntryRelationDao.addRole(participant, re, GroupRoles.participant.name());
GTACourseNode node = new GTACourseNode();
node.getModuleConfiguration()
.setStringValue(GTACourseNode.GTASK_TYPE, GTAType.individual.name());
TaskList tasks = gtaManager.createIfNotExists(re, node);
File taskFile = new File("bg.txt");
Assert.assertNotNull(tasks);
dbInstance.commit();
// select
AssignmentResponse response = gtaManager.selectTask(participant, tasks, node, taskFile);
dbInstance.commitAndCloseSession();
Assert.assertNotNull(response);
// check that there is tasks
List<Task> assignedTasks = gtaManager.getTasks(participant, re, node);
Assert.assertNotNull(assignedTasks);
Assert.assertEquals(1, assignedTasks.size());
// delete
int numOfDeletedObjects = gtaManager.deleteAllTaskLists(re);
Assert.assertEquals(2, numOfDeletedObjects);
dbInstance.commitAndCloseSession();
// check that there isn't any tasks
List<Task> deletedAssignedTasks = gtaManager.getTasks(participant, re, node);
Assert.assertNotNull(deletedAssignedTasks);
Assert.assertEquals(0, deletedAssignedTasks.size());
}
@Test
public void isArtefactsInStructure() {
// create two artefacts
final AbstractArtefact artefact1 = epFrontendManager.createAndPersistArtefact(ident1, "text");
assertNotNull(artefact1);
final AbstractArtefact artefact2 = epFrontendManager.createAndPersistArtefact(ident1, "bc");
assertNotNull(artefact2);
dbInstance.commitAndCloseSession();
// create a map with a page and the page has two artefacts
final PortfolioStructureMap originalMap =
epFrontendManager.createAndPersistPortfolioDefaultMap(ident1, "Title", "Description");
final PortfolioStructure page1 =
epFrontendManager.createAndPersistPortfolioPage(
originalMap, "Page title", "Page description");
final PortfolioStructure page2 =
epFrontendManager.createAndPersistPortfolioPage(
originalMap, "Page title", "Page description");
final boolean successfullLink1 =
epFrontendManager.addArtefactToStructure(ident1, artefact1, page1);
assertTrue(successfullLink1);
final boolean successfullLink2 =
epFrontendManager.addArtefactToStructure(ident1, artefact2, page2);
assertTrue(successfullLink2);
dbInstance.commitAndCloseSession();
assertTrue(epFrontendManager.isArtefactInStructure(artefact1, page1));
assertFalse(epFrontendManager.isArtefactInStructure(artefact1, page2));
assertFalse(epFrontendManager.isArtefactInStructure(artefact2, page1));
assertTrue(epFrontendManager.isArtefactInStructure(artefact2, page2));
}
/** testGenericInsertFindDelete */
@Test
public void testGenericInsertFindDelete() {
// create resource, identity and group
OLATResource ores = JunitTestHelper.createRandomResource();
Identity identity =
JunitTestHelper.createAndPersistIdentityAsUser("prop-1-" + UUID.randomUUID().toString());
BusinessGroup group =
businessGroupService.createBusinessGroup(
identity, "a buddygroup", "a desc", -1, -1, false, false, null);
dbInstance.commitAndCloseSession();
Property p =
pm.createPropertyInstance(
identity,
group,
ores,
"catgeneric",
"TestProperty",
new Float(1.1),
new Long(123456),
"stringValue",
"textValue");
pm.saveProperty(p);
dbInstance.commitAndCloseSession();
p = pm.findProperty(identity, group, ores, "catgeneric", "TestProperty");
assertNotNull(p);
assertEquals(p.getStringValue(), "stringValue");
assertEquals(p.getFloatValue(), new Float(1.1));
assertEquals(p.getLongValue(), new Long(123456));
assertEquals(p.getTextValue(), "textValue");
pm.deleteProperty(p);
p = pm.findProperty(identity, group, ores, "catgeneric", "TestProperty");
assertNull(p);
}
