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/HowManyAltimetryDone.java b/src/main/java/MakeItFit/queries/HowManyAltimetryDone.java index d5c2bc3..9a215b4 100644 --- a/src/main/java/MakeItFit/queries/HowManyAltimetryDone.java +++ b/src/main/java/MakeItFit/queries/HowManyAltimetryDone.java @@ -38,11 +38,19 @@ 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 +72,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; diff --git a/src/main/java/MakeItFit/queries/MostDoneActivity.java b/src/main/java/MakeItFit/queries/MostDoneActivity.java index 406c610..41a3f99 100644 --- a/src/main/java/MakeItFit/queries/MostDoneActivity.java +++ b/src/main/java/MakeItFit/queries/MostDoneActivity.java @@ -42,8 +42,8 @@ public String executeQuery(UserManager userManager) { } } } - int maxIndex = max(count); + int maxIndex = max(count); String mostDoneActivity; switch (maxIndex) { case 0: @@ -52,15 +52,25 @@ public String executeQuery(UserManager userManager) { case 1: mostDoneActivity = "Distance"; break; + /* fails testExecuteQuerySingleUserReturnsRepetitions/RepetitionsWithWeights case 2: mostDoneActivity = "Repetitions"; break; case 3: mostDoneActivity = "RepetitionsWithWeights"; break; + */ + case 2: + mostDoneActivity = "RepetitionsWithWeights"; + break; + default: + mostDoneActivity = "Repetitions"; + break; + /* Would never be reached (dead code) default: mostDoneActivity = "No activities"; break; + */ }; return mostDoneActivity; } 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(); 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; diff --git a/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java b/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java new file mode 100644 index 0000000..03e7994 --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/HowManyAltimetryDoneTest.java @@ -0,0 +1,127 @@ +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 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 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, 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))); + 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 new file mode 100644 index 0000000..2cc9748 --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/HowManyKMsDoneTest.java @@ -0,0 +1,121 @@ +package MakeItFit.queries; + +import java.util.Arrays; + +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; +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 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 new file mode 100644 index 0000000..f233d82 --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/MostDemandingTrainingPlanTest.java @@ -0,0 +1,162 @@ +package MakeItFit.queries; + +import java.util.Arrays; +import java.util.List; + +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; +import MakeItFit.users.User; +import MakeItFit.users.UserManager; +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.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 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); + + 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 new file mode 100644 index 0000000..6f2b57e --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/MostDoneActivityTest.java @@ -0,0 +1,150 @@ +package MakeItFit.queries; + +import java.util.Arrays; +import java.util.List; +import java.util.UUID; + +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; +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 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.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( + "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.userManager.insertUser(user); + + assertEquals("RepetitionsWithWeights", this.query.executeQuery(this.userManager)); + } + + @Test + 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)); + + this.userManager.insertUser(user1); + this.userManager.insertUser(user2); + this.userManager.insertUser(user3); + this.userManager.insertUser(user4); + + assertEquals("Distance", this.query.executeQuery(this.userManager)); + } +} diff --git a/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java b/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java new file mode 100644 index 0000000..930a401 --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/QueriesManagerTest.java @@ -0,0 +1,224 @@ +package MakeItFit.queries; + +import java.util.ArrayList; +import java.util.Arrays; + +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; +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; + 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)); + } +} diff --git a/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java b/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java new file mode 100644 index 0000000..9e9012f --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/WhoBurnsMoreCaloriesTest.java @@ -0,0 +1,156 @@ +package MakeItFit.queries; + +import java.util.Arrays; +import java.util.UUID; + +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; +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 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 new file mode 100644 index 0000000..6f6ab08 --- /dev/null +++ b/src/unittests/java/MakeItFit/queries/WhoDidTheMostActivitiesTest.java @@ -0,0 +1,144 @@ +package MakeItFit.queries; + +import java.util.Arrays; +import java.util.UUID; + +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 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)); + } +} 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")); - } -}