ILIAS  release_6 Revision v6.24-5-g0c8bfefb3b8
•All Data Structures Namespaces Files Functions Variables Modules Pages
ilStudyProgrammeUserProgressTest.php
Go to the documentation of this file.
1 <?php
2 
3 /* Copyright (c) 2015 Richard Klees <richard.klees@concepts-and-training.de> Extended GPL, see docs/LICENSE */
4 
5 use PHPUnit\Framework\TestCase;
6 
7 require_once(__DIR__ . "/mocks.php");
8 
17 class ilStudyProgrammeUserProgressTest extends TestCase
18 {
19  protected $backupGlobals = false;
20 
21  protected function setUp() : void
22  {
23  require_once("./Modules/StudyProgramme/classes/class.ilObjStudyProgramme.php");
24  PHPUnit\Framework\Error\Deprecated::$enabled = false;
25 
26  global $DIC;
27  if (!$DIC) {
28  include_once("./Services/PHPUnit/classes/class.ilUnitUtil.php");
29  try {
30  ilUnitUtil::performInitialisation();
31  } catch (Exception $e) {
32  }
33  }
34 
35  $this->root = ilObjStudyProgramme::createInstance();
36  $this->root->putInTree(ROOT_FOLDER_ID);
37  $this->root->object_factory = new ilObjectFactoryWrapperMock();
38 
39  $this->node1 = ilObjStudyProgramme::createInstance();
40  $this->node2 = ilObjStudyProgramme::createInstance();
41 
42  $this->leaf1 = new ilStudyProgrammeLeafMock();
43  $this->leaf2 = new ilStudyProgrammeLeafMock();
44 
45  $this->root->addNode($this->node1);
46  $this->root->addNode($this->node2);
47  $this->node1->addLeaf($this->leaf1);
48  $this->node2->addLeaf($this->leaf2);
49 
50  global $DIC;
51  $tree = $DIC['tree'];
52  $this->tree = $tree;
53 
54  global $DIC;
55  $ilUser = $DIC['ilUser'];
56  $this->user = $ilUser;
57  }
58 
59  protected function tearDown() : void
60  {
61  if ($this->root) {
62  $this->root->delete();
63  }
64  }
65 
66  protected function newUser()
67  {
68  $user = new ilObjUser();
69  $user->create();
70  return $user;
71  }
72 
73  protected function setAllNodesActive()
74  {
75  $this->root->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE)->update();
76  $this->node1->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE)->update();
77  $this->node2->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE)->update();
78  }
79 
80  protected function assignNewUserToRoot()
81  {
82  $user = $this->newUser();
83  return array($this->root->assignUser($user->getId(), 6), $user);
84  }
85 
86  public function testInitialProgressActive()
87  {
88  $this->setAllNodesActive();
89  $tmp = $this->assignNewUserToRoot();
90  $ass = $tmp[0];
91  $user = $tmp[1];
92 
93  $root_progresses = $this->root->getProgressesOf($user->getId());
94  $this->assertCount(1, $root_progresses);
95  $root_progress = $root_progresses[0];
96  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $root_progress->getStatus());
97  $this->assertEquals($this->root->getPoints(), $root_progress->getAmountOfPoints());
98  $this->assertEquals(0, $root_progress->getCurrentAmountOfPoints());
99  $this->assertEquals($this->root->getId(), $root_progress->getStudyProgramme()->getId());
100  $this->assertEquals($ass->getId(), $root_progress->getAssignmentId());
101  $this->assertEquals($user->getId(), $root_progress->getUserId());
102  $this->assertNull($root_progress->getLastChangeBy());
103  $this->assertNull($root_progress->getCompletionBy());
104  $this->assertNull($root_progress->getCompletionDate());
105  $this->assertEquals($root_progress->getAssignmentDate()->format('Y-m-d'), (new \DateTime())->format('Y-m-d'));
106 
107 
108  $node1_progresses = $this->node1->getProgressesOf($user->getId());
109  $this->assertCount(1, $node1_progresses);
110  $node1_progress = $node1_progresses[0];
111  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node1_progress->getStatus());
112  $this->assertEquals($this->node1->getPoints(), $node1_progress->getAmountOfPoints());
113  $this->assertEquals(0, $node1_progress->getCurrentAmountOfPoints());
114  $this->assertEquals($this->node1->getId(), $node1_progress->getStudyProgramme()->getId());
115  $this->assertEquals($ass->getId(), $node1_progress->getAssignmentId());
116  $this->assertEquals($user->getId(), $node1_progress->getUserId());
117  $this->assertNull($node1_progress->getLastChangeBy());
118  $this->assertNull($node1_progress->getCompletionBy());
119 
120  $node2_progresses = $this->node2->getProgressesOf($user->getId());
121  $this->assertCount(1, $node2_progresses);
122  $node2_progress = $node2_progresses[0];
123  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node2_progress->getStatus());
124  $this->assertEquals($this->node2->getPoints(), $node2_progress->getAmountOfPoints());
125  $this->assertEquals(0, $node2_progress->getCurrentAmountOfPoints());
126  $this->assertEquals($this->node2->getId(), $node2_progress->getStudyProgramme()->getId());
127  $this->assertEquals($ass->getId(), $node2_progress->getAssignmentId());
128  $this->assertEquals($user->getId(), $node2_progress->getUserId());
129  $this->assertNull($node2_progress->getLastChangeBy());
130  $this->assertNull($node2_progress->getCompletionBy());
131  }
132 
133  public function testInitialProgressDraft()
134  {
135  $this->root->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE)->update();
136  $this->node1->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE)->update();
137  $this->node2->setStatus(ilStudyProgrammeSettings::STATUS_DRAFT)->update();
138 
139  $tmp = $this->assignNewUserToRoot();
140  $user = $tmp[1];
141  $ass = $tmp[0];
142 
143  $root_progresses = $this->root->getProgressesOf($user->getId());
144  $root_progress = $root_progresses[0];
145  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $root_progress->getStatus());
146 
147  $node1_progresses = $this->node1->getProgressesOf($user->getId());
148  $node1_progress = $node1_progresses[0];
149  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node1_progress->getStatus());
150 
151  $node2_progresses = $this->node2->getProgressesOf($user->getId());
152  $node2_progress = $node2_progresses[0];
153  $this->assertEquals(ilStudyProgrammeProgress::STATUS_NOT_RELEVANT, $node2_progress->getStatus());
154  }
155 
156  public function testInitialProgressOutdated()
157  {
158  $this->root->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE)->update();
159  $this->node1->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE)->update();
160  $this->node2->setStatus(ilStudyProgrammeSettings::STATUS_OUTDATED)->update();
161 
162  $tmp = $this->assignNewUserToRoot();
163  $user = $tmp[1];
164  $ass = $tmp[0];
165 
166  $root_progresses = $this->root->getProgressesOf($user->getId());
167  $root_progress = $root_progresses[0];
168  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $root_progress->getStatus());
169 
170  $node1_progresses = $this->node1->getProgressesOf($user->getId());
171  $node1_progress = $node1_progresses[0];
172  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node1_progress->getStatus());
173 
174  $node2_progresses = $this->node2->getProgressesOf($user->getId());
175  $node2_progress = $node2_progresses[0];
176  $this->assertEquals(ilStudyProgrammeProgress::STATUS_NOT_RELEVANT, $node2_progress->getStatus());
177  }
178 
179  public function testUserSelection()
180  {
181  $this->setAllNodesActive();
182  $this->assignNewUserToRoot();
183  $tmp = $this->assignNewUserToRoot();
184  $ass = $tmp[0];
185  $user = $tmp[1];
186 
187  $root_progresses = $this->root->getProgressesOf($user->getId());
188  $this->assertCount(1, $root_progresses);
189  }
190 
191  public function testMarkAccredited()
192  {
193  $this->setAllNodesActive();
194  $tmp = $this->assignNewUserToRoot();
195  $ass = $tmp[0];
196  $user = $tmp[1];
197 
198  $user2 = $this->newUser();
199  $USER_ID = $user2->getId();
200 
201  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
202  $node1_progress = array_shift($this->node1->getProgressesOf($user->getId()));
203  $node2_progress = array_shift($this->node2->getProgressesOf($user->getId()));
204  $this->assertEquals($root_progress->getAmountOfPoints(), ilStudyProgrammeSettings::DEFAULT_POINTS);
205  $this->assertEquals($node1_progress->getAmountOfPoints(), ilStudyProgrammeSettings::DEFAULT_POINTS);
206  $this->assertEquals($node2_progress->getAmountOfPoints(), ilStudyProgrammeSettings::DEFAULT_POINTS);
207 
208  $ts_before_change = $node2_progress->getLastChange()->format('Y-m-d H:i:s');
209  $node2_progress->markAccredited($USER_ID);
210  $ts_after_change = $node2_progress->getLastChange()->format('Y-m-d H:i:s');
211 
212 
213  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
214  $node1_progress = array_shift($this->node1->getProgressesOf($user->getId()));
215  $node2_progress = array_shift($this->node2->getProgressesOf($user->getId()));
216 
217  $this->assertTrue($node2_progress->isSuccessful());
218  $this->assertEquals($root_progress->getAmountOfPoints(), $root_progress->getCurrentAmountOfPoints());
219 
220  $this->assertEquals(ilStudyProgrammeProgress::STATUS_COMPLETED, $root_progress->getStatus());
221  $this->assertEquals((new \DateTime())->format('Y-m-d'), $root_progress->getCompletionDate()->format('Y-m-d'));
222  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node1_progress->getStatus());
223  $this->assertNull($node1_progress->getCompletionDate());
224  $this->assertEquals(ilStudyProgrammeProgress::STATUS_ACCREDITED, $node2_progress->getStatus());
225  $this->assertEquals((new \DateTime())->format('Y-m-d'), $node2_progress->getCompletionDate()->format('Y-m-d'));
226  $this->assertEquals($USER_ID, $node2_progress->getCompletionBy());
227  $this->assertLessThanOrEqual($ts_before_change, $ts_after_change);
228  }
229 
230  public function testUnmarkAccredited()
231  {
232  $this->setAllNodesActive();
233  $tmp = $this->assignNewUserToRoot();
234  $ass = $tmp[0];
235  $user = $tmp[1];
236 
237  $user2 = $this->newUser();
238  $USER_ID = $user2->getId();
239 
240  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
241  $node1_progress = array_shift($this->node1->getProgressesOf($user->getId()));
242  $node2_progress = array_shift($this->node2->getProgressesOf($user->getId()));
243 
244  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $root_progress->getStatus());
245  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node1_progress->getStatus());
246  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node2_progress->getStatus());
247 
248  $ts_before_change = $node2_progress->getLastChange()->format('Y-m-d H:i:s');
249  $node2_progress->markAccredited($USER_ID);
250  $node2_progress->unmarkAccredited();
251  $ts_after_change = $node2_progress->getLastChange()->format('Y-m-d H:i:s');
252 
253  // The root node will still be completed, as we do not go back from completed to some other
254  // status.
255  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $root_progress->getStatus());
256  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node1_progress->getStatus());
257  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node2_progress->getStatus());
258  $this->assertNull($root_progress->getCompletionDate());
259  $this->assertNull($node1_progress->getCompletionDate());
260  $this->assertNull($node2_progress->getCompletionDate());
261  $this->assertEquals(null, $node2_progress->getCompletionBy());
262  $this->assertLessThanOrEqual($ts_before_change, $ts_after_change);
263  }
264 
265  public function testMarkFailed()
266  {
267  $this->setAllNodesActive();
268  $tmp = $this->assignNewUserToRoot();
269  $ass = $tmp[0];
270  $user = $tmp[1];
271 
272  $user2 = $this->newUser();
273  $USER_ID = $user2->getId();
274 
275  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
276  $node1_progress = array_shift($this->node1->getProgressesOf($user->getId()));
277  $node2_progress = array_shift($this->node2->getProgressesOf($user->getId()));
278  $node2_progress->markFailed($USER_ID);
279 
280  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $root_progress->getStatus());
281  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node1_progress->getStatus());
282  $this->assertEquals(ilStudyProgrammeProgress::STATUS_FAILED, $node2_progress->getStatus());
283  $this->assertNull($root_progress->getCompletionDate());
284  $this->assertNull($node1_progress->getCompletionDate());
285  $this->assertNull($node2_progress->getCompletionDate());
286  }
287 
288  public function testMarkNotFailed()
289  {
290  $this->setAllNodesActive();
291  $tmp = $this->assignNewUserToRoot();
292  $ass = $tmp[0];
293  $user = $tmp[1];
294 
295  $user2 = $this->newUser();
296  $USER_ID = (int) $user2->getId();
297 
298  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
299  $node1_progress = array_shift($this->node1->getProgressesOf($user->getId()));
300  $node2_progress = array_shift($this->node2->getProgressesOf($user->getId()));
301  $node2_progress->markFailed($USER_ID);
302 
303  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $root_progress->getStatus());
304  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node1_progress->getStatus());
305  $this->assertEquals(ilStudyProgrammeProgress::STATUS_FAILED, $node2_progress->getStatus());
306  $this->assertNull($root_progress->getCompletionDate());
307  $this->assertNull($node1_progress->getCompletionDate());
308  $this->assertNull($node2_progress->getCompletionDate());
309  $node2_progress->markNotFailed($USER_ID);
310 
311  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node2_progress->getStatus());
312  }
313 
314  public function testMarkNotRelevant()
315  {
316  $this->setAllNodesActive();
317  $tmp = $this->assignNewUserToRoot();
318  $ass = $tmp[0];
319  $user = $tmp[1];
320 
321  $user2 = $this->newUser();
322  $USER_ID = $user2->getId();
323 
324  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
325  $node1_progress = array_shift($this->node1->getProgressesOf($user->getId()));
326  $node2_progress = array_shift($this->node2->getProgressesOf($user->getId()));
327  $ts_before_change = $node2_progress->getLastChange()->format('Y-m-d H:i:s');
328  $node2_progress->markNotRelevant($USER_ID);
329  $ts_after_change = $node2_progress->getLastChange()->format('Y-m-d H:i:s');
330  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $root_progress->getStatus());
331  $this->assertEquals(ilStudyProgrammeProgress::STATUS_IN_PROGRESS, $node1_progress->getStatus());
332  $this->assertEquals(ilStudyProgrammeProgress::STATUS_NOT_RELEVANT, $node2_progress->getStatus());
333  $this->assertNull($root_progress->getCompletionDate());
334  $this->assertNull($node1_progress->getCompletionDate());
335  $this->assertNull($node2_progress->getCompletionDate());
336  $this->assertEquals($USER_ID, $node2_progress->getCompletionBy());
337  $this->assertLessThanOrEqual($ts_before_change, $ts_after_change);
338  $this->assertTrue($node2_progress->hasIndividualModifications());
339  }
340 
341  // Neues Moduls: Wird dem Studierenden-Studierenden inkl. Kurse, Punkte als "Nicht relevant" hinzugefügt.
342  public function testNewNodesAreNotRelevant()
343  {
344  $this->setAllNodesActive();
345  $tmp = $this->assignNewUserToRoot();
346  $ass = $tmp[0];
347  $user = $tmp[1];
348 
349  $node3 = ilObjStudyProgramme::createInstance();
350  $this->root->addNode($node3);
351 
352  $node3_progress = array_shift($node3->getProgressesOf($user->getId()));
353  $this->assertNotNull($node3_progress);
354  $this->assertEquals(ilStudyProgrammeProgress::STATUS_NOT_RELEVANT, $node3_progress->getStatus());
355  }
356 
357  public function testIndividualRequiredPoints()
358  {
359  $this->setAllNodesActive();
360  $tmp = $this->assignNewUserToRoot();
361  $ass1 = $tmp[0];
362  $user1 = $tmp[1];
363 
364 
365  $NEW_AMOUNT_OF_POINTS_1 = 205;
366  $this->assertNotEquals($NEW_AMOUNT_OF_POINTS_1, ilStudyProgrammeSettings::DEFAULT_POINTS);
367 
368  $node2_progress1 = array_shift($this->node2->getProgressesOf($user1->getId()));
369  $node2_progress1->setRequiredAmountOfPoints($NEW_AMOUNT_OF_POINTS_1, 6);
370 
371  $this->assertEquals($NEW_AMOUNT_OF_POINTS_1, $node2_progress1->getAmountOfPoints());
372  }
373 
374  public function testMaximimPossibleAmountOfPoints1()
375  {
376  $this->setAllNodesActive();
377  $tmp = $this->assignNewUserToRoot();
378  $ass = $tmp[0];
379  $user = $tmp[1];
380 
381  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
382  $node1_progress = array_shift($this->node1->getProgressesOf($user->getId()));
383  $node2_progress = array_shift($this->node2->getProgressesOf($user->getId()));
384 
385  $this->assertEquals(2 * ilStudyProgrammeSettings::DEFAULT_POINTS, $root_progress->getMaximumPossibleAmountOfPoints());
386  $this->assertEquals(ilStudyProgrammeSettings::DEFAULT_POINTS, $node1_progress->getMaximumPossibleAmountOfPoints());
387  $this->assertEquals(ilStudyProgrammeSettings::DEFAULT_POINTS, $node2_progress->getMaximumPossibleAmountOfPoints());
388  }
389 
390  public function testMaximimPossibleAmountOfPoints2()
391  {
392  $this->setAllNodesActive();
393  $tmp = $this->assignNewUserToRoot();
394  $ass = $tmp[0];
395  $user = $tmp[1];
396 
397  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
398  $node1_progress = array_shift($this->node1->getProgressesOf($user->getId()));
399  $node2_progress = array_shift($this->node2->getProgressesOf($user->getId()));
400 
401  $this->assertEquals(2 * ilStudyProgrammeSettings::DEFAULT_POINTS, $root_progress->getMaximumPossibleAmountOfPoints());
402  $this->assertEquals(ilStudyProgrammeSettings::DEFAULT_POINTS, $node1_progress->getMaximumPossibleAmountOfPoints());
403  $this->assertEquals(ilStudyProgrammeSettings::DEFAULT_POINTS, $node2_progress->getMaximumPossibleAmountOfPoints());
404  }
405 
406  public function testCanBeCompleted1()
407  {
408  $this->setAllNodesActive();
409  $tmp = $this->assignNewUserToRoot();
410  $ass = $tmp[0];
411  $user = $tmp[1];
412 
413  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
414  $node1_progress = array_shift($this->node1->getProgressesOf($user->getId()));
415  $node2_progress = array_shift($this->node2->getProgressesOf($user->getId()));
416 
417  $this->assertTrue($root_progress->canBeCompleted());
418  $this->assertTrue($node1_progress->canBeCompleted());
419  $this->assertTrue($node2_progress->canBeCompleted());
420  }
421 
422  public function testCanBeCompleted2()
423  {
424  $NEW_AMOUNT_OF_POINTS = 3003;
425  $this->assertGreaterThan(ilStudyProgrammeSettings::DEFAULT_POINTS, $NEW_AMOUNT_OF_POINTS);
426 
427  $this->setAllNodesActive();
428  $this->root->setPoints($NEW_AMOUNT_OF_POINTS)
429  ->update();
430  $tmp = $this->assignNewUserToRoot();
431  $ass = $tmp[0];
432  $user = $tmp[1];
433 
434  $this->assertLessThan($NEW_AMOUNT_OF_POINTS, $this->node1->getPoints() + $this->node2->getPoints());
435 
436  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
437  $this->assertFalse($root_progress->canBeCompleted());
438  }
439 
440  public function testCanBeCompleted3()
441  {
442  $NEW_AMOUNT_OF_POINTS = 3003;
443  $this->assertGreaterThan(ilStudyProgrammeSettings::DEFAULT_POINTS, $NEW_AMOUNT_OF_POINTS);
444 
445  $this->setAllNodesActive();
446  $node3 = ilObjStudyProgramme::createInstance();
447  $this->root->addNode($node3);
448  $node3->setPoints($NEW_AMOUNT_OF_POINTS)
449  ->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE)
450  ->update();
451 
452 
453  $tmp = $this->assignNewUserToRoot();
454  $ass = $tmp[0];
455  $user = $tmp[1];
456 
457  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
458  $node3_progress = array_shift($node3->getProgressesOf($user->getId()));
459 
460  $this->assertFalse($root_progress->canBeCompleted());
461  $this->assertFalse($node3_progress->canBeCompleted());
462  }
463 
464  public function testUserDeletionDeletesAssignments()
465  {
466  $this->setAllNodesActive();
467  $tmp = $this->assignNewUserToRoot();
468  $ass = $tmp[0];
469  $user = $tmp[1];
470 
471  $user->delete();
472 
473  $root_progresses = $this->root->getProgressesOf($user->getId());
474  $this->assertCount(0, $root_progresses);
475  $node1_progresses = $this->node1->getProgressesOf($user->getId());
476  $this->assertCount(0, $node1_progresses);
477  $node2_progresses = $this->node2->getProgressesOf($user->getId());
478  $this->assertCount(0, $node2_progresses);
479  }
480 
481  // - Änderungen von Punkten bei bestehenden qua-Objekten werden nicht direkt übernommen
482  public function testNoImplicitPointUpdate()
483  {
484  $this->setAllNodesActive();
485  $tmp = $this->assignNewUserToRoot();
486  $ass = $tmp[0];
487  $user = $tmp[1];
488 
489  $NEW_AMOUNT_OF_POINTS = 201;
490  $this->assertNotEquals($NEW_AMOUNT_OF_POINTS, ilStudyProgrammeSettings::DEFAULT_POINTS);
491 
492  $this->root->setPoints($NEW_AMOUNT_OF_POINTS)
493  ->update();
494 
495  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
496  $this->assertEquals(ilStudyProgrammeSettings::DEFAULT_POINTS, $root_progress->getAmountOfPoints());
497  }
498 
499  // Änderungen von Punkten bei bestehenden qua-Objekten werden nicht direkt übernommen,
500  // sondern dann bei bewusster Aktualisierung.
501  public function testExplicitPointUpdate1()
502  {
503  $this->setAllNodesActive();
504  $tmp = $this->assignNewUserToRoot();
505  $ass = $tmp[0];
506  $user = $tmp[1];
507 
508  $NEW_AMOUNT_OF_POINTS = 202;
509  $this->assertNotEquals($NEW_AMOUNT_OF_POINTS, ilStudyProgrammeSettings::DEFAULT_POINTS);
510 
511  $this->root->setPoints($NEW_AMOUNT_OF_POINTS)
512  ->update();
513 
514  $ass->updateFromProgram();
515  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
516  $this->assertEquals($NEW_AMOUNT_OF_POINTS, $root_progress->getAmountOfPoints());
517  }
518 
519  // Änderungen von Punkten bei bestehenden qua-Objekten werden nicht direkt übernommen,
520  // sondern dann bei bewusster Aktualisierung.
521  // Similar to testExplicitPointUpdate1, but order of calls differs.
522  public function testExplicitPointUpdate2()
523  {
524  $this->setAllNodesActive();
525  $tmp = $this->assignNewUserToRoot();
526  $ass = $tmp[0];
527  $user = $tmp[1];
528 
529  $NEW_AMOUNT_OF_POINTS = 203;
530  $this->assertNotEquals($NEW_AMOUNT_OF_POINTS, ilStudyProgrammeSettings::DEFAULT_POINTS);
531 
532  $this->root->setPoints($NEW_AMOUNT_OF_POINTS)
533  ->update();
534 
535  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
536  $ass->updateFromProgram();
537  $root_progress = array_shift($this->root->getProgressesOf($user->getId()));
538  $this->assertEquals($NEW_AMOUNT_OF_POINTS, $root_progress->getAmountOfPoints());
539  }
540 
541  // Änderungen von Punkten bei bestehenden qua-Objekten werden nicht direkt übernommen,
542  // sondern dann bei bewusster Aktualisierung (sofern nicht ein darüberliegenden
543  // Knotenpunkt manuell angepasst worden ist)
544  public function testNoUpdateOnModifiedNodes()
545  {
546  $this->setAllNodesActive();
547  $tmp = $this->assignNewUserToRoot();
548  $ass1 = $tmp[0];
549  $user1 = $tmp[1];
550 
551  $tmp = $this->assignNewUserToRoot();
552  $ass2 = $tmp[0];
553  $user2 = $tmp[1];
554 
555  $NEW_AMOUNT_OF_POINTS_1 = 205;
556  $this->assertNotEquals($NEW_AMOUNT_OF_POINTS_1, ilStudyProgrammeSettings::DEFAULT_POINTS);
557  $NEW_AMOUNT_OF_POINTS_2 = 206;
558  $this->assertNotEquals($NEW_AMOUNT_OF_POINTS_2, ilStudyProgrammeSettings::DEFAULT_POINTS);
559  $this->assertNotEquals($NEW_AMOUNT_OF_POINTS_1, $NEW_AMOUNT_OF_POINTS_2);
560 
561  $node2_progress1 = array_shift($this->node2->getProgressesOf($user1->getId()));
562 
563 
564  $node2_progress2 = array_shift($this->node2->getProgressesOf($user2->getId()));
565 
566  $node2_progress1->setRequiredAmountOfPoints($NEW_AMOUNT_OF_POINTS_1, 6);
567  $this->assertEquals($NEW_AMOUNT_OF_POINTS_1, $node2_progress1->getAmountOfPoints());
568  $node2_progress1 = array_shift($this->node2->getProgressesOf($user1->getId()));
569  $this->assertEquals($NEW_AMOUNT_OF_POINTS_1, $node2_progress1->getAmountOfPoints());
570  $this->node2->setPoints($NEW_AMOUNT_OF_POINTS_2)
571  ->update();
572  $this->root->updateAllAssignments();
573  $node2_progress2 = array_shift($this->node2->getProgressesOf($user2->getId()));
574  //$this->assertEquals($NEW_AMOUNT_OF_POINTS_1, $node2_progress1->getAmountOfPoints());
575  $this->assertEquals($NEW_AMOUNT_OF_POINTS_2, $node2_progress2->getAmountOfPoints());
576 
577  //$node2_progress1 = array_shift($this->node2->getProgressesOf($user1->getId()));
578  $node2_progress2 = array_shift($this->node2->getProgressesOf($user2->getId()));
579 
580  //$this->assertEquals($NEW_AMOUNT_OF_POINTS_1, $node2_progress1->getAmountOfPoints());
581  $this->assertEquals($NEW_AMOUNT_OF_POINTS_2, $node2_progress2->getAmountOfPoints());
582  }
583 
590  public function testOutdatedNodesCantBeSetToRelevant()
591  {
592  $this->setAllNodesActive();
593  $this->node1->setStatus(ilStudyProgrammeSettings::STATUS_OUTDATED);
594  $tmp = $this->assignNewUserToRoot();
595  $ass1 = $tmp[0];
596  $user1 = $tmp[1];
597 
598  $progress = $this->node1->getProgressForAssignment($ass1->getId());
599  $this->assertEquals(ilStudyProgrammeProgress::STATUS_NOT_RELEVANT, $progress->getStatus());
600  $progress->markAccredited($this->user->getId());
601  }
602 
603  // Hinweis bei der bei der Studierenden-Instanz des Studienplanes, falls dieser vom
604  // Original-Studienplan abweicht.
605  public function testHasDeviationToProgram1()
606  {
607  $this->setAllNodesActive();
608  $tmp = $this->assignNewUserToRoot();
609  $ass1 = $tmp[0];
610  $user1 = $tmp[1];
611 
612  $progress = $this->node1->getProgressForAssignment($ass1->getId());
613  $this->assertFalse($progress->hasIndividualModifications());
614  }
615 
616  public function testHasDeviationToProgram2()
617  {
618  $this->setAllNodesActive();
619  $tmp = $this->assignNewUserToRoot();
620  $ass1 = $tmp[0];
621  $user1 = $tmp[1];
622 
623  $progress = $this->node1->getProgressForAssignment($ass1->getId());
624  $progress->setRequiredAmountOfPoints(1000, 6);
625  $this->assertTrue($progress->hasIndividualModifications());
626  }
627 
628  public function testHasDeviationToProgram3()
629  {
630  $this->setAllNodesActive();
631  $tmp = $this->assignNewUserToRoot();
632  $ass1 = $tmp[0];
633  $user1 = $tmp[1];
634 
635  $progress = $this->node1->getProgressForAssignment($ass1->getId());
636  $progress->markNotRelevant(6);
637  $this->assertTrue($progress->hasIndividualModifications());
638  }
639 
640  public function testHasDeviationToProgram4()
641  {
642  $this->setAllNodesActive();
643  $tmp = $this->assignNewUserToRoot();
644  $ass1 = $tmp[0];
645  $user1 = $tmp[1];
646 
647  $progress = $this->node1->getProgressForAssignment($ass1->getId());
648  $progress->markAccredited($this->user->getId());
649  $this->assertFalse($progress->hasIndividualModifications());
650  }
651 
652  public function testGetNamesOfCompletedOrAccreditedChildren()
653  {
654  $this->setAllNodesActive();
655  $tmp = $this->assignNewUserToRoot();
656  $ass = $tmp[0];
657  $user = $tmp[1];
658 
659  $user2 = $this->newUser();
660  $USER_ID = $user2->getId();
661 
662  $this->node1->setTitle("node1");
663  $this->node1->update();
664  $this->node2->setTitle("node2");
665  $this->node2->update();
666 
667  $names = $this->root->getProgressForAssignment($ass->getId())
668  ->getNamesOfCompletedOrAccreditedChildren();
669  $this->assertEquals($names, array());
670 
671  $this->node1->getProgressForAssignment($ass->getId())->markAccredited($USER_ID);
672  $names = $this->root->getProgressForAssignment($ass->getId())
673  ->getNamesOfCompletedOrAccreditedChildren();
674  $this->assertEquals($names, array("node1"));
675 
676  $this->node2->getProgressForAssignment($ass->getId())->markAccredited($USER_ID);
677  $names = $this->root->getProgressForAssignment($ass->getId())
678  ->getNamesOfCompletedOrAccreditedChildren();
679  $this->assertEquals($names, array("node1", "node2"));
680  }
681 
682  public function testCompletionOnDeeplyNestedProgresses()
683  {
684  $depth1 = ilObjStudyProgramme::createInstance();
685  $depth2 = ilObjStudyProgramme::createInstance();
686  $depth3 = ilObjStudyProgramme::createInstance();
687  $depth4 = ilObjStudyProgramme::createInstance();
688  $depth1->putInTree(ROOT_FOLDER_ID);
689  $depth1->addNode($depth2);
690  $depth2->addNode($depth3);
691  $depth3->addNode($depth4);
692  $depth1->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
693  $depth2->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
694  $depth3->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
695  $depth4->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
696 
697  $user = $this->newUser();
698 
699  $assignment = $depth1->assignUser($user->getId(), 6);
700  $progress4 = $depth4->getProgressForAssignment($assignment->getId());
701  $progress4->markAccredited(6);
702 
703  $progress1 = $depth1->getProgressForAssignment($assignment->getId());
704  $progress2 = $depth2->getProgressForAssignment($assignment->getId());
705  $progress3 = $depth3->getProgressForAssignment($assignment->getId());
706 
707  $this->assertTrue($progress1->isSuccessful());
708  $this->assertTrue($progress2->isSuccessful());
709  $this->assertTrue($progress3->isSuccessful());
710  $this->assertTrue($progress4->isSuccessful());
711 
712  $this->assertEquals(ilStudyProgrammeSettings::DEFAULT_POINTS, $progress1->getCurrentAmountOfPoints());
713  $this->assertEquals(ilStudyProgrammeSettings::DEFAULT_POINTS, $progress2->getCurrentAmountOfPoints());
714  $this->assertEquals(ilStudyProgrammeSettings::DEFAULT_POINTS, $progress3->getCurrentAmountOfPoints());
715  $this->assertEquals(ilStudyProgrammeSettings::DEFAULT_POINTS, $progress4->getCurrentAmountOfPoints());
716  }
717 
718 
719  public function testPossibleActions()
720  {
721  //node is root-node, status is "not relevant"
722  $expected = array(
723  ilStudyProgrammeUserProgress::ACTION_SHOW_INDIVIDUAL_PLAN,
724  ilStudyProgrammeUserProgress::ACTION_REMOVE_USER
725  );
726  $this->assertEquals(
727  $expected,
728  ilStudyProgrammeUserProgress::getPossibleActions(
729  1,
730  1,
731  ilStudyProgrammeProgress::STATUS_NOT_RELEVANT
732  )
733  );
734 
735  //node is root-node, status is "in progress"
736  $expected = array(
737  ilStudyProgrammeUserProgress::ACTION_SHOW_INDIVIDUAL_PLAN,
738  ilStudyProgrammeUserProgress::ACTION_REMOVE_USER,
739  ilStudyProgrammeUserProgress::ACTION_MARK_ACCREDITED
740  );
741  $this->assertEquals(
742  $expected,
743  ilStudyProgrammeUserProgress::getPossibleActions(
744  1,
745  1,
746  ilStudyProgrammeProgress::STATUS_IN_PROGRESS
747  )
748  );
749 
750  //node is root-node, status is "accredited"
751  $expected = array(
752  ilStudyProgrammeUserProgress::ACTION_SHOW_INDIVIDUAL_PLAN,
753  ilStudyProgrammeUserProgress::ACTION_REMOVE_USER,
754  ilStudyProgrammeUserProgress::ACTION_UNMARK_ACCREDITED
755  );
756  $this->assertEquals(
757  $expected,
758  ilStudyProgrammeUserProgress::getPossibleActions(
759  1,
760  1,
761  ilStudyProgrammeProgress::STATUS_ACCREDITED
762  )
763  );
764 
765  //node is _not_ root-node, status is "accredited"
766  $expected = array(
767  ilStudyProgrammeUserProgress::ACTION_UNMARK_ACCREDITED
768  );
769  $this->assertEquals(
770  $expected,
771  ilStudyProgrammeUserProgress::getPossibleActions(
772  0,
773  1,
774  ilStudyProgrammeProgress::STATUS_ACCREDITED
775  )
776  );
777  }
778 
779  //get progress instance via DB-class
780  public function testGetInstance()
781  {
782  $this->setAllNodesActive();
783  $tmp = $this->assignNewUserToRoot();
784  $ass = $tmp[0];
785  $user = $tmp[1];
786 
787  $sp_user_progress_db = ilStudyProgrammeDIC::dic()['ilStudyProgrammeUserProgressDB'];
788  $inst = $sp_user_progress_db->getInstance(
789  $ass->getId(),
790  $this->root->getId(),
791  $user->getId()
792  );
793  $this->assertInstanceOf(ilStudyProgrammeUserProgress::class, $inst);
794  $this->assertEquals(
795  $this->root->getProgressesOf($user->getId()),
796  $sp_user_progress_db->getInstancesForUser($this->root->getId(), $user->getId())
797  );
798 
799  $up = $this->root->getProgressesOf($user->getId())[0];
800  $this->assertEquals(
801  $up,
802  $sp_user_progress_db->getInstanceById($up->getId())
803  );
804  }
805 
806  public function testGetInstanceCalls()
807  {
808  $sp_user_progress_db = ilStudyProgrammeDIC::dic()['ilStudyProgrammeUserProgressDB'];
809  try {
810  $sp_user_progress_db->getInstanceById(-1);
811  $this->assertFalse("This should not happen");
812  } catch (ilException $e) {
813  $this->assertTrue(true);
814  }
815 
816 
817  try {
818  $sp_user_progress_db->getInstancesForAssignment(-1);
819  $this->assertFalse("This should not happen");
820  } catch (ilStudyProgrammeNoProgressForAssignmentException $e) {
821  $this->assertTrue(true);
822  }
823  }
824 
825  public function test_limited_validity_period()
826  {
827  $prg1 = ilObjStudyProgramme::createInstance();
828  $prg2 = ilObjStudyProgramme::createInstance();
829 
830 
831  $prg1->putInTree(ROOT_FOLDER_ID);
832  $prg1->addNode($prg2);
833  $prg1->setValidityOfQualificationPeriod(100);
834 
835  $prg1->update();
836 
837  $prg1->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
838  $prg2->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
839 
840  $user = $this->newUser();
841 
842  $assignment = $prg1->assignUser($user->getId(), 6);
843  $progress2 = $prg2->getProgressForAssignment($assignment->getId());
844  $progress2->markAccredited(6);
845 
846  $progress1 = $prg1->getProgressForAssignment($assignment->getId());
847  $progress2 = $prg2->getProgressForAssignment($assignment->getId());
848 
849  $this->assertTrue($progress1->isSuccessful());
850  $this->assertTrue($progress2->isSuccessful());
851  $val_date = new DateTime();
852  $val_date->add(new DateInterval('P100D'));
853  $this->assertEquals(
854  $val_date->format('Ymd'),
855  $progress1->getValidityOfQualification()->format('Ymd')
856  );
857  $this->assertNull($progress2->getValidityOfQualification());
858  }
859 
860  public function test_limited_validity_date()
861  {
862  $prg1 = ilObjStudyProgramme::createInstance();
863  $prg2 = ilObjStudyProgramme::createInstance();
864 
865 
866  $prg1->putInTree(ROOT_FOLDER_ID);
867  $prg1->addNode($prg2);
868  $val_date_ref = new DateTime();
869  $val_date_ref->add(new DateInterval('P100D'));
870  $prg1->setValidityOfQualificationDate($val_date_ref);
871 
872  $prg1->update();
873 
874  $prg1->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
875  $prg2->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
876 
877  $user = $this->newUser();
878 
879  $assignment = $prg1->assignUser($user->getId(), 6);
880  $progress2 = $prg2->getProgressForAssignment($assignment->getId());
881  $progress2->markAccredited(6);
882 
883  $progress1 = $prg1->getProgressForAssignment($assignment->getId());
884  $progress2 = $prg2->getProgressForAssignment($assignment->getId());
885 
886  $this->assertTrue($progress1->isSuccessful());
887  $this->assertTrue($progress2->isSuccessful());
888  $this->assertEquals(
889  $val_date_ref->format('Ymd'),
890  $progress1->getValidityOfQualification()->format('Ymd')
891  );
892  }
893 
894 
895  public function test_limited_validity_accredited()
896  {
897  $prg1 = ilObjStudyProgramme::createInstance();
898 
899 
900  $prg1->putInTree(ROOT_FOLDER_ID);
901  $prg1->setValidityOfQualificationPeriod(100);
902  $prg1->update();
903 
904  $prg1->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
905 
906  $user = $this->newUser();
907 
908  $assignment = $prg1->assignUser($user->getId(), 6);
909  $progress1 = $prg1->getProgressForAssignment($assignment->getId());
910  $progress1->markAccredited(6);
911 
912  $progress1 = $prg1->getProgressForAssignment($assignment->getId());
913 
914  $this->assertTrue($progress1->isSuccessful());
915  $val_date = new DateTime();
916  $val_date->add(new DateInterval('P100D'));
917  $this->assertEquals($val_date->format('Ymd'), $progress1->getValidityOfQualification()->format('Ymd'));
918  }
919 
920  public function test_set_failed_limited_validity_future()
921  {
922  $prg1 = ilObjStudyProgramme::createInstance();
923  $prg2 = ilObjStudyProgramme::createInstance();
924 
925 
926  $prg1->putInTree(ROOT_FOLDER_ID);
927  $prg1->addNode($prg2);
928  $val_date_ref = new DateTime();
929  $val_date_ref->add(new DateInterval('P1D'));
930  $prg1->setValidityOfQualificationDate($val_date_ref);
931 
932  $prg1->update();
933 
934  $prg1->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
935  $prg2->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
936 
937  $user = $this->newUser();
938 
939  $assignment = $prg1->assignUser($user->getId(), 6);
940  $progress1 = $prg2->getProgressForAssignment($assignment->getId());
941  $this->assertFalse($progress1->isSuccessfulExpired());
942  $progress2 = $prg2->getProgressForAssignment($assignment->getId());
943  $progress2->markAccredited(6);
944 
945  $progress1 = $prg1->getProgressForAssignment($assignment->getId());
946  $this->assertEquals(
947  $val_date_ref->format('Ymd'),
948  $progress1->getValidityOfQualification()->format('Ymd')
949  );
950  $this->assertTrue($progress1->isSuccessful());
951  $this->assertFalse($progress1->isSuccessfulExpired());
952  try {
953  $progress1->markFailed(6);
954  $this->assertFalse('did not throw');
955  } catch (ilException $e) {
956  $this->assertTrue(true);
957  }
958  }
959 
960  public function test_set_failed_limited_validity_past()
961  {
962  $prg1 = ilObjStudyProgramme::createInstance();
963  $prg2 = ilObjStudyProgramme::createInstance();
964 
965 
966  $prg1->putInTree(ROOT_FOLDER_ID);
967  $prg1->addNode($prg2);
968  $val_date_ref = new DateTime();
969  $val_date_ref->sub(new DateInterval('P1D'));
970  $prg1->setValidityOfQualificationDate($val_date_ref);
971 
972  $prg1->update();
973 
974  $prg1->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
975  $prg2->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
976 
977  $user = $this->newUser();
978 
979  $assignment = $prg1->assignUser($user->getId(), 6);
980  $progress1 = $prg2->getProgressForAssignment($assignment->getId());
981  $this->assertFalse($progress1->isSuccessfulExpired());
982  $progress2 = $prg2->getProgressForAssignment($assignment->getId());
983  $progress2->markAccredited(6);
984 
985  $progress1 = $prg1->getProgressForAssignment($assignment->getId());
986  $this->assertEquals(
987  $val_date_ref->format('Ymd'),
988  $progress1->getValidityOfQualification()->format('Ymd')
989  );
990  $this->assertTrue($progress1->isSuccessful());
991  $this->assertTrue($progress1->isSuccessfulExpired());
992  try {
993  $progress1->invalidate();
994  $this->assertTrue(true);
995  } catch (ilException $e) {
996  $this->assertFalse('did throw');
997  }
998  $this->assertTrue($progress1->isSuccessful());
999  $this->assertTrue($progress1->isInvalidated());
1000  }
1001 
1002 
1003  public function test_set_failed_no_limited_validity()
1004  {
1005  $prg1 = ilObjStudyProgramme::createInstance();
1006  $prg2 = ilObjStudyProgramme::createInstance();
1007 
1008 
1009  $prg1->putInTree(ROOT_FOLDER_ID);
1010  $prg1->addNode($prg2);
1011 
1012  $prg1->update();
1013 
1014  $prg1->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
1015  $prg2->setStatus(ilStudyProgrammeSettings::STATUS_ACTIVE);
1016 
1017  $user = $this->newUser();
1018 
1019  $assignment = $prg1->assignUser($user->getId(), 6);
1020  $progress1 = $prg2->getProgressForAssignment($assignment->getId());
1021  $this->assertFalse($progress1->isSuccessfulExpired());
1022  $progress2 = $prg2->getProgressForAssignment($assignment->getId());
1023  $progress2->markAccredited(6);
1024 
1025  $progress1 = $prg1->getProgressForAssignment($assignment->getId());
1026  $this->assertNull($progress1->getValidityOfQualification());
1027  $this->assertTrue($progress1->isSuccessful());
1028  $this->assertFalse($progress1->isSuccessfulExpired());
1029  try {
1030  $progress1->invalidate();
1031  $this->assertFalse('did not throw');
1032  } catch (ilException $e) {
1033  $this->assertTrue(true);
1034  }
1035  $this->assertFalse($progress1->isInvalidated());
1036  }
1037 }
ilStudyProgrammeLeafMock
Mock classes for tests.
Definition: mocks.php:20
ilStudyProgrammeNoProgressForAssignmentException
Exception is thrown when a progress for some programme node and assignment is missing.
Definition: class.ilStudyProgrammeNoProgressForAssignmentException.php:10
ilStudyProgrammeUserProgressTest\testOutdatedNodesCantBeSetToRelevant
testOutdatedNodesCantBeSetToRelevant()
QUA-Objekte, welche "Inaktiv" sind können bei Studierenden-Studienplänen nicht von "nicht relevant" a...
Definition: ilStudyProgrammeUserProgressTest.php:590
user
user()
Definition: user.php:4
$ilUser
$ilUser
Definition: imgupload.php:18
ilStudyProgrammeUserProgress\getPossibleActions
static getPossibleActions(int $node_id, int $root_prg_id, int $status)
Get a list with possible actions on a progress record.
Definition: class.ilStudyProgrammeUserProgress.php:908
$DIC
$DIC
Definition: xapitoken.php:46
ilObjStudyProgramme\createInstance
static createInstance()
Create an instance of ilObjStudyProgramme, put in cache.
Definition: class.ilObjStudyProgramme.php:226
ilStudyProgrammeUserProgressTest
TestCase for the progress of users at a programme.
Definition: ilStudyProgrammeUserProgressTest.php:17
ilObjectFactoryWrapperMock
Mock for object factory.
Definition: mocks.php:68