/** 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()));
}
@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 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);
}
@Before
public void setUp() {
if (!isInitialized) {
ident1 = JunitTestHelper.createAndPersistIdentityAsUser(UUID.randomUUID().toString());
ident2 = JunitTestHelper.createAndPersistIdentityAsUser(UUID.randomUUID().toString());
}
}
@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 binderAndSectionAndPageAccessRights_byIdentity() {
Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-5");
Identity identity = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-6");
String title = "My published binder";
String summary = "My live";
Binder binder = portfolioService.createNewBinder(title, summary, null, owner);
dbInstance.commit();
portfolioService.appendNewSection("Section", "Coached section", null, null, binder);
dbInstance.commit();
List<Section> sections = portfolioService.getSections(binder);
Section section = sections.get(0);
portfolioService.appendNewPage(owner, "Reviewed page", "", null, null, section);
portfolioService.addAccessRights(section, identity, PortfolioRoles.coach);
dbInstance.commit();
List<Page> pages = portfolioService.getPages(section);
Page page = pages.get(0);
portfolioService.addAccessRights(page, identity, PortfolioRoles.reviewer);
// load right
List<AccessRights> rights = portfolioService.getAccessRights(binder, identity);
Assert.assertNotNull(rights);
Assert.assertEquals(2, rights.size());
}
@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());
}
/**
* 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());
}
@Before
public void setUp() {
if (!isInitialized) {
ident1 = JunitTestHelper.createAndPersistIdentityAsUser("frtuse-1");
ident2 = JunitTestHelper.createAndPersistIdentityAsUser("frtuse-2");
ident3 = JunitTestHelper.createAndPersistIdentityAsUser("frtuse-3");
}
}
/** @see junit.framework.TestCase#setUp() */
@Before
public void setUp() throws Exception {
ident1 = JunitTestHelper.createAndPersistIdentityAsUser("test-1");
ident2 = JunitTestHelper.createAndPersistIdentityAsUser("test-2");
ident3 = JunitTestHelper.createAndPersistIdentityAsUser("test-3");
identities = new Identity[] {ident1, ident2, ident3};
marking = applicationContext.getBean(MarkDAO.class);
}
@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 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 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 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 createIfNotExists() {
RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry("", false);
GTACourseNode node = new GTACourseNode();
Assert.assertNotNull(node.getIdent());
TaskList tasks = gtaManager.createIfNotExists(re, node);
Assert.assertNotNull(tasks);
dbInstance.commit();
// reload and check
TaskList reloadedTasks = gtaManager.getTaskList(re, node);
Assert.assertNotNull(reloadedTasks);
Assert.assertEquals(tasks, reloadedTasks);
Assert.assertTrue(reloadedTasks instanceof TaskListImpl);
TaskListImpl tasksImpl = (TaskListImpl) reloadedTasks;
Assert.assertNotNull(tasksImpl.getCreationDate());
Assert.assertNotNull(tasksImpl.getLastModified());
Assert.assertEquals(re, tasksImpl.getEntry());
Assert.assertEquals(node.getIdent(), tasksImpl.getCourseNodeIdent());
dbInstance.commit();
// check that a second call doesn't create a new task list
TaskList secondTasks = gtaManager.createIfNotExists(re, node);
Assert.assertNotNull(secondTasks);
dbInstance.commit();
Assert.assertEquals(tasks, secondTasks);
}
@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());
}
@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 isTemplateInUse() {
Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-9");
Identity id = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-10");
RepositoryEntry templateEntry = createTemplate(owner, "Template", "TE");
dbInstance.commitAndCloseSession();
// assign a template
Binder templateBinder = portfolioService.getBinderByResource(templateEntry.getOlatResource());
Binder template = portfolioService.assignBinder(id, templateBinder, templateEntry, null, null);
dbInstance.commit();
Assert.assertNotNull(template);
boolean inUse = portfolioService.isTemplateInUse(templateBinder, templateEntry, null);
Assert.assertTrue(inUse);
}
/** 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();
}
@Test
public void binderAndSectionAndPageAccessRights() {
Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-3");
Identity coach = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-4");
Identity reviewer = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-5");
String title = "My published binder";
String summary = "My live";
Binder binder = portfolioService.createNewBinder(title, summary, null, owner);
dbInstance.commit();
portfolioService.appendNewSection("Section", "Coached section", null, null, binder);
dbInstance.commit();
List<Section> sections = portfolioService.getSections(binder);
Section section = sections.get(0);
portfolioService.appendNewPage(owner, "Reviewed page", "", null, null, section);
portfolioService.addAccessRights(section, coach, PortfolioRoles.coach);
dbInstance.commit();
List<Page> pages = portfolioService.getPages(section);
Page page = pages.get(0);
portfolioService.addAccessRights(page, reviewer, PortfolioRoles.reviewer);
// load right
List<AccessRights> rights = portfolioService.getAccessRights(binder);
Assert.assertNotNull(rights);
Assert.assertEquals(4, rights.size());
boolean foundOwner = false;
boolean foundCoach = false;
boolean foundReviewer = false;
for (AccessRights right : rights) {
if (PortfolioRoles.owner.equals(right.getRole()) && owner.equals(right.getIdentity())) {
foundOwner = true;
} else if (PortfolioRoles.coach.equals(right.getRole())
&& coach.equals(right.getIdentity())) {
foundCoach = true;
} else if (PortfolioRoles.reviewer.equals(right.getRole())
&& reviewer.equals(right.getIdentity())) {
foundReviewer = true;
}
}
Assert.assertTrue(foundOwner);
Assert.assertTrue(foundCoach);
Assert.assertTrue(foundReviewer);
}
@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 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 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 syncBinder() {
Identity owner = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-10");
Identity id = JunitTestHelper.createAndPersistIdentityAsRndUser("port-u-11");
RepositoryEntry templateEntry = createTemplate(owner, "Template", "TE");
dbInstance.commitAndCloseSession();
// make 2 sections
Binder templateBinder = portfolioService.getBinderByResource(templateEntry.getOlatResource());
// add 2 sections
for (int i = 0; i < 2; i++) {
portfolioService.appendNewSection("Section " + i, "Section " + i, null, null, templateBinder);
dbInstance.commit();
}
List<Section> templateSections = portfolioService.getSections(templateBinder);
Assert.assertNotNull(templateSections);
Assert.assertEquals(3, templateSections.size());
// user get a the binder from the template
Binder binder =
portfolioService.assignBinder(id, templateBinder, templateEntry, "ac-234", new Date());
dbInstance.commit();
Assert.assertNotNull(binder);
boolean inUse = portfolioService.isTemplateInUse(templateBinder, templateEntry, "ac-234");
Assert.assertTrue(inUse);
// update the template with 2 more sections
for (int i = 2; i < 4; i++) {
portfolioService.appendNewSection("Section " + i, "Section " + i, null, null, templateBinder);
dbInstance.commit();
}
SynchedBinder synchedBinder = portfolioService.loadAndSyncBinder(binder);
Assert.assertNotNull(synchedBinder);
dbInstance.commit();
Assert.assertTrue(synchedBinder.isChanged());
Assert.assertEquals(binder, synchedBinder.getBinder());
List<Section> synchedSections = portfolioService.getSections(synchedBinder.getBinder());
Assert.assertEquals(5, synchedSections.size());
}
@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 isTaskAssigned() {
// create an individual task
Identity participant = JunitTestHelper.createAndPersistIdentityAsRndUser("gta-user-6");
RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry("", false);
GTACourseNode node = new GTACourseNode();
node.getModuleConfiguration()
.setStringValue(GTACourseNode.GTASK_TYPE, GTAType.individual.name());
TaskList tasks = gtaManager.createIfNotExists(re, node);
dbInstance.commit();
Assert.assertNotNull(tasks);
// select
File taskFile = new File("bg.txt");
AssignmentResponse response = gtaManager.selectTask(participant, tasks, node, taskFile);
Assert.assertNotNull(response);
Assert.assertEquals(Status.ok, response.getStatus());
// check is assigned
boolean assigned = gtaManager.isTaskAssigned(tasks, taskFile.getName());
Assert.assertTrue(assigned);
boolean notAssigned = gtaManager.isTaskAssigned(tasks, "noise.txt");
Assert.assertFalse(notAssigned);
}
@Test
public void getAssignedTasks() {
// 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"));
// get assigned tasks
List<String> assigned = gtaManager.getAssignedTasks(taskList);
Assert.assertNotNull(assigned);
Assert.assertEquals(2, assigned.size());
Assert.assertTrue(assigned.contains("work_1.txt"));
Assert.assertTrue(assigned.contains("work_2.txt"));
}
@Test
public void isTasksInProcess_no() {
// prepare
RepositoryEntry re = JunitTestHelper.createAndPersistRepositoryEntry("", false);
GTACourseNode node = new GTACourseNode();
node.getModuleConfiguration()
.setStringValue(GTACourseNode.GTASK_TYPE, GTAType.individual.name());
TaskList tasks = gtaManager.createIfNotExists(re, node);
Assert.assertNotNull(tasks);
dbInstance.commit();
// check
boolean inProcess = gtaManager.isTasksInProcess(re, node);
Assert.assertFalse(inProcess);
}
/** 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);
}