From afc7cf735ddc032ddaf166ec083afd5737e654a7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Lopes?= Date: Fri, 23 May 2025 21:05:38 +0100 Subject: [PATCH 01/10] setup unit testing for queries and utils --- .../java/MakeItFit/queries/HowManyAltimetryDoneTest.java | 5 +++++ src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java | 5 +++++ .../MakeItFit/queries/MostDemandingTrainingPlanTest.java | 5 +++++ .../java/MakeItFit/queries/MostDoneActivityTest.java | 5 +++++ src/unittests/java/MakeItFit/queries/QueriesManagerTest.java | 5 +++++ .../java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java | 5 +++++ .../java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java | 5 +++++ src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java | 5 +++++ src/unittests/java/MakeItFit/utils/MyTupleTest.java | 5 +++++ 9 files changed, 45 insertions(+) create mode 100644 src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java create mode 100644 src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java create mode 100644 src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java create mode 100644 src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java create mode 100644 src/unittests/java/MakeItFit/queries/QueriesManagerTest.java create mode 100644 src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java create mode 100644 src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java create mode 100644 src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java create mode 100644 src/unittests/java/MakeItFit/utils/MyTupleTest.java diff --git a/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java b/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java new file mode 100644 index 0000000..b2b88db --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java @@ -0,0 +1,5 @@ +package MakeItFit.queries; + +public class HowManyAltimetryDoneTest { + +} diff --git a/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java b/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java new file mode 100644 index 0000000..cba2134 --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java @@ -0,0 +1,5 @@ +package MakeItFit.queries; + +public class HowManyKMsDoneTest { + +} diff --git a/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java b/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java new file mode 100644 index 0000000..8a95b6b --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java @@ -0,0 +1,5 @@ +package MakeItFit.queries; + +public class MostDemandingTrainingPlanTest { + +} diff --git a/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java b/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java new file mode 100644 index 0000000..d4cff49 --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java @@ -0,0 +1,5 @@ +package MakeItFit.queries; + +public class MostDoneActivityTest { + +} diff --git a/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java b/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java new file mode 100644 index 0000000..449d903 --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java @@ -0,0 +1,5 @@ +package MakeItFit.queries; + +public class QueriesManagerTest { + +} diff --git a/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java b/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java new file mode 100644 index 0000000..a9edfc8 --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java @@ -0,0 +1,5 @@ +package MakeItFit.queries; + +public class WhoBurnsMoreCaloriesTest { + +} diff --git a/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java b/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java new file mode 100644 index 0000000..9288a0f --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java @@ -0,0 +1,5 @@ +package MakeItFit.queries; + +public class WhoDidTheMostActivitiesTest { + +} diff --git a/src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java b/src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java new file mode 100644 index 0000000..62ba523 --- /dev/null +++ b/src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java @@ -0,0 +1,5 @@ +package MakeItFit.utils; + +public class MakeItFitDateTest { + +} diff --git a/src/unittests/java/MakeItFit/utils/MyTupleTest.java b/src/unittests/java/MakeItFit/utils/MyTupleTest.java new file mode 100644 index 0000000..bf111b9 --- /dev/null +++ b/src/unittests/java/MakeItFit/utils/MyTupleTest.java @@ -0,0 +1,5 @@ +package MakeItFit.utils; + +public class MyTupleTest { + +} From a8d1b53899292c0647af0ef087a1ceb3729b2017 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Lopes?= Date: Tue, 3 Jun 2025 03:25:25 +0100 Subject: [PATCH 02/10] add tests to test suite --- .../queries/HowManyAltimetryDoneTest.java | 197 ++++++++++++++++++ .../MakeItFit/queries/HowManyKMsDoneTest.java | 184 ++++++++++++++++ .../MostDemandingTrainingPlanTest.java | 190 +++++++++++++++++ .../queries/MostDoneActivityTest.java | 169 +++++++++++++++ 4 files changed, 740 insertions(+) diff --git a/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java b/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java index b2b88db..6eb0fb2 100644 --- a/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java +++ b/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java @@ -1,5 +1,202 @@ package MakeItFit.queries; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.activities.implementation.Trail; + +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Professional; +import MakeItFit.utils.MakeItFitDate; +import MakeItFit.users.User; +import MakeItFit.users.Gender; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.Arrays; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + public class HowManyAltimetryDoneTest { + private HowManyAltimetryDone query; + private UserManager userManager; + private User user; + + private Trail createTrail(MakeItFitDate date, double elevationGain, double getElevationLoss) { + return new Trail( + user.getCode(), + date, + 90, + "Hiking", + "Subir ao Bom Jesus", + 2000.0, + elevationGain, + getElevationLoss, + 1 + ); + } + + private PushUp createPushUp(MakeItFitDate date) { + return new PushUp( + user.getCode(), + date, + 90, + "PushUps", + "100x", + 10, + 100 + ); + } + + @BeforeEach + void testSetup() { + this.query = new HowManyAltimetryDone(); + this.userManager = new UserManager(); + + this.user = new Professional( + "JohnDoe", + 21, + Gender.Male, + 59, + 150, + 60, + 6, + "Lloyd", + "987 123 432", + "jd@suspect.pt", + 7 + ); + } + + @Test + void testExecuteQueryWithDatesReturnsTrueAltimetry() { + user.addActivities(Arrays.asList( + createTrail( + MakeItFitDate.of(1999, 2, 9), + 229.12, + 142.0 + ), + createTrail( + MakeItFitDate.of(1999, 2, 14), + 654.129, + 532.0 + ) + )); + userManager.insertUser(user); + + assertEquals( + 229.12 + 142.0 + 654.129 + 532.0, + query.executeQuery( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(1999, 3, 1) + ), + 0.0001 + ); + } + + @Test + void testExecuteQueryWithDatesThrows() { + assertThrows( + IllegalArgumentException.class, + () -> query.executeQuery( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 9), + MakeItFitDate.of(1999, 2, 9) + ) + ); + } + + @Test + void testExecuteQueryWithDatesNoValidActivities() { + user.addActivities(Arrays.asList( + createPushUp( + MakeItFitDate.of(1999, 2, 9) + ) + )); + userManager.insertUser(user); + + assertEquals( + 0, + query.executeQuery( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 9), + MakeItFitDate.of(1999, 3, 1) + ) + ); + } + + @Test + void testExecuteQueryWithDatesActivitiesOutsideTimeWindow() { + user.addActivities(Arrays.asList( + createTrail( + MakeItFitDate.of(1999, 2, 9), + 229.12, + 142.0 + ), + createTrail( + MakeItFitDate.of(1999, 2, 14), + 654.129, + 532.0 + ) + )); + userManager.insertUser(user); + + assertEquals( + 0, + query.executeQuery( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 4, 9), + MakeItFitDate.of(1999, 4, 10) + ) + ); + } + + @Test + void testExecuteQueryReturnsTrueAltimetry() { + user.addActivities(Arrays.asList( + createTrail( + MakeItFitDate.of(1999, 2, 9), + 229.12, + 142.0 + ), + createTrail( + MakeItFitDate.of(1999, 2, 14), + 654.129, + 532.0 + ) + )); + userManager.insertUser(user); + + assertEquals( + 229.12 + 142.0 + 654.129 + 532.0, + query.executeQuery( + userManager, + "jd@suspect.pt" + ), + 0.0001 + ); + } + + @Test + void testExecuteQueryActivitiesOutsideTimeWindow() { + user.addActivities(Arrays.asList( + createPushUp( + MakeItFitDate.of(1999, 2, 9) + ) + )); + userManager.insertUser(user); + assertEquals( + 0, + query.executeQuery( + userManager, + "jd@suspect.pt" + ) + ); + } } diff --git a/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java b/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java index cba2134..3b7a27a 100644 --- a/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java +++ b/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java @@ -1,5 +1,189 @@ package MakeItFit.queries; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.Arrays; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.activities.implementation.Running; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Professional; +import MakeItFit.utils.MakeItFitDate; + public class HowManyKMsDoneTest { + private HowManyKMsDone query; + private UserManager userManager; + private User user; + + private Running createRunning(MakeItFitDate date, double distance) { + return new Running( + user.getCode(), + date, + 84, + "StreetRace", + "Corrida de Viana", + distance, + 12 + ); + } + + private PushUp createPushUp(MakeItFitDate date) { + return new PushUp( + user.getCode(), + date, + 90, + "PushUps", + "100x", + 10, + 100 + ); + } + + @BeforeEach + void testSetup() { + this.query = new HowManyKMsDone(); + this.userManager = new UserManager(); + + this.user = new Professional( + "JohnDoe", + 21, + Gender.Male, + 59, + 150, + 60, + 6, + "Lloyd", + "987 123 432", + "jd@suspect.pt", + 7 + ); + } + + @Test + void testExecuteQueryWithDatesReturnsTrueDistance() { + user.addActivities(Arrays.asList( + createRunning( + MakeItFitDate.of(1999, 2, 9), + 20000.0 + ), + createRunning( + MakeItFitDate.of(1999, 3, 9), + 4567.231 + ) + )); + userManager.insertUser(user); + + assertEquals( + (20000.0 + 4567.231) / 1000, + query.executeQuery( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(1999, 3, 10) + ), + 0.0001 + ); + } + + @Test + void testExecuteQueryWithDatesThrows() { + assertThrows( + IllegalArgumentException.class, + () -> query.executeQuery( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 9), + MakeItFitDate.of(1999, 2, 9) + ) + ); + } + + @Test + void testExecuteQueryWithDatesNoValidActivities() { + user.addActivities(Arrays.asList( + createPushUp( + MakeItFitDate.of(1999, 2, 9) + ) + )); + userManager.insertUser(user); + + assertEquals( + 0, + query.executeQuery( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 9), + MakeItFitDate.of(1999, 3, 1) + ) + ); + } + + @Test + void testExecuteQueryWithDatesActivitiesOutsideTimeWindow() { + user.addActivities(Arrays.asList( + createRunning( + MakeItFitDate.of(1999, 2, 9), + 123.143 + ) + )); + userManager.insertUser(user); + + assertEquals( + 0, + query.executeQuery( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 9), + MakeItFitDate.of(1999, 4, 10) + ) + ); + } + + @Test + void testExecuteQueryReturnsTrueDistance() { + user.addActivities(Arrays.asList( + createRunning( + MakeItFitDate.of(1999, 2, 9), + 2122.12 + ), + createRunning( + MakeItFitDate.of(1999, 2, 14), + 233.231 + ) + )); + userManager.insertUser(user); + + assertEquals( + (2122.12 + 233.231) / 1000, + query.executeQuery( + userManager, + "jd@suspect.pt" + ), + 0.0001 + ); + } + + @Test + void testExecuteQueryNoValidActivities() { + user.addActivities(Arrays.asList( + createPushUp( + MakeItFitDate.of(1999, 2, 9) + ) + )); + userManager.insertUser(user); + assertEquals( + 0, + query.executeQuery( + userManager, + "jd@suspect.pt" + ) + ); + } } diff --git a/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java b/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java index 8a95b6b..7219f59 100644 --- a/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java +++ b/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java @@ -1,5 +1,195 @@ package MakeItFit.queries; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; + +import java.util.Arrays; +import java.util.List; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import MakeItFit.trainingPlan.TrainingPlan; +import MakeItFit.trainingPlan.TrainingPlanManager; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Professional; +import MakeItFit.utils.MakeItFitDate; +import MakeItFit.utils.MyTuple; +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.activities.implementation.Running; +import MakeItFit.activities.implementation.Trail; +import MakeItFit.activities.implementation.WeightSquat; + public class MostDemandingTrainingPlanTest { + private MostDemandingTrainingPlan query; + private TrainingPlanManager TPManager; + private UserManager userManager; + private User user; + + private TrainingPlan createTrainingPlan(List> activities) { + TrainingPlan tl = new TrainingPlan( + user.getCode(), + MakeItFitDate.of(2000, 1, 1) + ); + + for (MyTuple activity : activities) { + tl.addActivity(activity.getItem1(), activity.getItem2()); + } + + return tl; + } + + private PushUp createPushUp(int repetitions, int series) { + return new PushUp( + user.getCode(), + MakeItFitDate.of(2000, 1, 1), + 60, + "PushUp", + "DO IT", + repetitions, + series + ); + } + + private Running createRunning(double distance, double speed) { + return new Running( + user.getCode(), + MakeItFitDate.of(2000, 1, 1), + 70, + "Running", + "For my life", + distance, + speed + ); + } + + private Trail createTrail(double distance, double elevationGain, double elevationLoss) { + return new Trail( + user.getCode(), + MakeItFitDate.of(2000, 1, 1), + 120, + "Trail", + "RunningUpThatHill", + distance, + elevationGain, + elevationLoss, + 2 + ); + } + + private WeightSquat createWeightSquat(int repetitions, int series, double weight) { + return new WeightSquat( + user.getCode(), + MakeItFitDate.of(2000, 1, 1), + 45, + "WeightSquat", + "PumpItUp", + repetitions, + series, + weight + ); + } + + @BeforeEach + void testSetup() { + this.query = new MostDemandingTrainingPlan(); + this.TPManager = new TrainingPlanManager(); + this.userManager = new UserManager(); + + this.user = new Professional( + "JohnDoe", + 21, + Gender.Male, + 59, + 150, + 60, + 6, + "Lloyd", + "987 123 432", + "jd@suspect.pt", + 7 + ); + userManager.insertUser(user); + } + + @Test + void testExecuteQueryNoPlans() { + assertNull(query.executeQuery(this.TPManager, this.userManager)); + } + + @Test + void testExecuteQuerySinglePlan() { + TrainingPlan tp = createTrainingPlan(Arrays.asList( + new MyTuple( + 1, + createTrail(7000, 212.23, 412.1234) + ), + new MyTuple(2, createPushUp(10, 100)) + )); + this.TPManager.insertTrainingPlan(tp); + + assertSame(tp, query.executeQuery(this.TPManager, this.userManager)); + } + + @Test + void testExecuteQueryMultiplePlans() { + TrainingPlan tp1 = createTrainingPlan(Arrays.asList( + new MyTuple( + 1, + createTrail(7000, 212.23, 412.1234) + ), + new MyTuple(2, createPushUp(10, 100)) + )); + TrainingPlan tp2 = createTrainingPlan(Arrays.asList( + new MyTuple(2, createRunning(7000, 12)), + new MyTuple(2, createWeightSquat(10, 100, 50)) + )); + + this.TPManager.insertTrainingPlan(tp1); + this.TPManager.insertTrainingPlan(tp2); + + + /* Calculate calories for the first plan */ + double caloriesTp1 = 0; + for (MyTuple tuple : tp1.getActivities()) { + caloriesTp1 += tuple.getItem1() * tuple.getItem2().caloricWaste(user.getIndex()); + } + + /* Calculate calories for the second plan */ + double caloriesTp2 = 0; + for (MyTuple tuple : tp2.getActivities()) { + caloriesTp2 += tuple.getItem1() * tuple.getItem2().caloricWaste(user.getIndex()); + } + + assertSame( + caloriesTp1 >= caloriesTp2 ? tp1 : tp2, + query.executeQuery(this.TPManager, this.userManager) + ); + } + + @Test + void testExecuteQueryTieReturnsFirst() { + TrainingPlan tp1 = createTrainingPlan(Arrays.asList( + new MyTuple( + 1, + createTrail(7000, 212.23, 412.1234) + ), + new MyTuple(2, createPushUp(10, 100)) + )); + TrainingPlan tp1Copy = createTrainingPlan(Arrays.asList( + new MyTuple( + 1, + createTrail(7000, 212.23, 412.1234) + ), + new MyTuple(2, createPushUp(10, 100)) + )); + + this.TPManager.insertTrainingPlan(tp1); + this.TPManager.insertTrainingPlan(tp1Copy); + assertSame(tp1, query.executeQuery(this.TPManager, this.userManager)); + } } diff --git a/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java b/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java index d4cff49..5f56947 100644 --- a/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java +++ b/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java @@ -1,5 +1,174 @@ package MakeItFit.queries; +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.rmi.server.UID; +import java.util.Arrays; +import java.util.List; +import java.util.UUID; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.activities.implementation.Running; +import MakeItFit.activities.implementation.Trail; +import MakeItFit.activities.implementation.WeightSquat; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Professional; +import MakeItFit.utils.MakeItFitDate; + public class MostDoneActivityTest { + private MostDoneActivity query; + private UserManager userManager; + + private PushUp pushUp; + private Running running; + private Trail trail; + private WeightSquat weightSquat; + + private User createUser(List activities) { + User user = new Professional( + "JohnDoe", + 21, + Gender.Male, + 59, + 150, + 60, + 6, + "Lloyd", + "987 123 432", + "jd@suspect.pt", + 7 + ); + + user.addActivities(activities); + return user; + } + + @BeforeEach + void testSetup() { + this.query = new MostDoneActivity(); + this.userManager = new UserManager(); + + this.pushUp = new PushUp( + UUID.randomUUID(), + MakeItFitDate.of(2000, 1, 1), + 60, + "PushUp", + "DO IT", + 10, + 100 + ); + this.running = new Running( + UUID.randomUUID(), + MakeItFitDate.of(2000, 1, 1), + 70, + "Running", + "For my life", + 100, + 1 + ); + this.trail = new Trail( + UUID.randomUUID(), + MakeItFitDate.of(2000, 1, 1), + 120, + "Trail", + "RunningUpThatHill", + 100, + 123, + 321, + 2 + ); + this.weightSquat = new WeightSquat( + UUID.randomUUID(), + MakeItFitDate.of(2000, 1, 1), + 45, + "WeightSquat", + "PumpItUp", + 10, + 100, + 46 + ); + } + + @Test + void testExecuteQueryNoUsers() { + assertEquals("DistanceWithAltimetry", this.query.executeQuery(this.userManager)); + } + + @Test + void testExecuteQuerySingleUserReturnsRepetitions() { + User user = createUser(Arrays.asList( + this.pushUp, + this.pushUp, + this.pushUp, + this.pushUp, + this.running, + this.running, + this.trail, + this.trail, + this.trail, + this.weightSquat, + this.weightSquat, + this.weightSquat, + this.weightSquat + )); + this.userManager.insertUser(user); + + assertEquals("Repetitions", this.query.executeQuery(this.userManager)); + } + + @Test + void testExecuteQueryMultipleUsersReturnsDistance() { + User user1 = createUser(Arrays.asList(this.pushUp, this.pushUp)); + User user2 = createUser(Arrays.asList(this.trail)); + User user3 = createUser(Arrays.asList(this.running, this.running, this.running)); + User user4 = createUser(Arrays.asList(this.weightSquat, this.weightSquat)); + + this.userManager.insertUser(user1); + this.userManager.insertUser(user2); + this.userManager.insertUser(user3); + this.userManager.insertUser(user4); + + assertEquals("Distance", this.query.executeQuery(this.userManager)); + } + + /* + @Test + @DisplayName("Tie between 'Repetitions' and 'Distance' → returns 'DistanceWithAltimetry'? No: check exact index mapping") + void testExecuteQuery_tieBetweenTwoCategories() { + // Arrange: Build two users leading to a tie between index 1 (Distance) and index 3 (Repetitions) + User uA = mock(User.class); + Distance dA1 = new Distance( ... ); + Distance dA2 = new Distance( ... ); + when(uA.getListActivities()).thenReturn(Arrays.asList(dA1, dA2)); // :contentReference[oaicite:16]{index=16} + + User uB = mock(User.class); + Repetitions rB1 = new Repetitions( ... ); + Repetitions rB2 = new Repetitions( ... ); + when(uB.getListActivities()).thenReturn(Arrays.asList(rB1, rB2)); // :contentReference[oaicite:17]{index=17} + + when(mockUserManager.getAllUsers()) + .thenReturn(Arrays.asList(uA, uB)); // :contentReference[oaicite:18]{index=18} + + // Counts: + // DistanceWithAltimetry = 0 + // Distance = 2 + // RepetitionsWithWeights = 0 + // Repetitions = 2 + // → maxIndices = {1, 3} tied at 2. Since max(...) picks the first occurrence of the maximum, index 1 (“Distance”) is returned. + + // Act + String result = queryService.executeQuery(mockUserManager); + + // Assert: “Distance” should be returned because index 1 (Distance) appears before index 3 (Repetitions) in the tie + assertEquals("Distance", result, + "Tie between Distance and Repetitions → Distance (index 1) should win because it appears first"); // :contentReference[oaicite:19]{index=19} + } + */ } From 46ca91839f8bd33fca1aa95a582881d94a6fa301 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Lopes?= Date: Tue, 3 Jun 2025 03:25:40 +0100 Subject: [PATCH 03/10] fix query --- .../MakeItFit/queries/HowManyAltimetryDone.java | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/main/java/MakeItFit/queries/HowManyAltimetryDone.java b/src/main/java/MakeItFit/queries/HowManyAltimetryDone.java index d5c2bc3..d108927 100644 --- a/src/main/java/MakeItFit/queries/HowManyAltimetryDone.java +++ b/src/main/java/MakeItFit/queries/HowManyAltimetryDone.java @@ -38,11 +38,20 @@ public double executeQuery(UserManager userManager, User user = userManager.getUserByEmail(email); double altimetry = 0; for (Activity a : user.getListActivities()) { - + /* fails testExecuteQueryWithDatesActivitiesOutsideTimeWindow if (a instanceof DistanceWithAltimetry) { altimetry += ((DistanceWithAltimetry) a).getElevationGain() + ((DistanceWithAltimetry) a).getElevationLoss(); } + */ + + if (a instanceof DistanceWithAltimetry && + a.getRealizationDate().isAfter(date1) && + date2.isAfter(a.getRealizationDate())) { + + altimetry += ((DistanceWithAltimetry) a).getElevationGain() + + ((DistanceWithAltimetry) a).getElevationLoss(); + } } return altimetry; @@ -64,8 +73,12 @@ public double executeQuery(UserManager userManager, String email) { double altimetry = 0; for (Activity a : user.getListActivities()) { if (a instanceof DistanceWithAltimetry) { + /* fails testExecuteQueryReturnsTrueAltimetry altimetry += ((DistanceWithAltimetry) a).getElevationGain() - ((DistanceWithAltimetry) a).getElevationLoss(); + */ + altimetry += ((DistanceWithAltimetry) a).getElevationGain() + + ((DistanceWithAltimetry) a).getElevationLoss(); } } return altimetry; From f1fd9f14c334cf790a6c60a9b33ae154b29bd542 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Lopes?= Date: Tue, 3 Jun 2025 18:08:34 +0100 Subject: [PATCH 04/10] complete test suite --- .../MostDemandingTrainingPlanTest.java | 4 +- .../queries/MostDoneActivityTest.java | 109 +++++----- .../queries/WhoBurnsMoreCaloriesTest.java | 187 ++++++++++++++++++ .../queries/WhoDidTheMostActivitiesTest.java | 175 ++++++++++++++++ 4 files changed, 427 insertions(+), 48 deletions(-) diff --git a/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java b/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java index 7219f59..6f28016 100644 --- a/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java +++ b/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java @@ -151,7 +151,6 @@ void testExecuteQueryMultiplePlans() { this.TPManager.insertTrainingPlan(tp1); this.TPManager.insertTrainingPlan(tp2); - /* Calculate calories for the first plan */ double caloriesTp1 = 0; for (MyTuple tuple : tp1.getActivities()) { @@ -190,6 +189,7 @@ void testExecuteQueryTieReturnsFirst() { this.TPManager.insertTrainingPlan(tp1); this.TPManager.insertTrainingPlan(tp1Copy); - assertSame(tp1, query.executeQuery(this.TPManager, this.userManager)); + List activities = this.TPManager.getAllTrainingPlans(); + assertSame(activities.get(0), query.executeQuery(this.TPManager, this.userManager)); } } diff --git a/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java b/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java index 5f56947..83c3f8f 100644 --- a/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java +++ b/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java @@ -2,7 +2,6 @@ import static org.junit.jupiter.api.Assertions.assertEquals; -import java.rmi.server.UID; import java.util.Arrays; import java.util.List; import java.util.UUID; @@ -15,11 +14,13 @@ import MakeItFit.activities.implementation.Running; import MakeItFit.activities.implementation.Trail; import MakeItFit.activities.implementation.WeightSquat; +import MakeItFit.trainingPlan.TrainingPlan; import MakeItFit.users.Gender; import MakeItFit.users.User; import MakeItFit.users.UserManager; import MakeItFit.users.types.Professional; import MakeItFit.utils.MakeItFitDate; +import MakeItFit.utils.MyTuple; public class MostDoneActivityTest { @@ -31,7 +32,7 @@ public class MostDoneActivityTest { private Trail trail; private WeightSquat weightSquat; - private User createUser(List activities) { + private User createUser(String email, List activities) { User user = new Professional( "JohnDoe", 21, @@ -42,7 +43,7 @@ private User createUser(List activities) { 6, "Lloyd", "987 123 432", - "jd@suspect.pt", + email, 7 ); @@ -101,34 +102,84 @@ void testExecuteQueryNoUsers() { assertEquals("DistanceWithAltimetry", this.query.executeQuery(this.userManager)); } + private TrainingPlan createTrainingPlan(UUID code, List> activities) { + TrainingPlan tl = new TrainingPlan( + code, + MakeItFitDate.of(2000, 1, 1) + ); + + for (MyTuple activity : activities) { + tl.addActivity(activity.getItem1(), activity.getItem2()); + } + + return tl; + } + @Test void testExecuteQuerySingleUserReturnsRepetitions() { - User user = createUser(Arrays.asList( - this.pushUp, + User user = createUser("jd@uminho.pt", Arrays.asList( this.pushUp, this.pushUp, + this.running, + this.trail, + this.weightSquat + )); + this.userManager.insertUser(user); + + assertEquals("Repetitions", this.query.executeQuery(this.userManager)); + } + + @Test + void testExecuteQuerySingleUserReturnsDistance() { + User user = createUser("jd@uminho.pt", Arrays.asList( this.pushUp, this.running, this.running, this.trail, + this.weightSquat + )); + this.userManager.insertUser(user); + + assertEquals("Distance", this.query.executeQuery(this.userManager)); + } + + @Test + void testExecuteQuerySingleUserReturnsDistanceWithAltimetry() { + User user = createUser("jd@uminho.pt", Arrays.asList( + this.pushUp, + this.running, + this.trail, this.trail, + this.weightSquat + )); + this.userManager.insertUser(user); + + assertEquals("DistanceWithAltimetry", this.query.executeQuery(this.userManager)); + } + + @Test + void testExecuteQuerySingleUserReturnsRepetitionsWithWeights() { + User user = createUser("jd@uminho.pt", Arrays.asList( + this.pushUp, + this.running, this.trail, this.weightSquat, - this.weightSquat, - this.weightSquat, this.weightSquat )); this.userManager.insertUser(user); - assertEquals("Repetitions", this.query.executeQuery(this.userManager)); + assertEquals("RepetitionsWithWeights", this.query.executeQuery(this.userManager)); } @Test void testExecuteQueryMultipleUsersReturnsDistance() { - User user1 = createUser(Arrays.asList(this.pushUp, this.pushUp)); - User user2 = createUser(Arrays.asList(this.trail)); - User user3 = createUser(Arrays.asList(this.running, this.running, this.running)); - User user4 = createUser(Arrays.asList(this.weightSquat, this.weightSquat)); + User user1 = createUser("jd@suspect.pt", Arrays.asList(this.pushUp, this.pushUp)); + User user2 = createUser("jd@uminho.pt", Arrays.asList(this.trail)); + User user3 = createUser("jd@eb23.pt", Arrays.asList(this.weightSquat, this.weightSquat)); + User user4 = createUser( + "jd@vice.pt", + Arrays.asList(this.running, this.running, this.running) + ); this.userManager.insertUser(user1); this.userManager.insertUser(user2); @@ -137,38 +188,4 @@ void testExecuteQueryMultipleUsersReturnsDistance() { assertEquals("Distance", this.query.executeQuery(this.userManager)); } - - /* - @Test - @DisplayName("Tie between 'Repetitions' and 'Distance' → returns 'DistanceWithAltimetry'? No: check exact index mapping") - void testExecuteQuery_tieBetweenTwoCategories() { - // Arrange: Build two users leading to a tie between index 1 (Distance) and index 3 (Repetitions) - User uA = mock(User.class); - Distance dA1 = new Distance( ... ); - Distance dA2 = new Distance( ... ); - when(uA.getListActivities()).thenReturn(Arrays.asList(dA1, dA2)); // :contentReference[oaicite:16]{index=16} - - User uB = mock(User.class); - Repetitions rB1 = new Repetitions( ... ); - Repetitions rB2 = new Repetitions( ... ); - when(uB.getListActivities()).thenReturn(Arrays.asList(rB1, rB2)); // :contentReference[oaicite:17]{index=17} - - when(mockUserManager.getAllUsers()) - .thenReturn(Arrays.asList(uA, uB)); // :contentReference[oaicite:18]{index=18} - - // Counts: - // DistanceWithAltimetry = 0 - // Distance = 2 - // RepetitionsWithWeights = 0 - // Repetitions = 2 - // → maxIndices = {1, 3} tied at 2. Since max(...) picks the first occurrence of the maximum, index 1 (“Distance”) is returned. - - // Act - String result = queryService.executeQuery(mockUserManager); - - // Assert: “Distance” should be returned because index 1 (Distance) appears before index 3 (Repetitions) in the tie - assertEquals("Distance", result, - "Tie between Distance and Repetitions → Distance (index 1) should win because it appears first"); // :contentReference[oaicite:19]{index=19} - } - */ } diff --git a/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java b/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java index a9edfc8..4e1a030 100644 --- a/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java +++ b/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java @@ -1,5 +1,192 @@ package MakeItFit.queries; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.Arrays; +import java.util.UUID; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Professional; +import MakeItFit.utils.MakeItFitDate; + public class WhoBurnsMoreCaloriesTest { + private WhoBurnsMoreCalories query; + private UserManager userManager; + + private User createUser(String email, float weight, int height, int bpm) { + return new Professional( + "JohnDoe", + 21, + Gender.Male, + weight, + height, + bpm, + 6, + "Lloyd", + "987 123 432", + email, + 7 + ); + } + + private PushUp createPushUp(UUID code, MakeItFitDate date) { + return new PushUp( + code, + date, + 60, + "PushUp", + "DO IT", + 10, + 100 + ); + } + + @BeforeEach + void testSetup() { + query = new WhoBurnsMoreCalories(); + userManager = new UserManager(); + } + + @Test + void testExecuteQueryWithDatesThrows() { + assertThrows( + IllegalArgumentException.class, + () -> this.query.executeQuery( + userManager, + MakeItFitDate.of(2000, 2, 9), + MakeItFitDate.of(1999, 12, 30) + ) + ); + } + + @Test + void testExecuteQueryWithDatesReturnsUserWithValidActivities() { + User user1 = createUser("jd@uminho.pt", 58, 167, 80); + user1.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + + User user2 = createUser("jd@gemail.pt", 58, 167, 80); + user2.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(2004, 2, 15)), + createPushUp(user1.getCode(), MakeItFitDate.of(2003, 2, 15)), + createPushUp(user1.getCode(), MakeItFitDate.of(2002, 2, 15)) + )); + + userManager.insertUser(user1); + userManager.insertUser(user2); + + assertSame(user1, + query.executeQuery( + userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(1999, 11, 1) + ) + ); + } + + @Test + void testExecuteQueryWithDatesTieReturnsFirstUser() { + User user1 = createUser("jd@uminho.pt", 58, 167, 80); + user1.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + User user1Copy = createUser("jd@gemail.pt", 58, 167, 80); + user1Copy.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + + this.userManager.insertUser(user1); + this.userManager.insertUser(user1Copy); + + assertSame( + this.userManager.getAllUsers().get(0), + query.executeQuery( + userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(1999, 11, 1) + ) + ); + } + + @Test + void testExecuteQueryReturnsCorrectUser() { + User user1 = createUser("jd@uminho.pt", 58, 167, 80); + user1.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + + User user2 = createUser("jd@gemail.pt", 58, 167, 80); + user2.addActivities(Arrays.asList( + createPushUp(user2.getCode(), MakeItFitDate.of(2004, 2, 15)), + createPushUp(user2.getCode(), MakeItFitDate.of(2003, 2, 15)), + createPushUp(user2.getCode(), MakeItFitDate.of(2002, 2, 15)) + )); + + userManager.insertUser(user1); + userManager.insertUser(user2); + + /* Calculate calories for user1 */ + int caloriesUser1 = 0; + for (Activity activity : user1.getListActivities()) { + caloriesUser1 += activity.caloricWaste(user1.getIndex()); + } + + /* Calculate calories for user2 */ + int caloriesUser2 = 0; + for (Activity activity : user2.getListActivities()) { + caloriesUser2 += activity.caloricWaste(user1.getIndex()); + } + + assertSame(caloriesUser1 < caloriesUser2 ? user2 : user1, + query.executeQuery( + userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(2004, 2, 16) + ) + ); + } + + @Test + void testExecuteQueryTieReturnsFirstUser() { + User user1 = createUser("jd@uminho.pt", 58, 167, 80); + user1.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + User user1Copy = createUser("jd@gemail.pt", 58, 167, 80); + user1Copy.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + + this.userManager.insertUser(user1); + this.userManager.insertUser(user1Copy); + + assertSame(this.userManager.getAllUsers().get(0), query.executeQuery(userManager)); + } + + @Test + void testExecuteQueryWithDatesNoUsersReturnsNull() { + assertNull( + query.executeQuery( + this.userManager, + MakeItFitDate.of(2000, 1, 1), + MakeItFitDate.of(2000, 1, 2) + ) + ); + } + + @Test + void testExecuteQueryNoUsersReturnsNull() { + assertNull(query.executeQuery(this.userManager)); + } } diff --git a/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java b/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java index 9288a0f..b67939f 100644 --- a/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java +++ b/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java @@ -1,5 +1,180 @@ package MakeItFit.queries; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.util.Arrays; +import java.util.UUID; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Professional; +import MakeItFit.utils.MakeItFitDate; + public class WhoDidTheMostActivitiesTest { + private WhoDidTheMostActivities query; + private UserManager userManager; + + private User createUser(String email) { + return new Professional( + "JohnDoe", + 21, + Gender.Male, + 60, + 140, + 54, + 6, + "Lloyd", + "987 123 432", + email, + 7 + ); + } + + private PushUp createPushUp(UUID code, MakeItFitDate date) { + return new PushUp( + code, + date, + 60, + "PushUp", + "DO IT", + 10, + 100 + ); + } + + @BeforeEach + void testSetup() { + this.query = new WhoDidTheMostActivities(); + this.userManager = new UserManager(); + } + + @Test + void testExecuteQueryWithDatesThrows() { + assertThrows( + IllegalArgumentException.class, + () -> this.query.executeQuery( + userManager, + MakeItFitDate.of(2000, 2, 9), + MakeItFitDate.of(1999, 12, 30) + ) + ); + } + + @Test + void testExecuteQueryWithDatesReturnsUserWithValidActivities() { + User user1 = createUser("jd@uminho.pt"); + user1.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + + User user2 = createUser("jd@gemail.pt"); + user2.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(2004, 2, 15)), + createPushUp(user1.getCode(), MakeItFitDate.of(2003, 2, 15)), + createPushUp(user1.getCode(), MakeItFitDate.of(2002, 2, 15)) + )); + + userManager.insertUser(user1); + userManager.insertUser(user2); + + assertSame(user1, + query.executeQuery( + userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(1999, 11, 1) + ) + ); + } + + @Test + void testExecuteQueryWithDatesTieReturnsFirstUser() { + User user1 = createUser("jd@uminho.pt"); + user1.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + User user1Copy = createUser("jd@gemail.pt"); + user1Copy.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + + this.userManager.insertUser(user1); + this.userManager.insertUser(user1Copy); + + assertSame( + this.userManager.getAllUsers().get(0), + query.executeQuery( + userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(1999, 11, 1) + ) + ); + } + + @Test + void testExecuteQueryReturnsCorrectUser() { + User user1 = createUser("jd@uminho.pt"); + user1.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + + User user2 = createUser("jd@gemail.pt"); + user2.addActivities(Arrays.asList( + createPushUp(user2.getCode(), MakeItFitDate.of(2004, 2, 15)), + createPushUp(user2.getCode(), MakeItFitDate.of(2003, 2, 15)), + createPushUp(user2.getCode(), MakeItFitDate.of(2002, 2, 15)) + )); + + userManager.insertUser(user1); + userManager.insertUser(user2); + + assertSame( + user1.getListActivities().size() < user2.getListActivities().size() ? user2 : user1, + query.executeQuery( + userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(2004, 2, 16) + ) + ); + } + + @Test + void testExecuteQueryTieReturnsFirstUser() { + User user1 = createUser("jd@uminho.pt"); + user1.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + User user1Copy = createUser("jd@gemail.pt"); + user1Copy.addActivities(Arrays.asList( + createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) + )); + + this.userManager.insertUser(user1); + this.userManager.insertUser(user1Copy); + + assertSame(this.userManager.getAllUsers().get(0), query.executeQuery(userManager)); + } + + @Test + void testExecuteQueryWithDatesNoUsersReturnsNull() { + assertNull( + query.executeQuery( + this.userManager, + MakeItFitDate.of(2000, 1, 1), + MakeItFitDate.of(2000, 1, 2) + ) + ); + } + + @Test + void testExecuteQueryNoUsersReturnsNull() { + assertNull(query.executeQuery(this.userManager)); + } } From 3cf8eee838cce8526b66c19e62190169e7f37234 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Lopes?= Date: Tue, 3 Jun 2025 18:10:14 +0100 Subject: [PATCH 05/10] remove unnecessary import --- src/main/java/MakeItFit/queries/WhoDidTheMostActivities.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/MakeItFit/queries/WhoDidTheMostActivities.java b/src/main/java/MakeItFit/queries/WhoDidTheMostActivities.java index 18fd188..316b8f5 100644 --- a/src/main/java/MakeItFit/queries/WhoDidTheMostActivities.java +++ b/src/main/java/MakeItFit/queries/WhoDidTheMostActivities.java @@ -4,7 +4,6 @@ import java.util.List; import MakeItFit.activities.Activity; -import MakeItFit.activities.types.DistanceWithAltimetry; import MakeItFit.users.User; import MakeItFit.users.UserManager; import MakeItFit.utils.MakeItFitDate; From ead7793de20a7f95ff098bb4dcd417f711f15a64 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Lopes?= Date: Tue, 3 Jun 2025 18:13:12 +0100 Subject: [PATCH 06/10] fix query --- src/main/java/MakeItFit/queries/MostDoneActivity.java | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/main/java/MakeItFit/queries/MostDoneActivity.java b/src/main/java/MakeItFit/queries/MostDoneActivity.java index 7d9cf51..30561bb 100644 --- a/src/main/java/MakeItFit/queries/MostDoneActivity.java +++ b/src/main/java/MakeItFit/queries/MostDoneActivity.java @@ -46,9 +46,15 @@ public String executeQuery(UserManager userManager) { return switch (maxIndex) { case 0 -> "DistanceWithAltimetry"; case 1 -> "Distance"; + /* fails testExecuteQuerySingleUserReturnsRepetitions/RepetitionsWithWeights case 2 -> "Repetitions"; - case 3 -> "RepetitionsWithWeights"; + default -> "RepetitionsWithWeights"; + */ + case 2 -> "RepetitionsWithWeights"; + default -> "Repetitions"; + /* Would never be reached (dead code) default -> "No activities"; + */ }; } From 12951d2fcc6197249dcc92b3650bdd9d21244c8b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Lopes?= Date: Tue, 3 Jun 2025 22:11:24 +0100 Subject: [PATCH 07/10] finish queries test suites --- .../queries/MostDoneActivityTest.java | 15 - .../MakeItFit/queries/QueriesManagerTest.java | 273 ++++++++++++++++++ 2 files changed, 273 insertions(+), 15 deletions(-) diff --git a/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java b/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java index 83c3f8f..77b80ad 100644 --- a/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java +++ b/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java @@ -14,13 +14,11 @@ import MakeItFit.activities.implementation.Running; import MakeItFit.activities.implementation.Trail; import MakeItFit.activities.implementation.WeightSquat; -import MakeItFit.trainingPlan.TrainingPlan; import MakeItFit.users.Gender; import MakeItFit.users.User; import MakeItFit.users.UserManager; import MakeItFit.users.types.Professional; import MakeItFit.utils.MakeItFitDate; -import MakeItFit.utils.MyTuple; public class MostDoneActivityTest { @@ -102,19 +100,6 @@ void testExecuteQueryNoUsers() { assertEquals("DistanceWithAltimetry", this.query.executeQuery(this.userManager)); } - private TrainingPlan createTrainingPlan(UUID code, List> activities) { - TrainingPlan tl = new TrainingPlan( - code, - MakeItFitDate.of(2000, 1, 1) - ); - - for (MyTuple activity : activities) { - tl.addActivity(activity.getItem1(), activity.getItem2()); - } - - return tl; - } - @Test void testExecuteQuerySingleUserReturnsRepetitions() { User user = createUser("jd@uminho.pt", Arrays.asList( diff --git a/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java b/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java index 449d903..f5a1103 100644 --- a/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java +++ b/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java @@ -1,5 +1,278 @@ package MakeItFit.queries; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; + +import java.util.ArrayList; +import java.util.Arrays; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import MakeItFit.MakeItFit; +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.Trail; +import MakeItFit.trainingPlan.TrainingPlan; +import MakeItFit.trainingPlan.TrainingPlanManager; +import MakeItFit.users.Gender; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +import MakeItFit.users.types.Professional; +import MakeItFit.utils.MakeItFitDate; +import MakeItFit.utils.MyTuple; + public class QueriesManagerTest { + QueriesManager queriesManager; + UserManager userManager; + TrainingPlanManager TPManager; + Trail trail; + User user; + + @BeforeEach + void testSetup() { + this.queriesManager = new QueriesManager(); + this.userManager = new UserManager(); + this.TPManager = new TrainingPlanManager(); + this.user = new Professional( + "JohnDoe", + 21, + Gender.Male, + 59, + 150, + 60, + 6, + "Lloyd", + "987 123 432", + "jd@suspect.pt", + 7 + ); + + this.trail = new Trail( + this.user.getCode(), + MakeItFitDate.of(2000, 1, 1), + 90, + "Hiking", + "Subir ao Bom Jesus", + 2000.0, + 12432.3, + 12341.2, + 1 + ); + } + + @Test + void testExecuteQueryHowManyAltimetryDoneWithDates() { + HowManyAltimetryDone query = new HowManyAltimetryDone(); + + user.addActivities(Arrays.asList(this.trail, this.trail)); + userManager.insertUser(user); + + assertEquals( + query.executeQuery( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 12, 30), + MakeItFitDate.of(2000, 1 , 2) + ), + queriesManager.executeQueryHowManyAltimetryDone( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 12, 30), + MakeItFitDate.of(2000, 1 , 2) + ) + ); + } + + @Test + void testExecuteQueryHowManyAltimetryDone() { + HowManyAltimetryDone query = new HowManyAltimetryDone(); + + this.user.addActivities(Arrays.asList(this.trail, this.trail)); + this.userManager.insertUser(this.user); + + assertEquals( + query.executeQuery(this.userManager, "jd@suspect.pt"), + this.queriesManager.executeQueryHowManyAltimetryDone( + this.userManager, + "jd@suspect.pt" + ) + ); + } + + @Test + void testExecuteQueryHowManyKMsDoneWithDates() { + HowManyKMsDone query = new HowManyKMsDone(); + + this.user.addActivities(Arrays.asList(this.trail, this.trail)); + this.userManager.insertUser(this.user); + + assertEquals( + query.executeQuery( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2) + ), + this.queriesManager.executeQueryHowManyKMsDone( + userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2) + ), + 0.0001 + ); + } + + @Test + void testExecuteQueryHowManyKMsDone() { + HowManyKMsDone query = new HowManyKMsDone(); + + this.user.addActivities(Arrays.asList(this.trail, this.trail)); + this.userManager.insertUser(this.user); + + assertEquals( + query.executeQuery( + userManager, + "jd@suspect.pt" + ), + this.queriesManager.executeQueryHowManyKMsDone( + userManager, + "jd@suspect.pt" + ), + 0.0001 + ); + } + + @Test + void testExecuteQueryMostDemandingTrainingPlan() { + MostDemandingTrainingPlan query = new MostDemandingTrainingPlan(); + + TrainingPlan tp = new TrainingPlan( + this.user.getCode(), + MakeItFitDate.of(2000, 1, 1) + ); + + ArrayList> activities = + new ArrayList>( + Arrays.asList( + new MyTuple(1, this.trail), + new MyTuple(2, this.trail) + ) + ); + + for (MyTuple activity : activities) { + tp.addActivity(activity.getItem1(), activity.getItem2()); + } + + this.userManager.insertUser(this.user); + this.TPManager.insertTrainingPlan(tp); + + assertSame( + query.executeQuery(this.TPManager, this.userManager), + this.queriesManager.executeQueryMostDemandingTrainingPlan( + this.TPManager, this.userManager + ) + ); + } + + @Test + void testExecuteQueryMostDoneActivity() { + MostDoneActivity query = new MostDoneActivity(); + + this.user.addActivities(Arrays.asList(this.trail, this.trail)); + this.userManager.insertUser(this.user); + + assertEquals( + query.executeQuery(this.userManager), + this.queriesManager.executeQueryMostDoneActivity(this.userManager) + ); + } + + @Test + void testExecuteQueryWhoBurnsMoreCaloresWithDates() { + WhoBurnsMoreCalories query = new WhoBurnsMoreCalories(); + + this.user.addActivities(Arrays.asList(this.trail, this.trail)); + User user1 = this.user.clone(); + user1.setEmail("something@diferent.com"); + + this.userManager.insertUser(user); + this.userManager.insertUser(user1); + + assertSame( + query.executeQuery( + this.userManager, + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2) + ), + this.queriesManager.executeQuerywhoBurnsMoreCalories( + this.userManager, + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2) + ) + ); + } + + @Test + void testExecuteQueryWhoBurnsMoreCalores() { + WhoBurnsMoreCalories query = new WhoBurnsMoreCalories(); + + this.user.addActivities(Arrays.asList(this.trail, this.trail)); + User user1 = this.user.clone(); + user1.setEmail("something@diferent.com"); + user1.addActivity(this.trail); + + this.userManager.insertUser(user); + this.userManager.insertUser(user1); + + assertSame( + query.executeQuery(this.userManager), + this.queriesManager.executeQuerywhoBurnsMoreCalories(this.userManager) + ); + } + + @Test + void testWhoDidTheMostActivitiesWithDates() { + WhoDidTheMostActivities query = new WhoDidTheMostActivities(); + + this.user.addActivities(Arrays.asList(this.trail, this.trail)); + User user1 = this.user.clone(); + user1.setEmail("something@diferent.com"); + user1.addActivity(this.trail); + + this.userManager.insertUser(user); + this.userManager.insertUser(user1); + + assertSame( + query.executeQuery( + this.userManager, + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2) + ), + this.queriesManager.executeQueryWhoDidTheMostActivities( + this.userManager, + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2) + ) + ); + } + + @Test + void testWhoDidTheMostActivities() { + WhoDidTheMostActivities query = new WhoDidTheMostActivities(); + + this.user.addActivities(Arrays.asList(this.trail, this.trail)); + User user1 = this.user.clone(); + user1.setEmail("something@diferent.com"); + user1.addActivity(this.trail); + + this.userManager.insertUser(user); + this.userManager.insertUser(user1); + + assertSame( + query.executeQuery(this.userManager), + this.queriesManager.executeQueryWhoDidTheMostActivities(this.userManager) + ); + } } From a77786280eb66bfe78dbd7bd615b3032bd0fc519 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Lopes?= Date: Tue, 3 Jun 2025 22:11:54 +0100 Subject: [PATCH 08/10] fix QueriesManager constructor arguments --- src/main/java/MakeItFit/MakeItFit.java | 3 +++ src/main/java/MakeItFit/queries/QueriesManager.java | 3 +++ 2 files changed, 6 insertions(+) diff --git a/src/main/java/MakeItFit/MakeItFit.java b/src/main/java/MakeItFit/MakeItFit.java index d927c27..cc6eced 100644 --- a/src/main/java/MakeItFit/MakeItFit.java +++ b/src/main/java/MakeItFit/MakeItFit.java @@ -26,7 +26,10 @@ public class MakeItFit implements Serializable { public MakeItFit() { this.userManager = new UserManager(); this.trainingPlanManager = new TrainingPlanManager(); + /* Parameters aren't being used this.queriesManager = new QueriesManager(userManager, trainingPlanManager); + */ + this.queriesManager = new QueriesManager(); } /** diff --git a/src/main/java/MakeItFit/queries/QueriesManager.java b/src/main/java/MakeItFit/queries/QueriesManager.java index 90df038..cf34556 100644 --- a/src/main/java/MakeItFit/queries/QueriesManager.java +++ b/src/main/java/MakeItFit/queries/QueriesManager.java @@ -25,7 +25,10 @@ public class QueriesManager implements Serializable { /** * Constructs a new queries manager. */ + /* Parameters aren't being used public QueriesManager(UserManager userManager, TrainingPlanManager trainingPlanManager) { + */ + public QueriesManager() { this.howManyAltimetryDone = new HowManyAltimetryDone(); this.howManyKMsDone = new HowManyKMsDone(); this.mostDoneActivity = new MostDoneActivity(); From 5d5f86ae6cc2faaf00ec85938736f6d603ca7541 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Lopes?= Date: Wed, 4 Jun 2025 00:45:49 +0100 Subject: [PATCH 09/10] run formater --- .../queries/HowManyAltimetryDone.java | 3 +- .../MakeItFit/queries/MostDoneActivity.java | 9 +- .../queries/HowManyAltimetryDoneTest.java | 207 ++++++----------- .../MakeItFit/queries/HowManyKMsDoneTest.java | 186 +++++---------- .../MostDemandingTrainingPlanTest.java | 179 ++++++--------- .../queries/MostDoneActivityTest.java | 162 ++++++------- .../MakeItFit/queries/QueriesManagerTest.java | 212 +++++++----------- .../queries/WhoBurnsMoreCaloriesTest.java | 152 +++++-------- .../queries/WhoDidTheMostActivitiesTest.java | 154 +++++-------- .../MakeItFit/utils/MakeItFitDateTest.java | 4 +- .../java/MakeItFit/utils/MyTupleTest.java | 4 +- 11 files changed, 470 insertions(+), 802 deletions(-) diff --git a/src/main/java/MakeItFit/queries/HowManyAltimetryDone.java b/src/main/java/MakeItFit/queries/HowManyAltimetryDone.java index d108927..9a215b4 100644 --- a/src/main/java/MakeItFit/queries/HowManyAltimetryDone.java +++ b/src/main/java/MakeItFit/queries/HowManyAltimetryDone.java @@ -45,8 +45,7 @@ public double executeQuery(UserManager userManager, } */ - if (a instanceof DistanceWithAltimetry && - a.getRealizationDate().isAfter(date1) && + if (a instanceof DistanceWithAltimetry && a.getRealizationDate().isAfter(date1) && date2.isAfter(a.getRealizationDate())) { altimetry += ((DistanceWithAltimetry) a).getElevationGain() + diff --git a/src/main/java/MakeItFit/queries/MostDoneActivity.java b/src/main/java/MakeItFit/queries/MostDoneActivity.java index 30561bb..cf2488d 100644 --- a/src/main/java/MakeItFit/queries/MostDoneActivity.java +++ b/src/main/java/MakeItFit/queries/MostDoneActivity.java @@ -51,10 +51,11 @@ public String executeQuery(UserManager userManager) { default -> "RepetitionsWithWeights"; */ case 2 -> "RepetitionsWithWeights"; - default -> "Repetitions"; - /* Would never be reached (dead code) - default -> "No activities"; - */ + default -> + "Repetitions"; + /* Would never be reached (dead code) + default -> "No activities"; + */ }; } diff --git a/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java b/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java index 6eb0fb2..03e7994 100644 --- a/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java +++ b/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java @@ -1,51 +1,39 @@ package MakeItFit.queries; +import java.util.Arrays; + import MakeItFit.activities.implementation.PushUp; import MakeItFit.activities.implementation.Trail; - +import MakeItFit.users.Gender; +import MakeItFit.users.User; import MakeItFit.users.UserManager; import MakeItFit.users.types.Professional; import MakeItFit.utils.MakeItFitDate; -import MakeItFit.users.User; -import MakeItFit.users.Gender; +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.assertThrows; -import java.util.Arrays; - -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - public class HowManyAltimetryDoneTest { private HowManyAltimetryDone query; - private UserManager userManager; - private User user; + private UserManager userManager; + private User user; private Trail createTrail(MakeItFitDate date, double elevationGain, double getElevationLoss) { - return new Trail( - user.getCode(), - date, - 90, - "Hiking", - "Subir ao Bom Jesus", - 2000.0, - elevationGain, - getElevationLoss, - 1 - ); + return new Trail(user.getCode(), + date, + 90, + "Hiking", + "Subir ao Bom Jesus", + 2000.0, + elevationGain, + getElevationLoss, + 1); } private PushUp createPushUp(MakeItFitDate date) { - return new PushUp( - user.getCode(), - date, - 90, - "PushUps", - "100x", - 10, - 100 - ); + return new PushUp(user.getCode(), date, 90, "PushUps", "100x", 10, 100); } @BeforeEach @@ -53,150 +41,87 @@ void testSetup() { this.query = new HowManyAltimetryDone(); this.userManager = new UserManager(); - this.user = new Professional( - "JohnDoe", - 21, - Gender.Male, - 59, - 150, - 60, - 6, - "Lloyd", - "987 123 432", - "jd@suspect.pt", - 7 - ); + this.user = new Professional("JohnDoe", + 21, + Gender.Male, + 59, + 150, + 60, + 6, + "Lloyd", + "987 123 432", + "jd@suspect.pt", + 7); } @Test void testExecuteQueryWithDatesReturnsTrueAltimetry() { - user.addActivities(Arrays.asList( - createTrail( - MakeItFitDate.of(1999, 2, 9), - 229.12, - 142.0 - ), - createTrail( - MakeItFitDate.of(1999, 2, 14), - 654.129, - 532.0 - ) - )); + user.addActivities( + Arrays.asList(createTrail(MakeItFitDate.of(1999, 2, 9), 229.12, 142.0), + createTrail(MakeItFitDate.of(1999, 2, 14), 654.129, 532.0))); userManager.insertUser(user); - assertEquals( - 229.12 + 142.0 + 654.129 + 532.0, - query.executeQuery( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 2, 8), - MakeItFitDate.of(1999, 3, 1) - ), - 0.0001 - ); + assertEquals(229.12 + 142.0 + 654.129 + 532.0, + query.executeQuery(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(1999, 3, 1)), + 0.0001); } @Test void testExecuteQueryWithDatesThrows() { - assertThrows( - IllegalArgumentException.class, - () -> query.executeQuery( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 2, 9), - MakeItFitDate.of(1999, 2, 9) - ) - ); + assertThrows(IllegalArgumentException.class, + () + -> query.executeQuery(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 9), + MakeItFitDate.of(1999, 2, 9))); } @Test void testExecuteQueryWithDatesNoValidActivities() { - user.addActivities(Arrays.asList( - createPushUp( - MakeItFitDate.of(1999, 2, 9) - ) - )); + user.addActivities(Arrays.asList(createPushUp(MakeItFitDate.of(1999, 2, 9)))); userManager.insertUser(user); - assertEquals( - 0, - query.executeQuery( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 2, 9), - MakeItFitDate.of(1999, 3, 1) - ) - ); + assertEquals(0, + query.executeQuery(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(1999, 3, 1))); } @Test void testExecuteQueryWithDatesActivitiesOutsideTimeWindow() { - user.addActivities(Arrays.asList( - createTrail( - MakeItFitDate.of(1999, 2, 9), - 229.12, - 142.0 - ), - createTrail( - MakeItFitDate.of(1999, 2, 14), - 654.129, - 532.0 - ) - )); + user.addActivities( + Arrays.asList(createTrail(MakeItFitDate.of(1999, 2, 9), 229.12, 142.0), + createTrail(MakeItFitDate.of(1999, 2, 14), 654.129, 532.0))); userManager.insertUser(user); - assertEquals( - 0, - query.executeQuery( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 4, 9), - MakeItFitDate.of(1999, 4, 10) - ) - ); + assertEquals(0, + query.executeQuery(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 4, 9), + MakeItFitDate.of(1999, 4, 10))); } @Test void testExecuteQueryReturnsTrueAltimetry() { - user.addActivities(Arrays.asList( - createTrail( - MakeItFitDate.of(1999, 2, 9), - 229.12, - 142.0 - ), - createTrail( - MakeItFitDate.of(1999, 2, 14), - 654.129, - 532.0 - ) - )); + user.addActivities( + Arrays.asList(createTrail(MakeItFitDate.of(1999, 2, 9), 229.12, 142.0), + createTrail(MakeItFitDate.of(1999, 2, 14), 654.129, 532.0))); userManager.insertUser(user); - assertEquals( - 229.12 + 142.0 + 654.129 + 532.0, - query.executeQuery( - userManager, - "jd@suspect.pt" - ), - 0.0001 - ); + assertEquals(229.12 + 142.0 + 654.129 + 532.0, + query.executeQuery(userManager, "jd@suspect.pt"), + 0.0001); } @Test void testExecuteQueryActivitiesOutsideTimeWindow() { - user.addActivities(Arrays.asList( - createPushUp( - MakeItFitDate.of(1999, 2, 9) - ) - )); + user.addActivities(Arrays.asList(createPushUp(MakeItFitDate.of(1999, 2, 9)))); userManager.insertUser(user); - assertEquals( - 0, - query.executeQuery( - userManager, - "jd@suspect.pt" - ) - ); + assertEquals(0, query.executeQuery(userManager, "jd@suspect.pt")); } } diff --git a/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java b/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java index 3b7a27a..2cc9748 100644 --- a/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java +++ b/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java @@ -1,13 +1,7 @@ package MakeItFit.queries; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; - import java.util.Arrays; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - import MakeItFit.activities.implementation.PushUp; import MakeItFit.activities.implementation.Running; import MakeItFit.users.Gender; @@ -15,34 +9,29 @@ import MakeItFit.users.UserManager; import MakeItFit.users.types.Professional; 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.assertThrows; public class HowManyKMsDoneTest { private HowManyKMsDone query; - private UserManager userManager; - private User user; + private UserManager userManager; + private User user; private Running createRunning(MakeItFitDate date, double distance) { - return new Running( - user.getCode(), - date, - 84, - "StreetRace", - "Corrida de Viana", - distance, - 12 - ); + return new Running(user.getCode(), + date, + 84, + "StreetRace", + "Corrida de Viana", + distance, + 12); } private PushUp createPushUp(MakeItFitDate date) { - return new PushUp( - user.getCode(), - date, - 90, - "PushUps", - "100x", - 10, - 100 - ); + return new PushUp(user.getCode(), date, 90, "PushUps", "100x", 10, 100); } @BeforeEach @@ -50,140 +39,83 @@ void testSetup() { this.query = new HowManyKMsDone(); this.userManager = new UserManager(); - this.user = new Professional( - "JohnDoe", - 21, - Gender.Male, - 59, - 150, - 60, - 6, - "Lloyd", - "987 123 432", - "jd@suspect.pt", - 7 - ); + this.user = new Professional("JohnDoe", + 21, + Gender.Male, + 59, + 150, + 60, + 6, + "Lloyd", + "987 123 432", + "jd@suspect.pt", + 7); } @Test void testExecuteQueryWithDatesReturnsTrueDistance() { - user.addActivities(Arrays.asList( - createRunning( - MakeItFitDate.of(1999, 2, 9), - 20000.0 - ), - createRunning( - MakeItFitDate.of(1999, 3, 9), - 4567.231 - ) - )); + user.addActivities(Arrays.asList(createRunning(MakeItFitDate.of(1999, 2, 9), 20000.0), + createRunning(MakeItFitDate.of(1999, 3, 9), 4567.231))); userManager.insertUser(user); - assertEquals( - (20000.0 + 4567.231) / 1000, - query.executeQuery( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 2, 8), - MakeItFitDate.of(1999, 3, 10) - ), - 0.0001 - ); + assertEquals((20000.0 + 4567.231) / 1000, + query.executeQuery(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(1999, 3, 10)), + 0.0001); } @Test void testExecuteQueryWithDatesThrows() { - assertThrows( - IllegalArgumentException.class, - () -> query.executeQuery( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 2, 9), - MakeItFitDate.of(1999, 2, 9) - ) - ); + assertThrows(IllegalArgumentException.class, + () + -> query.executeQuery(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 9), + MakeItFitDate.of(1999, 2, 9))); } @Test void testExecuteQueryWithDatesNoValidActivities() { - user.addActivities(Arrays.asList( - createPushUp( - MakeItFitDate.of(1999, 2, 9) - ) - )); + user.addActivities(Arrays.asList(createPushUp(MakeItFitDate.of(1999, 2, 9)))); userManager.insertUser(user); - assertEquals( - 0, - query.executeQuery( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 2, 9), - MakeItFitDate.of(1999, 3, 1) - ) - ); + assertEquals(0, + query.executeQuery(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 9), + MakeItFitDate.of(1999, 3, 1))); } @Test void testExecuteQueryWithDatesActivitiesOutsideTimeWindow() { - user.addActivities(Arrays.asList( - createRunning( - MakeItFitDate.of(1999, 2, 9), - 123.143 - ) - )); + user.addActivities(Arrays.asList(createRunning(MakeItFitDate.of(1999, 2, 9), 123.143))); userManager.insertUser(user); - assertEquals( - 0, - query.executeQuery( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 2, 9), - MakeItFitDate.of(1999, 4, 10) - ) - ); + assertEquals(0, + query.executeQuery(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 9), + MakeItFitDate.of(1999, 4, 10))); } @Test void testExecuteQueryReturnsTrueDistance() { - user.addActivities(Arrays.asList( - createRunning( - MakeItFitDate.of(1999, 2, 9), - 2122.12 - ), - createRunning( - MakeItFitDate.of(1999, 2, 14), - 233.231 - ) - )); + user.addActivities(Arrays.asList(createRunning(MakeItFitDate.of(1999, 2, 9), 2122.12), + createRunning(MakeItFitDate.of(1999, 2, 14), 233.231))); userManager.insertUser(user); - assertEquals( - (2122.12 + 233.231) / 1000, - query.executeQuery( - userManager, - "jd@suspect.pt" - ), - 0.0001 - ); + assertEquals((2122.12 + 233.231) / 1000, + query.executeQuery(userManager, "jd@suspect.pt"), + 0.0001); } @Test void testExecuteQueryNoValidActivities() { - user.addActivities(Arrays.asList( - createPushUp( - MakeItFitDate.of(1999, 2, 9) - ) - )); + user.addActivities(Arrays.asList(createPushUp(MakeItFitDate.of(1999, 2, 9)))); userManager.insertUser(user); - assertEquals( - 0, - query.executeQuery( - userManager, - "jd@suspect.pt" - ) - ); + assertEquals(0, query.executeQuery(userManager, "jd@suspect.pt")); } } diff --git a/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java b/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java index 6f28016..f233d82 100644 --- a/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java +++ b/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java @@ -1,14 +1,13 @@ package MakeItFit.queries; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; - import java.util.Arrays; import java.util.List; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.activities.implementation.Running; +import MakeItFit.activities.implementation.Trail; +import MakeItFit.activities.implementation.WeightSquat; import MakeItFit.trainingPlan.TrainingPlan; import MakeItFit.trainingPlan.TrainingPlanManager; import MakeItFit.users.Gender; @@ -17,23 +16,20 @@ import MakeItFit.users.types.Professional; import MakeItFit.utils.MakeItFitDate; import MakeItFit.utils.MyTuple; -import MakeItFit.activities.Activity; -import MakeItFit.activities.implementation.PushUp; -import MakeItFit.activities.implementation.Running; -import MakeItFit.activities.implementation.Trail; -import MakeItFit.activities.implementation.WeightSquat; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; public class MostDemandingTrainingPlanTest { private MostDemandingTrainingPlan query; - private TrainingPlanManager TPManager; - private UserManager userManager; - private User user; + private TrainingPlanManager TPManager; + private UserManager userManager; + private User user; private TrainingPlan createTrainingPlan(List> activities) { - TrainingPlan tl = new TrainingPlan( - user.getCode(), - MakeItFitDate.of(2000, 1, 1) - ); + TrainingPlan tl = new TrainingPlan(user.getCode(), MakeItFitDate.of(2000, 1, 1)); for (MyTuple activity : activities) { tl.addActivity(activity.getItem1(), activity.getItem2()); @@ -43,54 +39,46 @@ private TrainingPlan createTrainingPlan(List> activit } private PushUp createPushUp(int repetitions, int series) { - return new PushUp( - user.getCode(), - MakeItFitDate.of(2000, 1, 1), - 60, - "PushUp", - "DO IT", - repetitions, - series - ); + return new PushUp(user.getCode(), + MakeItFitDate.of(2000, 1, 1), + 60, + "PushUp", + "DO IT", + repetitions, + series); } private Running createRunning(double distance, double speed) { - return new Running( - user.getCode(), - MakeItFitDate.of(2000, 1, 1), - 70, - "Running", - "For my life", - distance, - speed - ); + return new Running(user.getCode(), + MakeItFitDate.of(2000, 1, 1), + 70, + "Running", + "For my life", + distance, + speed); } private Trail createTrail(double distance, double elevationGain, double elevationLoss) { - return new Trail( - user.getCode(), - MakeItFitDate.of(2000, 1, 1), - 120, - "Trail", - "RunningUpThatHill", - distance, - elevationGain, - elevationLoss, - 2 - ); + return new Trail(user.getCode(), + MakeItFitDate.of(2000, 1, 1), + 120, + "Trail", + "RunningUpThatHill", + distance, + elevationGain, + elevationLoss, + 2); } private WeightSquat createWeightSquat(int repetitions, int series, double weight) { - return new WeightSquat( - user.getCode(), - MakeItFitDate.of(2000, 1, 1), - 45, - "WeightSquat", - "PumpItUp", - repetitions, - series, - weight - ); + return new WeightSquat(user.getCode(), + MakeItFitDate.of(2000, 1, 1), + 45, + "WeightSquat", + "PumpItUp", + repetitions, + series, + weight); } @BeforeEach @@ -99,19 +87,17 @@ void testSetup() { this.TPManager = new TrainingPlanManager(); this.userManager = new UserManager(); - this.user = new Professional( - "JohnDoe", - 21, - Gender.Male, - 59, - 150, - 60, - 6, - "Lloyd", - "987 123 432", - "jd@suspect.pt", - 7 - ); + this.user = new Professional("JohnDoe", + 21, + Gender.Male, + 59, + 150, + 60, + 6, + "Lloyd", + "987 123 432", + "jd@suspect.pt", + 7); userManager.insertUser(user); } @@ -122,13 +108,9 @@ void testExecuteQueryNoPlans() { @Test void testExecuteQuerySinglePlan() { - TrainingPlan tp = createTrainingPlan(Arrays.asList( - new MyTuple( - 1, - createTrail(7000, 212.23, 412.1234) - ), - new MyTuple(2, createPushUp(10, 100)) - )); + TrainingPlan tp = createTrainingPlan( + Arrays.asList(new MyTuple(1, createTrail(7000, 212.23, 412.1234)), + new MyTuple(2, createPushUp(10, 100)))); this.TPManager.insertTrainingPlan(tp); assertSame(tp, query.executeQuery(this.TPManager, this.userManager)); @@ -136,17 +118,12 @@ void testExecuteQuerySinglePlan() { @Test void testExecuteQueryMultiplePlans() { - TrainingPlan tp1 = createTrainingPlan(Arrays.asList( - new MyTuple( - 1, - createTrail(7000, 212.23, 412.1234) - ), - new MyTuple(2, createPushUp(10, 100)) - )); - TrainingPlan tp2 = createTrainingPlan(Arrays.asList( - new MyTuple(2, createRunning(7000, 12)), - new MyTuple(2, createWeightSquat(10, 100, 50)) - )); + TrainingPlan tp1 = createTrainingPlan( + Arrays.asList(new MyTuple(1, createTrail(7000, 212.23, 412.1234)), + new MyTuple(2, createPushUp(10, 100)))); + TrainingPlan tp2 = createTrainingPlan( + Arrays.asList(new MyTuple(2, createRunning(7000, 12)), + new MyTuple(2, createWeightSquat(10, 100, 50)))); this.TPManager.insertTrainingPlan(tp1); this.TPManager.insertTrainingPlan(tp2); @@ -163,28 +140,18 @@ void testExecuteQueryMultiplePlans() { caloriesTp2 += tuple.getItem1() * tuple.getItem2().caloricWaste(user.getIndex()); } - assertSame( - caloriesTp1 >= caloriesTp2 ? tp1 : tp2, - query.executeQuery(this.TPManager, this.userManager) - ); + assertSame(caloriesTp1 >= caloriesTp2 ? tp1 : tp2, + query.executeQuery(this.TPManager, this.userManager)); } @Test void testExecuteQueryTieReturnsFirst() { - TrainingPlan tp1 = createTrainingPlan(Arrays.asList( - new MyTuple( - 1, - createTrail(7000, 212.23, 412.1234) - ), - new MyTuple(2, createPushUp(10, 100)) - )); - TrainingPlan tp1Copy = createTrainingPlan(Arrays.asList( - new MyTuple( - 1, - createTrail(7000, 212.23, 412.1234) - ), - new MyTuple(2, createPushUp(10, 100)) - )); + TrainingPlan tp1 = createTrainingPlan( + Arrays.asList(new MyTuple(1, createTrail(7000, 212.23, 412.1234)), + new MyTuple(2, createPushUp(10, 100)))); + TrainingPlan tp1Copy = createTrainingPlan( + Arrays.asList(new MyTuple(1, createTrail(7000, 212.23, 412.1234)), + new MyTuple(2, createPushUp(10, 100)))); this.TPManager.insertTrainingPlan(tp1); this.TPManager.insertTrainingPlan(tp1Copy); diff --git a/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java b/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java index 77b80ad..6f2b57e 100644 --- a/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java +++ b/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java @@ -1,14 +1,9 @@ package MakeItFit.queries; -import static org.junit.jupiter.api.Assertions.assertEquals; - import java.util.Arrays; import java.util.List; import java.util.UUID; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - import MakeItFit.activities.Activity; import MakeItFit.activities.implementation.PushUp; import MakeItFit.activities.implementation.Running; @@ -19,31 +14,33 @@ import MakeItFit.users.UserManager; import MakeItFit.users.types.Professional; import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; public class MostDoneActivityTest { private MostDoneActivity query; - private UserManager userManager; + private UserManager userManager; - private PushUp pushUp; - private Running running; - private Trail trail; + private PushUp pushUp; + private Running running; + private Trail trail; private WeightSquat weightSquat; private User createUser(String email, List activities) { - User user = new Professional( - "JohnDoe", - 21, - Gender.Male, - 59, - 150, - 60, - 6, - "Lloyd", - "987 123 432", - email, - 7 - ); + User user = new Professional("JohnDoe", + 21, + Gender.Male, + 59, + 150, + 60, + 6, + "Lloyd", + "987 123 432", + email, + 7); user.addActivities(activities); return user; @@ -51,48 +48,40 @@ private User createUser(String email, List activities) { @BeforeEach void testSetup() { - this.query = new MostDoneActivity(); + this.query = new MostDoneActivity(); this.userManager = new UserManager(); - this.pushUp = new PushUp( - UUID.randomUUID(), - MakeItFitDate.of(2000, 1, 1), - 60, - "PushUp", - "DO IT", - 10, - 100 - ); - this.running = new Running( - UUID.randomUUID(), - MakeItFitDate.of(2000, 1, 1), - 70, - "Running", - "For my life", - 100, - 1 - ); - this.trail = new Trail( - UUID.randomUUID(), - MakeItFitDate.of(2000, 1, 1), - 120, - "Trail", - "RunningUpThatHill", - 100, - 123, - 321, - 2 - ); - this.weightSquat = new WeightSquat( - UUID.randomUUID(), - MakeItFitDate.of(2000, 1, 1), - 45, - "WeightSquat", - "PumpItUp", - 10, - 100, - 46 - ); + this.pushUp = new PushUp(UUID.randomUUID(), + MakeItFitDate.of(2000, 1, 1), + 60, + "PushUp", + "DO IT", + 10, + 100); + this.running = new Running(UUID.randomUUID(), + MakeItFitDate.of(2000, 1, 1), + 70, + "Running", + "For my life", + 100, + 1); + this.trail = new Trail(UUID.randomUUID(), + MakeItFitDate.of(2000, 1, 1), + 120, + "Trail", + "RunningUpThatHill", + 100, + 123, + 321, + 2); + this.weightSquat = new WeightSquat(UUID.randomUUID(), + MakeItFitDate.of(2000, 1, 1), + 45, + "WeightSquat", + "PumpItUp", + 10, + 100, + 46); } @Test @@ -102,13 +91,9 @@ void testExecuteQueryNoUsers() { @Test void testExecuteQuerySingleUserReturnsRepetitions() { - User user = createUser("jd@uminho.pt", Arrays.asList( - this.pushUp, - this.pushUp, - this.running, - this.trail, - this.weightSquat - )); + User user = createUser( + "jd@uminho.pt", + Arrays.asList(this.pushUp, this.pushUp, this.running, this.trail, this.weightSquat)); this.userManager.insertUser(user); assertEquals("Repetitions", this.query.executeQuery(this.userManager)); @@ -116,13 +101,9 @@ void testExecuteQuerySingleUserReturnsRepetitions() { @Test void testExecuteQuerySingleUserReturnsDistance() { - User user = createUser("jd@uminho.pt", Arrays.asList( - this.pushUp, - this.running, - this.running, - this.trail, - this.weightSquat - )); + User user = createUser( + "jd@uminho.pt", + Arrays.asList(this.pushUp, this.running, this.running, this.trail, this.weightSquat)); this.userManager.insertUser(user); assertEquals("Distance", this.query.executeQuery(this.userManager)); @@ -130,13 +111,9 @@ void testExecuteQuerySingleUserReturnsDistance() { @Test void testExecuteQuerySingleUserReturnsDistanceWithAltimetry() { - User user = createUser("jd@uminho.pt", Arrays.asList( - this.pushUp, - this.running, - this.trail, - this.trail, - this.weightSquat - )); + User user = createUser( + "jd@uminho.pt", + Arrays.asList(this.pushUp, this.running, this.trail, this.trail, this.weightSquat)); this.userManager.insertUser(user); assertEquals("DistanceWithAltimetry", this.query.executeQuery(this.userManager)); @@ -144,13 +121,12 @@ void testExecuteQuerySingleUserReturnsDistanceWithAltimetry() { @Test void testExecuteQuerySingleUserReturnsRepetitionsWithWeights() { - User user = createUser("jd@uminho.pt", Arrays.asList( - this.pushUp, - this.running, - this.trail, - this.weightSquat, - this.weightSquat - )); + User user = createUser("jd@uminho.pt", + Arrays.asList(this.pushUp, + this.running, + this.trail, + this.weightSquat, + this.weightSquat)); this.userManager.insertUser(user); assertEquals("RepetitionsWithWeights", this.query.executeQuery(this.userManager)); @@ -161,10 +137,8 @@ void testExecuteQueryMultipleUsersReturnsDistance() { User user1 = createUser("jd@suspect.pt", Arrays.asList(this.pushUp, this.pushUp)); User user2 = createUser("jd@uminho.pt", Arrays.asList(this.trail)); User user3 = createUser("jd@eb23.pt", Arrays.asList(this.weightSquat, this.weightSquat)); - User user4 = createUser( - "jd@vice.pt", - Arrays.asList(this.running, this.running, this.running) - ); + User user4 = + createUser("jd@vice.pt", Arrays.asList(this.running, this.running, this.running)); this.userManager.insertUser(user1); this.userManager.insertUser(user2); diff --git a/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java b/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java index f5a1103..930a401 100644 --- a/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java +++ b/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java @@ -1,14 +1,8 @@ package MakeItFit.queries; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertSame; - import java.util.ArrayList; import java.util.Arrays; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - import MakeItFit.MakeItFit; import MakeItFit.activities.Activity; import MakeItFit.activities.implementation.Trail; @@ -20,45 +14,46 @@ import MakeItFit.users.types.Professional; 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.assertEquals; +import static org.junit.jupiter.api.Assertions.assertSame; public class QueriesManagerTest { - QueriesManager queriesManager; - UserManager userManager; + QueriesManager queriesManager; + UserManager userManager; TrainingPlanManager TPManager; - Trail trail; - User user; + Trail trail; + User user; @BeforeEach void testSetup() { this.queriesManager = new QueriesManager(); - this.userManager = new UserManager(); - this.TPManager = new TrainingPlanManager(); - this.user = new Professional( - "JohnDoe", - 21, - Gender.Male, - 59, - 150, - 60, - 6, - "Lloyd", - "987 123 432", - "jd@suspect.pt", - 7 - ); - - this.trail = new Trail( - this.user.getCode(), - MakeItFitDate.of(2000, 1, 1), - 90, - "Hiking", - "Subir ao Bom Jesus", - 2000.0, - 12432.3, - 12341.2, - 1 - ); + this.userManager = new UserManager(); + this.TPManager = new TrainingPlanManager(); + this.user = new Professional("JohnDoe", + 21, + Gender.Male, + 59, + 150, + 60, + 6, + "Lloyd", + "987 123 432", + "jd@suspect.pt", + 7); + + this.trail = new Trail(this.user.getCode(), + MakeItFitDate.of(2000, 1, 1), + 90, + "Hiking", + "Subir ao Bom Jesus", + 2000.0, + 12432.3, + 12341.2, + 1); } @Test @@ -68,20 +63,14 @@ void testExecuteQueryHowManyAltimetryDoneWithDates() { user.addActivities(Arrays.asList(this.trail, this.trail)); userManager.insertUser(user); - assertEquals( - query.executeQuery( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 12, 30), - MakeItFitDate.of(2000, 1 , 2) - ), - queriesManager.executeQueryHowManyAltimetryDone( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 12, 30), - MakeItFitDate.of(2000, 1 , 2) - ) - ); + assertEquals(query.executeQuery(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 12, 30), + MakeItFitDate.of(2000, 1, 2)), + queriesManager.executeQueryHowManyAltimetryDone(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 12, 30), + MakeItFitDate.of(2000, 1, 2))); } @Test @@ -91,13 +80,9 @@ void testExecuteQueryHowManyAltimetryDone() { this.user.addActivities(Arrays.asList(this.trail, this.trail)); this.userManager.insertUser(this.user); - assertEquals( - query.executeQuery(this.userManager, "jd@suspect.pt"), - this.queriesManager.executeQueryHowManyAltimetryDone( - this.userManager, - "jd@suspect.pt" - ) - ); + assertEquals(query.executeQuery(this.userManager, "jd@suspect.pt"), + this.queriesManager.executeQueryHowManyAltimetryDone(this.userManager, + "jd@suspect.pt")); } @Test @@ -107,21 +92,15 @@ void testExecuteQueryHowManyKMsDoneWithDates() { this.user.addActivities(Arrays.asList(this.trail, this.trail)); this.userManager.insertUser(this.user); - assertEquals( - query.executeQuery( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 2, 8), - MakeItFitDate.of(2000, 1, 2) - ), - this.queriesManager.executeQueryHowManyKMsDone( - userManager, - "jd@suspect.pt", - MakeItFitDate.of(1999, 2, 8), - MakeItFitDate.of(2000, 1, 2) - ), - 0.0001 - ); + assertEquals(query.executeQuery(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2)), + this.queriesManager.executeQueryHowManyKMsDone(userManager, + "jd@suspect.pt", + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2)), + 0.0001); } @Test @@ -131,35 +110,21 @@ void testExecuteQueryHowManyKMsDone() { this.user.addActivities(Arrays.asList(this.trail, this.trail)); this.userManager.insertUser(this.user); - assertEquals( - query.executeQuery( - userManager, - "jd@suspect.pt" - ), - this.queriesManager.executeQueryHowManyKMsDone( - userManager, - "jd@suspect.pt" - ), - 0.0001 - ); + assertEquals(query.executeQuery(userManager, "jd@suspect.pt"), + this.queriesManager.executeQueryHowManyKMsDone(userManager, "jd@suspect.pt"), + 0.0001); } @Test void testExecuteQueryMostDemandingTrainingPlan() { MostDemandingTrainingPlan query = new MostDemandingTrainingPlan(); - TrainingPlan tp = new TrainingPlan( - this.user.getCode(), - MakeItFitDate.of(2000, 1, 1) - ); + TrainingPlan tp = new TrainingPlan(this.user.getCode(), MakeItFitDate.of(2000, 1, 1)); ArrayList> activities = new ArrayList>( - Arrays.asList( - new MyTuple(1, this.trail), - new MyTuple(2, this.trail) - ) - ); + Arrays.asList(new MyTuple(1, this.trail), + new MyTuple(2, this.trail))); for (MyTuple activity : activities) { tp.addActivity(activity.getItem1(), activity.getItem2()); @@ -168,12 +133,9 @@ void testExecuteQueryMostDemandingTrainingPlan() { this.userManager.insertUser(this.user); this.TPManager.insertTrainingPlan(tp); - assertSame( - query.executeQuery(this.TPManager, this.userManager), - this.queriesManager.executeQueryMostDemandingTrainingPlan( - this.TPManager, this.userManager - ) - ); + assertSame(query.executeQuery(this.TPManager, this.userManager), + this.queriesManager.executeQueryMostDemandingTrainingPlan(this.TPManager, + this.userManager)); } @Test @@ -183,10 +145,8 @@ void testExecuteQueryMostDoneActivity() { this.user.addActivities(Arrays.asList(this.trail, this.trail)); this.userManager.insertUser(this.user); - assertEquals( - query.executeQuery(this.userManager), - this.queriesManager.executeQueryMostDoneActivity(this.userManager) - ); + assertEquals(query.executeQuery(this.userManager), + this.queriesManager.executeQueryMostDoneActivity(this.userManager)); } @Test @@ -201,17 +161,12 @@ void testExecuteQueryWhoBurnsMoreCaloresWithDates() { this.userManager.insertUser(user1); assertSame( - query.executeQuery( - this.userManager, - MakeItFitDate.of(1999, 2, 8), - MakeItFitDate.of(2000, 1, 2) - ), - this.queriesManager.executeQuerywhoBurnsMoreCalories( - this.userManager, - MakeItFitDate.of(1999, 2, 8), - MakeItFitDate.of(2000, 1, 2) - ) - ); + query.executeQuery(this.userManager, + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2)), + this.queriesManager.executeQuerywhoBurnsMoreCalories(this.userManager, + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2))); } @Test @@ -226,10 +181,8 @@ void testExecuteQueryWhoBurnsMoreCalores() { this.userManager.insertUser(user); this.userManager.insertUser(user1); - assertSame( - query.executeQuery(this.userManager), - this.queriesManager.executeQuerywhoBurnsMoreCalories(this.userManager) - ); + assertSame(query.executeQuery(this.userManager), + this.queriesManager.executeQuerywhoBurnsMoreCalories(this.userManager)); } @Test @@ -245,17 +198,12 @@ void testWhoDidTheMostActivitiesWithDates() { this.userManager.insertUser(user1); assertSame( - query.executeQuery( - this.userManager, - MakeItFitDate.of(1999, 2, 8), - MakeItFitDate.of(2000, 1, 2) - ), - this.queriesManager.executeQueryWhoDidTheMostActivities( - this.userManager, - MakeItFitDate.of(1999, 2, 8), - MakeItFitDate.of(2000, 1, 2) - ) - ); + query.executeQuery(this.userManager, + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2)), + this.queriesManager.executeQueryWhoDidTheMostActivities(this.userManager, + MakeItFitDate.of(1999, 2, 8), + MakeItFitDate.of(2000, 1, 2))); } @Test @@ -270,9 +218,7 @@ void testWhoDidTheMostActivities() { this.userManager.insertUser(user); this.userManager.insertUser(user1); - assertSame( - query.executeQuery(this.userManager), - this.queriesManager.executeQueryWhoDidTheMostActivities(this.userManager) - ); + assertSame(query.executeQuery(this.userManager), + this.queriesManager.executeQueryWhoDidTheMostActivities(this.userManager)); } } diff --git a/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java b/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java index 4e1a030..9e9012f 100644 --- a/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java +++ b/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java @@ -1,15 +1,8 @@ package MakeItFit.queries; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertThrows; - import java.util.Arrays; import java.util.UUID; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - import MakeItFit.activities.Activity; import MakeItFit.activities.implementation.PushUp; import MakeItFit.users.Gender; @@ -17,121 +10,101 @@ import MakeItFit.users.UserManager; import MakeItFit.users.types.Professional; import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; public class WhoBurnsMoreCaloriesTest { private WhoBurnsMoreCalories query; - private UserManager userManager; + private UserManager userManager; private User createUser(String email, float weight, int height, int bpm) { - return new Professional( - "JohnDoe", - 21, - Gender.Male, - weight, - height, - bpm, - 6, - "Lloyd", - "987 123 432", - email, - 7 - ); + return new Professional("JohnDoe", + 21, + Gender.Male, + weight, + height, + bpm, + 6, + "Lloyd", + "987 123 432", + email, + 7); } private PushUp createPushUp(UUID code, MakeItFitDate date) { - return new PushUp( - code, - date, - 60, - "PushUp", - "DO IT", - 10, - 100 - ); + return new PushUp(code, date, 60, "PushUp", "DO IT", 10, 100); } @BeforeEach void testSetup() { - query = new WhoBurnsMoreCalories(); + query = new WhoBurnsMoreCalories(); userManager = new UserManager(); } @Test void testExecuteQueryWithDatesThrows() { - assertThrows( - IllegalArgumentException.class, - () -> this.query.executeQuery( - userManager, - MakeItFitDate.of(2000, 2, 9), - MakeItFitDate.of(1999, 12, 30) - ) - ); + assertThrows(IllegalArgumentException.class, + () + -> this.query.executeQuery(userManager, + MakeItFitDate.of(2000, 2, 9), + MakeItFitDate.of(1999, 12, 30))); } @Test void testExecuteQueryWithDatesReturnsUserWithValidActivities() { User user1 = createUser("jd@uminho.pt", 58, 167, 80); - user1.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); User user2 = createUser("jd@gemail.pt", 58, 167, 80); - user2.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(2004, 2, 15)), - createPushUp(user1.getCode(), MakeItFitDate.of(2003, 2, 15)), - createPushUp(user1.getCode(), MakeItFitDate.of(2002, 2, 15)) - )); + user2.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(2004, 2, 15)), + createPushUp(user1.getCode(), MakeItFitDate.of(2003, 2, 15)), + createPushUp(user1.getCode(), MakeItFitDate.of(2002, 2, 15)))); userManager.insertUser(user1); userManager.insertUser(user2); assertSame(user1, - query.executeQuery( - userManager, - MakeItFitDate.of(1998, 1, 1), - MakeItFitDate.of(1999, 11, 1) - ) - ); + query.executeQuery(userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(1999, 11, 1))); } @Test void testExecuteQueryWithDatesTieReturnsFirstUser() { User user1 = createUser("jd@uminho.pt", 58, 167, 80); - user1.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); User user1Copy = createUser("jd@gemail.pt", 58, 167, 80); - user1Copy.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1Copy.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); this.userManager.insertUser(user1); this.userManager.insertUser(user1Copy); - assertSame( - this.userManager.getAllUsers().get(0), - query.executeQuery( - userManager, - MakeItFitDate.of(1998, 1, 1), - MakeItFitDate.of(1999, 11, 1) - ) - ); + assertSame(this.userManager.getAllUsers().get(0), + query.executeQuery(userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(1999, 11, 1))); } @Test void testExecuteQueryReturnsCorrectUser() { User user1 = createUser("jd@uminho.pt", 58, 167, 80); - user1.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); User user2 = createUser("jd@gemail.pt", 58, 167, 80); - user2.addActivities(Arrays.asList( - createPushUp(user2.getCode(), MakeItFitDate.of(2004, 2, 15)), - createPushUp(user2.getCode(), MakeItFitDate.of(2003, 2, 15)), - createPushUp(user2.getCode(), MakeItFitDate.of(2002, 2, 15)) - )); + user2.addActivities( + Arrays.asList(createPushUp(user2.getCode(), MakeItFitDate.of(2004, 2, 15)), + createPushUp(user2.getCode(), MakeItFitDate.of(2003, 2, 15)), + createPushUp(user2.getCode(), MakeItFitDate.of(2002, 2, 15)))); userManager.insertUser(user1); userManager.insertUser(user2); @@ -149,24 +122,19 @@ void testExecuteQueryReturnsCorrectUser() { } assertSame(caloriesUser1 < caloriesUser2 ? user2 : user1, - query.executeQuery( - userManager, - MakeItFitDate.of(1998, 1, 1), - MakeItFitDate.of(2004, 2, 16) - ) - ); + query.executeQuery(userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(2004, 2, 16))); } @Test void testExecuteQueryTieReturnsFirstUser() { User user1 = createUser("jd@uminho.pt", 58, 167, 80); - user1.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); User user1Copy = createUser("jd@gemail.pt", 58, 167, 80); - user1Copy.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1Copy.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); this.userManager.insertUser(user1); this.userManager.insertUser(user1Copy); @@ -176,13 +144,9 @@ void testExecuteQueryTieReturnsFirstUser() { @Test void testExecuteQueryWithDatesNoUsersReturnsNull() { - assertNull( - query.executeQuery( - this.userManager, - MakeItFitDate.of(2000, 1, 1), - MakeItFitDate.of(2000, 1, 2) - ) - ); + assertNull(query.executeQuery(this.userManager, + MakeItFitDate.of(2000, 1, 1), + MakeItFitDate.of(2000, 1, 2))); } @Test diff --git a/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java b/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java index b67939f..6f6ab08 100644 --- a/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java +++ b/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java @@ -1,53 +1,42 @@ package MakeItFit.queries; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertSame; -import static org.junit.jupiter.api.Assertions.assertThrows; - import java.util.Arrays; import java.util.UUID; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; - import MakeItFit.activities.implementation.PushUp; import MakeItFit.users.Gender; import MakeItFit.users.User; import MakeItFit.users.UserManager; import MakeItFit.users.types.Professional; import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertThrows; public class WhoDidTheMostActivitiesTest { private WhoDidTheMostActivities query; - private UserManager userManager; + private UserManager userManager; private User createUser(String email) { - return new Professional( - "JohnDoe", - 21, - Gender.Male, - 60, - 140, - 54, - 6, - "Lloyd", - "987 123 432", - email, - 7 - ); + return new Professional("JohnDoe", + 21, + Gender.Male, + 60, + 140, + 54, + 6, + "Lloyd", + "987 123 432", + email, + 7); } private PushUp createPushUp(UUID code, MakeItFitDate date) { - return new PushUp( - code, - date, - 60, - "PushUp", - "DO IT", - 10, - 100 - ); + return new PushUp(code, date, 60, "PushUp", "DO IT", 10, 100); } @BeforeEach @@ -58,103 +47,82 @@ void testSetup() { @Test void testExecuteQueryWithDatesThrows() { - assertThrows( - IllegalArgumentException.class, - () -> this.query.executeQuery( - userManager, - MakeItFitDate.of(2000, 2, 9), - MakeItFitDate.of(1999, 12, 30) - ) - ); + assertThrows(IllegalArgumentException.class, + () + -> this.query.executeQuery(userManager, + MakeItFitDate.of(2000, 2, 9), + MakeItFitDate.of(1999, 12, 30))); } @Test void testExecuteQueryWithDatesReturnsUserWithValidActivities() { User user1 = createUser("jd@uminho.pt"); - user1.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); User user2 = createUser("jd@gemail.pt"); - user2.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(2004, 2, 15)), - createPushUp(user1.getCode(), MakeItFitDate.of(2003, 2, 15)), - createPushUp(user1.getCode(), MakeItFitDate.of(2002, 2, 15)) - )); + user2.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(2004, 2, 15)), + createPushUp(user1.getCode(), MakeItFitDate.of(2003, 2, 15)), + createPushUp(user1.getCode(), MakeItFitDate.of(2002, 2, 15)))); userManager.insertUser(user1); userManager.insertUser(user2); assertSame(user1, - query.executeQuery( - userManager, - MakeItFitDate.of(1998, 1, 1), - MakeItFitDate.of(1999, 11, 1) - ) - ); + query.executeQuery(userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(1999, 11, 1))); } @Test void testExecuteQueryWithDatesTieReturnsFirstUser() { User user1 = createUser("jd@uminho.pt"); - user1.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); User user1Copy = createUser("jd@gemail.pt"); - user1Copy.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1Copy.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); this.userManager.insertUser(user1); this.userManager.insertUser(user1Copy); - assertSame( - this.userManager.getAllUsers().get(0), - query.executeQuery( - userManager, - MakeItFitDate.of(1998, 1, 1), - MakeItFitDate.of(1999, 11, 1) - ) - ); + assertSame(this.userManager.getAllUsers().get(0), + query.executeQuery(userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(1999, 11, 1))); } @Test void testExecuteQueryReturnsCorrectUser() { User user1 = createUser("jd@uminho.pt"); - user1.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); User user2 = createUser("jd@gemail.pt"); - user2.addActivities(Arrays.asList( - createPushUp(user2.getCode(), MakeItFitDate.of(2004, 2, 15)), - createPushUp(user2.getCode(), MakeItFitDate.of(2003, 2, 15)), - createPushUp(user2.getCode(), MakeItFitDate.of(2002, 2, 15)) - )); + user2.addActivities( + Arrays.asList(createPushUp(user2.getCode(), MakeItFitDate.of(2004, 2, 15)), + createPushUp(user2.getCode(), MakeItFitDate.of(2003, 2, 15)), + createPushUp(user2.getCode(), MakeItFitDate.of(2002, 2, 15)))); userManager.insertUser(user1); userManager.insertUser(user2); - assertSame( - user1.getListActivities().size() < user2.getListActivities().size() ? user2 : user1, - query.executeQuery( - userManager, - MakeItFitDate.of(1998, 1, 1), - MakeItFitDate.of(2004, 2, 16) - ) - ); + assertSame(user1.getListActivities().size() < user2.getListActivities().size() ? user2 + : user1, + query.executeQuery(userManager, + MakeItFitDate.of(1998, 1, 1), + MakeItFitDate.of(2004, 2, 16))); } @Test void testExecuteQueryTieReturnsFirstUser() { User user1 = createUser("jd@uminho.pt"); - user1.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); User user1Copy = createUser("jd@gemail.pt"); - user1Copy.addActivities(Arrays.asList( - createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)) - )); + user1Copy.addActivities( + Arrays.asList(createPushUp(user1.getCode(), MakeItFitDate.of(1999, 10, 2)))); this.userManager.insertUser(user1); this.userManager.insertUser(user1Copy); @@ -164,13 +132,9 @@ void testExecuteQueryTieReturnsFirstUser() { @Test void testExecuteQueryWithDatesNoUsersReturnsNull() { - assertNull( - query.executeQuery( - this.userManager, - MakeItFitDate.of(2000, 1, 1), - MakeItFitDate.of(2000, 1, 2) - ) - ); + assertNull(query.executeQuery(this.userManager, + MakeItFitDate.of(2000, 1, 1), + MakeItFitDate.of(2000, 1, 2))); } @Test diff --git a/src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java b/src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java index 62ba523..5532131 100644 --- a/src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java +++ b/src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java @@ -1,5 +1,3 @@ package MakeItFit.utils; -public class MakeItFitDateTest { - -} +public class MakeItFitDateTest {} diff --git a/src/unittests/java/MakeItFit/utils/MyTupleTest.java b/src/unittests/java/MakeItFit/utils/MyTupleTest.java index bf111b9..2ad43b1 100644 --- a/src/unittests/java/MakeItFit/utils/MyTupleTest.java +++ b/src/unittests/java/MakeItFit/utils/MyTupleTest.java @@ -1,5 +1,3 @@ package MakeItFit.utils; -public class MyTupleTest { - -} +public class MyTupleTest {} From 0fc5afd02f5ea1e0658fa7e5d9e99fcfc33be74f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jos=C3=A9=20Lopes?= Date: Wed, 4 Jun 2025 00:50:49 +0100 Subject: [PATCH 10/10] delete utils unit testing base --- .../java/MakeItFit/utils/EmailValidatorTest.java | 13 ------------- .../java/MakeItFit/utils/MakeItFitDateTest.java | 3 --- src/unittests/java/MakeItFit/utils/MyTupleTest.java | 3 --- 3 files changed, 19 deletions(-) delete mode 100644 src/unittests/java/MakeItFit/utils/EmailValidatorTest.java delete mode 100644 src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java delete mode 100644 src/unittests/java/MakeItFit/utils/MyTupleTest.java diff --git a/src/unittests/java/MakeItFit/utils/EmailValidatorTest.java b/src/unittests/java/MakeItFit/utils/EmailValidatorTest.java deleted file mode 100644 index 1a7605a..0000000 --- a/src/unittests/java/MakeItFit/utils/EmailValidatorTest.java +++ /dev/null @@ -1,13 +0,0 @@ -package MakeItFit.utils; - -import MakeItFit.utils.MakeItFitDate; -import org.junit.jupiter.api.Test; - -import static org.junit.jupiter.api.Assertions.*; - -public class EmailValidatorTest { - @Test - public void testValid() { - assertTrue(EmailValidator.isValidEmail("jonh@mail.com")); - } -} diff --git a/src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java b/src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java deleted file mode 100644 index 5532131..0000000 --- a/src/unittests/java/MakeItFit/utils/MakeItFitDateTest.java +++ /dev/null @@ -1,3 +0,0 @@ -package MakeItFit.utils; - -public class MakeItFitDateTest {} diff --git a/src/unittests/java/MakeItFit/utils/MyTupleTest.java b/src/unittests/java/MakeItFit/utils/MyTupleTest.java deleted file mode 100644 index 2ad43b1..0000000 --- a/src/unittests/java/MakeItFit/utils/MyTupleTest.java +++ /dev/null @@ -1,3 +0,0 @@ -package MakeItFit.utils; - -public class MyTupleTest {}