From b0080c4a620d698fd4da154c04f111f4d56af489 Mon Sep 17 00:00:00 2001 From: Voidbert Date: Wed, 4 Jun 2025 20:33:15 +0100 Subject: [PATCH] Add training plan tests --- .../MakeItFit/trainingPlan/TrainingPlan.java | 8 +- .../trainingPlan/TrainingPlanManager.java | 20 +- .../activities/types/RepetitionsTest.java | 8 +- .../trainingPlan/TrainingPlanManagerTest.java | 257 ++++++++++++++++++ .../trainingPlan/TrainingPlanTest.java | 211 ++++++++++++++ 5 files changed, 492 insertions(+), 12 deletions(-) create mode 100644 src/unittests/java/MakeItFit/trainingPlan/TrainingPlanManagerTest.java create mode 100644 src/unittests/java/MakeItFit/trainingPlan/TrainingPlanTest.java diff --git a/src/main/java/MakeItFit/trainingPlan/TrainingPlan.java b/src/main/java/MakeItFit/trainingPlan/TrainingPlan.java index b8c58db..91ec78e 100644 --- a/src/main/java/MakeItFit/trainingPlan/TrainingPlan.java +++ b/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> 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 tuple : this.activities) { if (tuple.getItem2().getCode().equals(code)) { this.activities.remove(tuple); @@ -161,7 +165,7 @@ public List 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; } diff --git a/src/main/java/MakeItFit/trainingPlan/TrainingPlanManager.java b/src/main/java/MakeItFit/trainingPlan/TrainingPlanManager.java index 618a42a..16cd8e3 100644 --- a/src/main/java/MakeItFit/trainingPlan/TrainingPlanManager.java +++ b/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 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); } diff --git a/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java b/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java index e0947b0..5961707 100644 --- a/src/unittests/java/MakeItFit/activities/types/RepetitionsTest.java +++ b/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; diff --git a/src/unittests/java/MakeItFit/trainingPlan/TrainingPlanManagerTest.java b/src/unittests/java/MakeItFit/trainingPlan/TrainingPlanManagerTest.java new file mode 100644 index 0000000..a3a36ca --- /dev/null +++ b/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 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 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(1, this.referenceActivity2), + new MyTuple(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 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 done = + this.referenceManager.extractActivities(MakeItFitDate.of(2020, 1, 1), uuid); + assertEquals(List.of(this.referenceActivity1), done); + } +} diff --git a/src/unittests/java/MakeItFit/trainingPlan/TrainingPlanTest.java b/src/unittests/java/MakeItFit/trainingPlan/TrainingPlanTest.java new file mode 100644 index 0000000..c4b3617 --- /dev/null +++ b/src/unittests/java/MakeItFit/trainingPlan/TrainingPlanTest.java @@ -0,0 +1,211 @@ +package MakeItFit.trainingPlan; + +import java.util.List; +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +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 TrainingPlanTest { + private TrainingPlan referencePlan; + private UUID referenceUserCode; + private MakeItFitDate referenceStartDate; + private Activity referenceActivity1; + private Activity referenceActivity2; + + @BeforeEach + void initializeReferenceObjects() { + this.referenceUserCode = UUID.randomUUID(); + this.referencePlan = new TrainingPlan(this.referenceUserCode, MakeItFitDate.of(2024, 5, 1)); + + this.referenceActivity1 = + new PushUp(this.referenceUserCode, MakeItFitDate.of(2000, 1, 1), 30, "", "", 10, 10); + this.referenceActivity2 = + new PushUp(this.referenceUserCode, MakeItFitDate.of(2030, 1, 1), 1, "", "", 1, 1); + } + + @Test + void testEmptyConstructor() { + TrainingPlan plan = new TrainingPlan(); + assertEquals(List.of(), plan.getActivities()); + } + + @Test + void testCopyConstructor() { + TrainingPlan plan = new TrainingPlan(this.referencePlan); + assertEquals(this.referencePlan.getCode(), plan.getCode()); + assertEquals(this.referencePlan.getUserCode(), plan.getUserCode()); + assertEquals(this.referencePlan.getStartDate(), plan.getStartDate()); + assertEquals(this.referencePlan.getActivities(), plan.getActivities()); + } + + @Test + void testGetActivities() { + List> activities = this.referencePlan.getActivities(); + activities.add(new MyTuple(10, this.referenceActivity1)); + assertNotEquals(this.referencePlan.getActivities(), activities); + } + + @Test + void testSetStartDate() { + this.referencePlan.setStartDate(MakeItFitDate.of(2024, 10, 1)); + assertEquals(MakeItFitDate.of(2024, 10, 1), this.referencePlan.getStartDate()); + } + + @Test + void testAddActivity1() { + this.referencePlan.addActivity(10, this.referenceActivity1); + } + + @Test + void testRemoveActivity1() { + this.referencePlan.addActivity(1, this.referenceActivity1); + this.referencePlan.addActivity(2, this.referenceActivity2); + this.referencePlan.removeActivity(UUID.randomUUID()); + assertEquals(2, this.referencePlan.getActivities().size()); + } + + @Test + void testRemoveActivity2() { + this.referencePlan.addActivity(10, this.referenceActivity1); + this.referencePlan.addActivity(2, this.referenceActivity2); + this.referencePlan.removeActivity(this.referenceActivity2.getCode()); + assertEquals(List.of(new MyTuple(10, this.referenceActivity1)), + this.referencePlan.getActivities()); + } + + @Test + void testUpdateActivities() { + assertEquals(0, this.referenceActivity1.getCaloricWaste()); + assertEquals(0, this.referenceActivity2.getCaloricWaste()); + + this.referencePlan.addActivity(10, this.referenceActivity1); + this.referencePlan.addActivity(2, this.referenceActivity2); + this.referencePlan.updateActivities(MakeItFitDate.of(2020, 1, 1), 5.0f); + + List> activities = this.referencePlan.getActivities(); + assertNotEquals(0, activities.get(0).getItem2().getCaloricWaste()); + assertEquals(0, activities.get(1).getItem2().getCaloricWaste()); + } + + @Test + void testToString() { + String got = this.referencePlan.toString(); + String expected = " == (Training plan details) ==" + + "\n Training Plan: " + this.referencePlan.getCode() + + "\n User Code: " + this.referencePlan.getUserCode() + + "\n Start Date: " + this.referencePlan.getStartDate() + + "\n Activities(Iterations / Activity): []"; + + assertEquals(expected, got); + } + + @Test + void testExtractActivities1() { + assertEquals(List.of(), this.referencePlan.extractActivities(MakeItFitDate.of(2100, 1, 1))); + } + + @Test + void testExtractActivities2() { + this.referencePlan.addActivity(10, this.referenceActivity1); + this.referencePlan.addActivity(2, this.referenceActivity2); + + assertEquals(List.of(this.referenceActivity1, this.referenceActivity2), + this.referencePlan.extractActivities(MakeItFitDate.of(2100, 1, 1))); + } + + @Test + void testExtractActivities3() { + this.referencePlan.addActivity(10, this.referenceActivity1); + this.referencePlan.addActivity(2, this.referenceActivity2); + + assertEquals(List.of(this.referenceActivity1), + this.referencePlan.extractActivities(MakeItFitDate.of(2015, 1, 1))); + } + + @Test + void testEquals1() { + assertEquals(this.referencePlan, this.referencePlan); + } + + @Test + void testEquals2() { + assertNotEquals(this.referencePlan, null); + } + + @Test + void testEquals3() { + assertEquals(this.referencePlan, + new TrainingPlan(this.referenceUserCode, MakeItFitDate.of(2024, 5, 1))); + } + + @Test + void testEquals4() { + assertNotEquals(this.referencePlan, + new TrainingPlan(UUID.randomUUID(), MakeItFitDate.of(2024, 5, 1))); + } + + @Test + void testEquals5() { + TrainingPlan copy = this.referencePlan.clone(); + copy.setStartDate(MakeItFitDate.of(2020, 10, 16)); + assertNotEquals(this.referencePlan, copy); + } + + @Test + void testEquals6() { + TrainingPlan copy = this.referencePlan.clone(); + copy.addActivity(6, this.referenceActivity1); + assertNotEquals(this.referencePlan, copy); + } + + @Test + void testCompareTo1() { + assertEquals(0, this.referencePlan.compareTo(this.referencePlan)); + } + + @Test + void testCompareTo2() { + assertEquals(0, this.referencePlan.compareTo(this.referencePlan.clone())); + } + + @Test + void testCompareTo3() { + TrainingPlan copy = this.referencePlan.clone(); + copy.setStartDate(MakeItFitDate.of(2020, 10, 16)); + assertTrue(this.referencePlan.compareTo(copy) > 0); + } + + @Test + void testCompareTo4() { + TrainingPlan copy = this.referencePlan.clone(); + copy.addActivity(6, this.referenceActivity1); + assertTrue(this.referencePlan.compareTo(copy) < 0); + } + + @Test + void testClone1() { + TrainingPlan plan = this.referencePlan.clone(); + assertEquals(this.referencePlan.getCode(), plan.getCode()); + assertEquals(this.referencePlan.getUserCode(), plan.getUserCode()); + assertEquals(this.referencePlan.getStartDate(), plan.getStartDate()); + assertEquals(this.referencePlan.getActivities(), plan.getActivities()); + } + + @Test + void testClone2() { + this.referencePlan.addActivity(1, this.referenceActivity2); + + TrainingPlan plan = this.referencePlan.clone(); + assertEquals(this.referencePlan.getCode(), plan.getCode()); + assertEquals(this.referencePlan.getUserCode(), plan.getUserCode()); + assertEquals(this.referencePlan.getStartDate(), plan.getStartDate()); + assertEquals(this.referencePlan.getActivities(), plan.getActivities()); + } +}