Add training plan tests

src/main/java/MakeItFit/trainingPlan/TrainingPlan.java

@@ -2,6 +2,7 @@
 
 import java.io.Serializable;
 import java.util.*;
+import java.util.stream.Collectors;
 
 import MakeItFit.activities.Activity;
 import MakeItFit.users.UserManager;
@@ -87,7 +88,8 @@ public MakeItFitDate getStartDate() {
      * @return the activities
      */
     public List<MyTuple<Integer, Activity>> getActivities() {
-        return this.activities;
+        // CHANGED: failing association
+        return this.activities.stream().collect(Collectors.toList());
     }
 
     /**
@@ -115,6 +117,8 @@ public void addActivity(int repetitions, Activity activity) {
      * @param code the code of the activity to remove
      */
     public void removeActivity(UUID code) {
+        // NOTE: no information on whether this should throw an exception or not
+
         for (MyTuple<Integer, Activity> tuple : this.activities) {
             if (tuple.getItem2().getCode().equals(code)) {
                 this.activities.remove(tuple);
@@ -161,7 +165,7 @@ public List<Activity> extractActivities(MakeItFitDate currentDate) {
     @Override
     public String toString() {
         return "        == (Training plan details) =="
-            + "        \nTraining Plan: " + this.code + "\n        User Code: " + this.userCode +
+            + "\n        Training Plan: " + this.code + "\n        User Code: " + this.userCode +
             "\n        Start Date: " + this.startDate +
             "\n        Activities(Iterations / Activity): " + this.activities;
     }

src/main/java/MakeItFit/trainingPlan/TrainingPlanManager.java

@@ -8,6 +8,7 @@
 import MakeItFit.activities.HardInterface;
 import MakeItFit.activities.implementation.*;
 import MakeItFit.exceptions.EntityDoesNotExistException;
+import MakeItFit.exceptions.ExistingEntityConflictException;
 import MakeItFit.utils.ExtendedRandom;
 import MakeItFit.utils.MakeItFitDate;
 import MakeItFit.utils.MyTuple;
@@ -206,15 +207,17 @@ public TrainingPlan constructTrainingPlanByObjectives(TrainingPlan trainingPlan,
      *
      * @param trainingPlan the training plan to be inserted
      */
-    public void insertTrainingPlan(TrainingPlan trainingPlan) throws IllegalArgumentException {
+    public void insertTrainingPlan(TrainingPlan trainingPlan)
+        throws IllegalArgumentException, ExistingEntityConflictException {
 
         if (trainingPlan == null) {
             throw new IllegalArgumentException("Invalid input: trainingPlan cannot be null.");
         }
 
         if (this.trainingPlans.containsKey(trainingPlan.getCode())) {
-            throw new IllegalArgumentException("Training with code " + trainingPlan.getCode() +
-                                               " already exists.");
+            // CHANGE: change exception type
+            throw new ExistingEntityConflictException("Training with code " +
+                                                      trainingPlan.getCode() + " already exists.");
         }
 
         this.trainingPlans.put(trainingPlan.getCode(), trainingPlan);
@@ -226,6 +229,7 @@ public void insertTrainingPlan(TrainingPlan trainingPlan) throws IllegalArgument
      * @param code the code of the user
      */
     public void removeTrainingPlan(UUID code) {
+        // NOTE: no information on whether this should throw an exception or not
         this.trainingPlans.remove(code);
     }
 
@@ -234,13 +238,15 @@ public void removeTrainingPlan(UUID code) {
      *
      * @param code the code of the user
      * @return the training plan by the user code
-     * @throws IllegalArgumentException if the training plan does not exist
+     * @throws EntityDoesNotExistException if the training plan does not exist
      */
-    public TrainingPlan getTrainingPlan(UUID code) throws IllegalArgumentException {
+    public TrainingPlan getTrainingPlan(UUID code) throws EntityDoesNotExistException {
         TrainingPlan trainingPlan = this.trainingPlans.get(code);
 
         if (trainingPlan == null) {
-            throw new IllegalArgumentException("Training with code " + code + " does not exist.");
+            // CHANGE: type of exception
+            throw new EntityDoesNotExistException("Training with code " + code +
+                                                  " does not exist.");
         }
 
         return trainingPlan;
@@ -278,6 +284,7 @@ public List<TrainingPlan> getAllTrainingPlans() {
      * @param activity the activity to add
      */
     public void addActivity(UUID code, int repetitions, Activity activity) {
+        // NOTE: no information on whether this should throw an exception or not
         this.trainingPlans.get(code).addActivity(repetitions, activity);
     }
 
@@ -288,6 +295,7 @@ public void addActivity(UUID code, int repetitions, Activity activity) {
      * @param activity the code of the activity to remove
      */
     public void removeActivity(UUID code, UUID activity) {
+        // NOTE: no information on whether this should throw an exception or not
         this.trainingPlans.get(code).removeActivity(activity);
     }
 

src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java

@@ -2,14 +2,14 @@
 
 import java.util.UUID;
 
+import MakeItFit.utils.MakeItFitDate;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotSame;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import MakeItFit.utils.MakeItFitDate;
 
 public class RepetitionsTest {
     private TestRepetitions activity;

src/unittests/java/MakeItFit/trainingPlan/TrainingPlanManagerTest.java

@@ -0,0 +1,257 @@
+package MakeItFit.trainingPlan;
+
+import java.util.List;
+import java.util.UUID;
+
+import MakeItFit.activities.Activity;
+import MakeItFit.activities.implementation.PushUp;
+import MakeItFit.exceptions.EntityDoesNotExistException;
+import MakeItFit.exceptions.ExistingEntityConflictException;
+import MakeItFit.utils.MakeItFitDate;
+import MakeItFit.utils.MyTuple;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class TrainingPlanManagerTest {
+    private TrainingPlanManager referenceManager;
+    private TrainingPlan        referencePlan1;
+    private TrainingPlan        referencePlan2;
+    private Activity            referenceActivity1;
+    private Activity            referenceActivity2;
+
+    @BeforeEach
+    void initializeReferenceObjects() {
+        this.referenceManager = new TrainingPlanManager();
+
+        this.referencePlan1 = new TrainingPlan(UUID.randomUUID(), MakeItFitDate.of(2010, 5, 1));
+        this.referencePlan2 = new TrainingPlan(UUID.randomUUID(), MakeItFitDate.of(2030, 5, 1));
+
+        this.referenceActivity1 =
+            new PushUp(UUID.randomUUID(), MakeItFitDate.of(2000, 1, 1), 30, "", "", 10, 10);
+        this.referenceActivity2 =
+            new PushUp(UUID.randomUUID(), MakeItFitDate.of(2030, 1, 1), 1, "", "", 1, 1);
+
+        this.referencePlan2.addActivity(1, this.referenceActivity2);
+    }
+
+    @Test
+    void testConstructor() {
+        assertEquals(List.of(), (new TrainingPlanManager()).getAllTrainingPlans());
+    }
+
+    /*
+    @Test
+    void testConstructTrainingPlanByObjectives1() {
+        TrainingPlan plan = new TrainingPlan();
+        TrainingPlan generated = this.referenceManager.constructTrainingPlanByObjectives(plan, 1.0f,
+    false, 1, 100, 1, 10000);
+
+        assertSame(plan, generated);
+    }
+
+    @Test
+    void testConstructTrainingPlanByObjectives2() {
+        TrainingPlan plan = new TrainingPlan();
+        TrainingPlan generated = this.referenceManager.constructTrainingPlanByObjectives(plan, 1.0f,
+    true, 1, 100, 1, 10000);
+
+        assertSame(plan, generated);
+    }
+    */
+
+    @Test
+    void testCreateTrainingPlan1() {
+        assertThrows(IllegalArgumentException.class, () -> {
+            this.referenceManager.createTrainingPlan(null, new MakeItFitDate());
+        });
+    }
+
+    @Test
+    void testCreateTrainingPlan2() {
+        assertThrows(IllegalArgumentException.class,
+                     () -> { this.referenceManager.createTrainingPlan(UUID.randomUUID(), null); });
+    }
+
+    @Test
+    void testCreateTrainingPlan3() {
+        UUID          uuid = UUID.randomUUID();
+        MakeItFitDate date = new MakeItFitDate();
+
+        assertEquals(new TrainingPlan(uuid, date),
+                     this.referenceManager.createTrainingPlan(uuid, date));
+    }
+
+    @Test
+    void testInsertTrainingPlan1() {
+        assertThrows(IllegalArgumentException.class,
+                     () -> { this.referenceManager.insertTrainingPlan(null); });
+    }
+
+    @Test
+    void testInsertTrainingPlan2() {
+        this.referenceManager.insertTrainingPlan(this.referencePlan2);
+        assertThrows(ExistingEntityConflictException.class,
+                     () -> { this.referenceManager.insertTrainingPlan(this.referencePlan2); });
+    }
+
+    @Test
+    void testInsertTrainingPlan3() {
+        this.referenceManager.insertTrainingPlan(this.referencePlan1);
+        this.referenceManager.insertTrainingPlan(this.referencePlan2);
+
+        List<TrainingPlan> plans = this.referenceManager.getAllTrainingPlans();
+        assertTrue(plans.contains(this.referencePlan1));
+        assertTrue(plans.contains(this.referencePlan2));
+        assertEquals(2, plans.size());
+    }
+
+    @Test
+    void testRemoveTrainingPlan1() {
+        this.referenceManager.insertTrainingPlan(this.referencePlan1);
+        this.referenceManager.insertTrainingPlan(this.referencePlan2);
+        this.referenceManager.removeTrainingPlan(UUID.randomUUID());
+
+        List<TrainingPlan> plans = this.referenceManager.getAllTrainingPlans();
+        assertTrue(plans.contains(this.referencePlan1));
+        assertTrue(plans.contains(this.referencePlan2));
+        assertEquals(2, plans.size());
+    }
+
+    @Test
+    void testRemoveTrainingPlan2() {
+        this.referenceManager.insertTrainingPlan(this.referencePlan1);
+        this.referenceManager.insertTrainingPlan(this.referencePlan2);
+        this.referenceManager.removeTrainingPlan(this.referencePlan2.getCode());
+
+        assertEquals(List.of(this.referencePlan1), this.referenceManager.getAllTrainingPlans());
+    }
+
+    @Test
+    void testGetTrainingPlan1() {
+        this.referenceManager.insertTrainingPlan(this.referencePlan1);
+        assertSame(this.referencePlan1,
+                   this.referenceManager.getTrainingPlan(this.referencePlan1.getCode()));
+    }
+
+    @Test
+    void testGetTrainingPlan2() {
+        assertThrows(EntityDoesNotExistException.class,
+                     () -> { this.referenceManager.getTrainingPlan(UUID.randomUUID()); });
+    }
+
+    @Test
+    void testUpdateTrainingPlan1() {
+        this.referenceManager.insertTrainingPlan(this.referencePlan1);
+        assertThrows(EntityDoesNotExistException.class,
+                     () -> { this.referenceManager.updateTrainingPlan(this.referencePlan2); });
+    }
+
+    @Test
+    void testUpdateTrainingPlan2() {
+        this.referenceManager.insertTrainingPlan(this.referencePlan2);
+
+        TrainingPlan copy = this.referencePlan2.clone();
+        copy.setStartDate(new MakeItFitDate());
+        this.referenceManager.updateTrainingPlan(copy);
+
+        assertEquals(copy, this.referenceManager.getTrainingPlan(copy.getCode()));
+    }
+
+    @Test
+    void testAddActivity1() {
+        this.referenceManager.insertTrainingPlan(this.referencePlan2);
+        this.referenceManager.addActivity(this.referencePlan2.getCode(),
+                                          10,
+                                          this.referenceActivity1);
+
+        assertEquals(List.of(new MyTuple<Integer, Activity>(1, this.referenceActivity2),
+                             new MyTuple<Integer, Activity>(10, this.referenceActivity1)),
+                     referencePlan2.getActivities());
+    }
+
+    @Test
+    void testAddActivity2() {
+        assertThrows(NullPointerException.class, () -> {
+            this.referenceManager.addActivity(this.referencePlan2.getCode(),
+                                              10,
+                                              this.referenceActivity1);
+        });
+    }
+
+    @Test
+    void testRemoveActivity1() {
+        this.referenceManager.insertTrainingPlan(this.referencePlan1);
+        assertThrows(NullPointerException.class, () -> {
+            this.referenceManager.removeActivity(UUID.randomUUID(), UUID.randomUUID());
+        });
+    }
+
+    @Test
+    void testRemoveActivity2() {
+        this.referenceManager.insertTrainingPlan(this.referencePlan2);
+        this.referenceManager.removeActivity(this.referencePlan2.getCode(),
+                                             this.referenceActivity2.getCode());
+        assertEquals(List.of(), this.referencePlan1.getActivities());
+    }
+
+    @Test
+    void testGetTrainingPlansFromUser1() {
+        assertEquals(List.of(), this.referenceManager.getTrainingPlansFromUser(UUID.randomUUID()));
+    }
+
+    @Test
+    void testGetTrainingPlansFromUser2() {
+        this.referenceManager.insertTrainingPlan(this.referencePlan2);
+        assertEquals(
+            List.of(this.referencePlan2),
+            this.referenceManager.getTrainingPlansFromUser(this.referencePlan2.getUserCode()));
+    }
+
+    @Test
+    void testGetTrainingPlansFromUser3() {
+        UUID         uuid  = UUID.randomUUID();
+        TrainingPlan plan1 = new TrainingPlan(uuid, MakeItFitDate.of(2030, 5, 1));
+        TrainingPlan plan2 = new TrainingPlan(uuid, MakeItFitDate.of(2030, 5, 1));
+        TrainingPlan plan3 = new TrainingPlan(UUID.randomUUID(), MakeItFitDate.of(2030, 5, 1));
+
+        this.referenceManager.insertTrainingPlan(plan1);
+        this.referenceManager.insertTrainingPlan(plan2);
+        this.referenceManager.insertTrainingPlan(plan3);
+
+        List<TrainingPlan> plans = this.referenceManager.getTrainingPlansFromUser(uuid);
+        assertTrue(plans.contains(plan1));
+        assertTrue(plans.contains(plan2));
+        assertEquals(2, plans.size());
+    }
+
+    @Test
+    void testUpdateActivities() {
+        this.referencePlan2.addActivity(1, this.referenceActivity1);
+        this.referenceManager.insertTrainingPlan(this.referencePlan2);
+
+        this.referenceManager.updateActivities(MakeItFitDate.of(2020, 1, 1), 1.0f);
+        assertNotEquals(0, this.referenceActivity1.getCaloricWaste());
+        assertEquals(0, this.referenceActivity2.getCaloricWaste());
+    }
+
+    @Test
+    void testExtractActivities() {
+        UUID         uuid  = UUID.randomUUID();
+        TrainingPlan plan1 = new TrainingPlan(uuid, MakeItFitDate.of(2030, 5, 1));
+        TrainingPlan plan2 = new TrainingPlan(uuid, MakeItFitDate.of(2030, 5, 1));
+        TrainingPlan plan3 = new TrainingPlan(UUID.randomUUID(), MakeItFitDate.of(2030, 5, 1));
+
+        plan1.addActivity(1, this.referenceActivity1);
+        plan2.addActivity(5, this.referenceActivity2);
+
+        this.referenceManager.insertTrainingPlan(plan1);
+        this.referenceManager.insertTrainingPlan(plan2);
+        this.referenceManager.insertTrainingPlan(plan3);
+
+        List<Activity> done =
+            this.referenceManager.extractActivities(MakeItFitDate.of(2020, 1, 1), uuid);
+        assertEquals(List.of(this.referenceActivity1), done);
+    }
+}