diff --git a/src/main/java/MakeItFit/users/User.java b/src/main/java/MakeItFit/users/User.java index c04f1e0..1f5e713 100644 --- a/src/main/java/MakeItFit/users/User.java +++ b/src/main/java/MakeItFit/users/User.java @@ -14,6 +14,7 @@ * @version (11052024) */ public abstract class User implements UserInterface, Serializable, Comparable { + // CHANGED: removed index and setIndex: now calculated dynamically private final UUID code; private String name; @@ -26,7 +27,6 @@ public abstract class User implements UserInterface, Serializable, Comparable activities; /** @@ -53,18 +53,19 @@ public User(String name, String address, String phone, String email) { - this.code = UUID.randomUUID(); - this.name = name; - this.age = age; - this.gender = gender; - this.weight = weight; - this.height = height; - this.bpm = bpm; - this.level = level; + + // CHANGED: Added argument validation + this.code = UUID.randomUUID(); + this.name = name; + this.setAge(age); + this.gender = gender; + this.setWeight(weight); + this.setHeight(height); + this.setBpm(bpm); + this.setLevel(level); this.address = address; this.phone = phone; this.email = email; - this.index = calculateIndex(weight, height, bpm); this.activities = new ArrayList<>(); } @@ -72,18 +73,20 @@ public User(String name, * Constructs a new user with the default details. */ public User() { + // NOTE: unreachable code + // CHANGED: made values for weight, height, and bpm valid + this.code = UUID.randomUUID(); this.name = ""; this.age = 0; this.gender = Gender.Other; - this.weight = 0; - this.height = 0; - this.bpm = 0; + this.weight = 1.0f; + this.height = 1; + this.bpm = 1; this.level = 0; this.address = ""; this.phone = ""; this.email = ""; - this.index = 0; this.activities = new ArrayList<>(); } @@ -104,7 +107,6 @@ public User(User u) { this.address = u.getAddress(); this.phone = u.getPhone(); this.email = u.getEmail(); - this.index = u.getIndex(); this.activities = u.getListActivities(); } @@ -213,7 +215,7 @@ public String getEmail() { * @return The index of the user. */ public float getIndex() { - return this.index; + return this.calculateIndex(this.weight, this.height, this.bpm); } /** @@ -240,6 +242,11 @@ public void setName(String name) { * @param age The new age of the user. */ public void setAge(int age) { + // CHANGED: Added argument validation + if (age < 0) { + throw new IllegalArgumentException("Invalid user age"); + } + this.age = age; } @@ -258,6 +265,11 @@ public void setGender(Gender gender) { * @param weight The new weight of the user. */ public void setWeight(float weight) { + // CHANGED: Added argument validation + if (weight < 0.0f) { + throw new IllegalArgumentException("Invalid user weight"); + } + this.weight = weight; } @@ -267,6 +279,11 @@ public void setWeight(float weight) { * @param height The new height of the user. */ public void setHeight(int height) { + // CHANGED: Added argument validation + if (height < 0) { + throw new IllegalArgumentException("Invalid user age"); + } + this.height = height; } @@ -276,6 +293,11 @@ public void setHeight(int height) { * @param bpm The new bpm of the user. */ public void setBpm(int bpm) { + // CHANGED: Added argument validation + if (bpm < 0) { + throw new IllegalArgumentException("Invalid user bpm"); + } + this.bpm = bpm; } @@ -285,6 +307,11 @@ public void setBpm(int bpm) { * @param level The new level of the user. */ public void setLevel(int level) { + // CHANGED: Added argument validation + if (level < 0) { + throw new IllegalArgumentException("Invalid user level"); + } + this.level = level; } @@ -315,15 +342,6 @@ public void setEmail(String email) { this.email = email; } - /** - * Sets the index of the user. - * - * @param index The new index of the user. - */ - public void setIndex(float index) { - this.index = index; - } - /** * Adds an activity to the user's list of activities. * @@ -334,7 +352,10 @@ public void addActivity(Activity activity) { } public void addActivities(List activities) { - this.activities.addAll(activities); + // CHANGED: fix composition + for (Activity activity : activities) { + this.activities.add(activity.clone()); + } } /** @@ -351,7 +372,7 @@ public void removeActivity(UUID activityCode) { */ public void updateActivities() { for (Activity activity : this.activities) { - activity.updateActivity(this.index); + activity.updateActivity(this.getIndex()); } } @@ -364,6 +385,11 @@ public void updateActivities() { * @return The index of the user. */ public float calculateIndex(float weight, int height, int bpm) { + // CHANGED: added argument validation + if (weight <= 0.0f || height <= 0 || bpm <= 0) { + throw new IllegalArgumentException("Invalid calculateIndex arguments"); + } + return (weight / (((float) height / 100) * ((float) height / 100)) + (float) bpm / 40); } @@ -382,19 +408,19 @@ public float calculateIndex(float weight, int height, int bpm) { @Override public String toString() { // clang-format off - return String.format(" == (User details) ==\n" + - " Code: %s\n" + - " Name: %s\n" + - " Age: %d\n" + - " Gender: %s\n" + - " Weight: %.2f kg\n" + - " Height: %d cm\n" + - " Bpm: %d\n" + - " Level: %s\n" + - " Address: %s\n" + - " Phone: %s\n" + - " Email: %s\n" + - " Activities: %s\n", + return String.format("== (User details) ==\n" + + "Code: %s\n" + + "Name: %s\n" + + "Age: %d\n" + + "Gender: %s\n" + + "Weight: %.2f kg\n" + + "Height: %d cm\n" + + "Bpm: %d\n" + + "Level: %s\n" + + "Address: %s\n" + + "Phone: %s\n" + + "Email: %s\n" + + "Activities: %s\n", this.code, this.name, this.age, @@ -418,12 +444,17 @@ public String toString() { */ @Override public boolean equals(Object o) { + // CHANGED: check for null, class, and gender + if (o == this) return true; - if (!(o instanceof User)) + if (o == null) + return false; + if (this.getClass() != o.getClass()) return false; + User u = (User) o; - return (this.index == u.index && this.name.equals(u.name) && this.age == u.age && + return (this.name.equals(u.name) && this.age == u.age && this.gender == u.gender && this.height == u.height && this.weight == u.weight && this.bpm == u.bpm && this.level == u.level && this.address.equals(u.address) && this.phone.equals(u.phone) && this.email.equals(u.email) && diff --git a/src/main/java/MakeItFit/users/UserManager.java b/src/main/java/MakeItFit/users/UserManager.java index 147b09d..5f510f0 100644 --- a/src/main/java/MakeItFit/users/UserManager.java +++ b/src/main/java/MakeItFit/users/UserManager.java @@ -119,6 +119,12 @@ public void insertUser(User user) throws ExistingEntityConflictException { " already exists."); } + // CHANGED: this check was missing + if (this.usersByCode.containsKey(user.getCode())) { + throw new ExistingEntityConflictException("User with code " + user.getCode() + + " already exists."); + } + this.usersByCode.put(user.getCode(), user); this.usersByEmail.put(email, user); } @@ -147,9 +153,11 @@ public void removeUserByCode(UUID code) throws EntityDoesNotExistException { * @throws EntityDoesNotExistException if the user does not exist */ public void removeUserByEmail(String email) throws EntityDoesNotExistException { + // CHANGED: original authors forgot conversion to lower case before comparison + email = email.toLowerCase(); if (!this.usersByEmail.containsKey(email)) { - throw new EntityDoesNotExistException("User with code " + email + " does not exist."); + throw new EntityDoesNotExistException("User with email " + email + " does not exist."); } User user = this.usersByEmail.get(email); @@ -241,6 +249,9 @@ public List getAllUsers() { * @return a list of all activities from the user */ public List getActivitiesFromUser(String email) throws EntityDoesNotExistException { + // CHANGED: original authors forgot conversion to lower case before comparison + email = email.toLowerCase(); + if (!this.usersByEmail.containsKey(email)) { throw new EntityDoesNotExistException(email); } @@ -253,7 +264,14 @@ public List getActivitiesFromUser(String email) throws EntityDoesNotEx * @param email the user's email * @param activity the activity to be added */ - public void addActivityToUser(String email, Activity activity) { + public void addActivityToUser(String email, Activity activity) + throws EntityDoesNotExistException { + // CHANGED: added email conversion to lower case and exception + email = email.toLowerCase(); + + if (!this.usersByEmail.containsKey(email)) { + throw new EntityDoesNotExistException(email); + } usersByEmail.get(email).addActivity(activity); } @@ -264,6 +282,13 @@ public void addActivityToUser(String email, Activity activity) { * @param activityCode the activity code */ public void removeActivityFromUser(String email, UUID activityCode) { + // CHANGED: added email conversion to lower case and exception + email = email.toLowerCase(); + + if (!this.usersByEmail.containsKey(email)) { + throw new EntityDoesNotExistException(email); + } + usersByEmail.get(email).removeActivity(activityCode); } @@ -273,7 +298,13 @@ public void removeActivityFromUser(String email, UUID activityCode) { * @param userCode the user's code * @param activities the activities to be added */ - public void addActivitiesToUser(UUID userCode, List activities) { + public void addActivitiesToUser(UUID userCode, List activities) + throws EntityDoesNotExistException { + // CHANGED: add exception + if (!this.usersByCode.containsKey(userCode)) { + throw new EntityDoesNotExistException("User with code " + userCode + " does not exist"); + } + usersByCode.get(userCode).addActivities(activities); } diff --git a/src/main/java/MakeItFit/users/types/Amateur.java b/src/main/java/MakeItFit/users/types/Amateur.java index 2a746c5..bf4c6eb 100644 --- a/src/main/java/MakeItFit/users/types/Amateur.java +++ b/src/main/java/MakeItFit/users/types/Amateur.java @@ -65,6 +65,6 @@ public Amateur clone() { * @return A string representation of this Amateur user. */ public String toString() { - return super.toString() + " ====================\n"; + return super.toString() + "====================\n"; } } diff --git a/src/main/java/MakeItFit/users/types/Occasional.java b/src/main/java/MakeItFit/users/types/Occasional.java index e27dfb8..481d402 100644 --- a/src/main/java/MakeItFit/users/types/Occasional.java +++ b/src/main/java/MakeItFit/users/types/Occasional.java @@ -75,6 +75,27 @@ public void setFrequency(int frequency) { this.frequency = frequency; } + // CHANGED: added equals method + + /** + * Checks if the user is equal to another object. + * + * @param o The object to compare. + * @return True if the user is equal to the object, false otherwise. + */ + @Override + public boolean equals(Object o) { + if (o == this) + return true; + if (o == null) + return false; + if (this.getClass() != o.getClass()) + return false; + + Occasional u = (Occasional) o; + return (super.equals(o) && this.frequency == u.frequency); + } + /** * Creates and returns a copy of this Occasional user. * @@ -91,7 +112,6 @@ public Occasional clone() { * @return a string containing the details of the Occasional user */ public String toString() { - return super.toString() + " Frequency: " + frequency + "\n" - + " ====================\n"; + return super.toString() + "Frequency: " + frequency + "\n====================\n"; } } diff --git a/src/main/java/MakeItFit/users/types/Professional.java b/src/main/java/MakeItFit/users/types/Professional.java index d7a74cf..3140bb6 100644 --- a/src/main/java/MakeItFit/users/types/Professional.java +++ b/src/main/java/MakeItFit/users/types/Professional.java @@ -48,9 +48,11 @@ public Professional(String name, String phone, String email, int frequency) { + + // CHANGED: Added argument validation super(name, age, gender, weight, height, bpm, level, address, phone, email); this.specialization = "No specialization"; - this.frequency = frequency; + this.setFrequency(frequency); } /** @@ -98,6 +100,11 @@ public int getFrequency() { * @param frequency the new training frequency to set */ public void setFrequency(int frequency) { + // CHANGED: Added argument validation + if (frequency < 0) { + throw new IllegalArgumentException("Frequency must be a non-negative integer"); + } + this.frequency = frequency; } @@ -118,6 +125,9 @@ public void updateSpecialization() { Collections.max(activityCount.entrySet(), Map.Entry.comparingByValue()).getKey(); this.setSpecialization(mostFrequentActivity); + } else { + // CHANGED: added this missing assignment + this.setSpecialization("No specialization"); } } @@ -131,14 +141,35 @@ public Professional clone() { return new Professional(this); } + // CHANGED: added equals method + + /** + * Checks if the user is equal to another object. + * + * @param o The object to compare. + * @return True if the user is equal to the object, false otherwise. + */ + @Override + public boolean equals(Object o) { + if (o == this) + return true; + if (o == null) + return false; + if (this.getClass() != o.getClass()) + return false; + + Professional u = (Professional) o; + return (super.equals(o) && this.frequency == u.frequency && + this.specialization.equals(u.specialization)); + } + /** * Returns a string representation of the professional. * * @return a string representation including the specialization and training frequency */ public String toString() { - return super.toString() + " Specialization: " + specialization + "\n" - + " Frequency: " + frequency + "\n" - + " ====================\n"; + return super.toString() + "Specialization: " + specialization + + "\nFrequency: " + frequency + "\n====================\n"; } } diff --git a/src/unittests/java/MakeItFit/users/UserManagerTest.java b/src/unittests/java/MakeItFit/users/UserManagerTest.java new file mode 100644 index 0000000..4302fd4 --- /dev/null +++ b/src/unittests/java/MakeItFit/users/UserManagerTest.java @@ -0,0 +1,710 @@ +package MakeItFit.users; + +import java.util.List; +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.exceptions.EntityDoesNotExistException; +import MakeItFit.exceptions.ExistingEntityConflictException; +import MakeItFit.exceptions.InvalidTypeException; +import MakeItFit.users.types.Amateur; +import MakeItFit.users.types.Occasional; +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.*; + +public class UserManagerTest { + private UserManager referenceManager; + private User referenceUser1, referenceUser2, referenceUser3; + private PushUp referenceActivity; + + @BeforeEach + public void initializeReferenceManager() { + this.referenceManager = new UserManager(); + this.referenceUser1 = this.referenceManager.createUser("João", + 30, + Gender.Male, + 80.5f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com", + 0, + "Amateur"); + this.referenceUser2 = this.referenceManager.createUser("Maria", + 25, + Gender.Female, + 60.2f, + 165, + 74, + 1, + "Mi casa tu casa", + "+351 456", + "ghi@jkl.com", + 10, + "Occasional"); + this.referenceUser3 = + this.referenceManager.createUser("Alex", + 40, + Gender.Other, + 65.0f, + 170, + 68, + 1, + "Morada", + "+351 789", + "MNO@PQR.com", // Test upper case emails + 7, + "Professional"); + + this.referenceManager.insertUser(this.referenceUser1); + this.referenceManager.insertUser(this.referenceUser2); + this.referenceManager.insertUser(this.referenceUser3); + + this.referenceActivity = + new PushUp(this.referenceUser1.getCode(), new MakeItFitDate(), 1, "", "", 10, 10); + } + + @Test + void testConstructor() { + UserManager manager = new UserManager(); + assertEquals(List.of(), manager.getAllUsers()); + } + + @Test + public void testCreateUser1() { + assertThrows(IllegalArgumentException.class, () -> { + this.referenceManager.createUser(null, + 30, + Gender.Male, + 70.5f, + 180, + 70, + 1, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + }); + } + + @Test + public void testCreateUser2() { + assertThrows(IllegalArgumentException.class, () -> { + this.referenceManager.createUser("John Doe", + 30, + Gender.Male, + 70.5f, + 180, + 70, + 1, + null, + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + }); + } + + @Test + public void testCreateUser3() { + assertThrows(IllegalArgumentException.class, () -> { + this.referenceManager.createUser("John Doe", + 30, + Gender.Male, + 70.5f, + 180, + 70, + 1, + "123 Main St", + null, + "john.doe@example.com", + 0, + "Amateur"); + }); + } + + @Test + public void testCreateUser4() { + assertThrows(IllegalArgumentException.class, () -> { + this.referenceManager.createUser("John Doe", + 30, + Gender.Male, + 70.5f, + 180, + 70, + 1, + "123 Main St", + "123-456-7890", + null, + 0, + "Amateur"); + }); + } + + @Test + public void testCreateUser5() { + assertThrows(IllegalArgumentException.class, () -> { + this.referenceManager.createUser("John Doe", + -1, + Gender.Male, + 70.5f, + 180, + 70, + 1, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + }); + } + + @Test + public void testCreateUser6() { + User u = this.referenceManager.createUser("John Doe", + 0, + Gender.Male, + 70.5f, + 180, + 70, + 1, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + assertTrue(u instanceof Amateur); + } + + @Test + public void testCreateUser7() { + assertThrows(IllegalArgumentException.class, () -> { + this.referenceManager.createUser("John Doe", + 30, + Gender.Male, + -1.0f, + 180, + 70, + 1, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + }); + } + + @Test + public void testCreateUser8() { + User u = this.referenceManager.createUser("John Doe", + 0, + Gender.Male, + 0.0f, + 180, + 70, + 1, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + assertTrue(u instanceof Amateur); + } + + @Test + public void testCreateUser9() { + assertThrows(IllegalArgumentException.class, () -> { + this.referenceManager.createUser("John Doe", + 30, + Gender.Male, + 70.5f, + -1, + 70, + 1, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + }); + } + + @Test + public void testCreateUser10() { + User u = this.referenceManager.createUser("John Doe", + 30, + Gender.Male, + 70.5f, + 0, + 70, + 1, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + assertTrue(u instanceof Amateur); + } + + @Test + public void testCreateUser11() { + assertThrows(IllegalArgumentException.class, () -> { + this.referenceManager.createUser("John Doe", + 30, + Gender.Male, + 70.5f, + 180, + -1, + 1, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + }); + } + + @Test + public void testCreateUser12() { + User u = this.referenceManager.createUser("John Doe", + 30, + Gender.Male, + 70.5f, + 180, + 0, + 1, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + assertTrue(u instanceof Amateur); + } + + @Test + public void testCreateUser13() { + assertThrows(IllegalArgumentException.class, () -> { + this.referenceManager.createUser("John Doe", + 30, + Gender.Male, + 70.5f, + 180, + 70, + -1, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + }); + } + + @Test + public void testCreateUser14() { + User u = this.referenceManager.createUser("John Doe", + 30, + Gender.Male, + 70.5f, + 180, + 70, + 0, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "Amateur"); + assertTrue(u instanceof Amateur); + } + + @Test + public void testCreateUser15() { + assertThrows(InvalidTypeException.class, () -> { + this.referenceManager.createUser("John Doe", + 30, + Gender.Male, + 70.5f, + 180, + 70, + 1, + "123 Main St", + "123-456-7890", + "john.doe@example.com", + 0, + "InvalidType"); + }); + } + + @Test + void testInsertUser1() { + UserManager manager = new UserManager(); + manager.insertUser(this.referenceUser1); + manager.insertUser(this.referenceUser2); + + List users = manager.getAllUsers(); + assertEquals(2, users.size()); + assertTrue(users.contains(this.referenceUser1)); + assertTrue(users.contains(this.referenceUser2)); + } + + @Test + void testInsertUser2() { + assertThrows(ExistingEntityConflictException.class, + () -> { this.referenceManager.insertUser(this.referenceUser2); }); + } + + @Test + void testInsertUser3() { + UserManager manager = new UserManager(); + manager.insertUser(this.referenceUser1); + + this.referenceUser2.setEmail(this.referenceUser1.getEmail()); + assertThrows(ExistingEntityConflictException.class, + () -> { this.referenceManager.insertUser(this.referenceUser2); }); + } + + @Test + void testInsertUser4() { + UserManager manager = new UserManager(); + manager.insertUser(this.referenceUser3); + + User copy = this.referenceUser3.clone(); + copy.setEmail("novo-email@gmail.com"); + + assertThrows(ExistingEntityConflictException.class, + () -> { this.referenceManager.insertUser(copy); }); + } + + @Test + void testRemoveUserByCode1() { + this.referenceManager.removeUserByCode(referenceUser2.getCode()); + + List users = this.referenceManager.getAllUsers(); + assertEquals(2, users.size()); + assertTrue(users.contains(this.referenceUser1)); + assertTrue(users.contains(this.referenceUser3)); + } + + @Test + void testRemoveUserByCode2() { + this.referenceManager.removeUserByCode(referenceUser2.getCode()); + + assertTrue(this.referenceManager.existsUserWithEmail(this.referenceUser1.getEmail())); + assertFalse(this.referenceManager.existsUserWithEmail(this.referenceUser2.getEmail())); + assertTrue(this.referenceManager.existsUserWithEmail(this.referenceUser3.getEmail())); + } + + @Test + void testRemoveUserByCode3() { + this.referenceManager.removeUserByCode(referenceUser3.getCode()); + + assertSame(this.referenceUser1, + this.referenceManager.getUserByCode(this.referenceUser1.getCode())); + assertSame(this.referenceUser2, + this.referenceManager.getUserByCode(this.referenceUser2.getCode())); + assertThrows(EntityDoesNotExistException.class, + () -> { this.referenceManager.getUserByCode(this.referenceUser3.getCode()); }); + } + + @Test + void testRemoveUserByCode4() { + UserManager manager = new UserManager(); + manager.insertUser(this.referenceUser1); + manager.insertUser(this.referenceUser2); + + assertThrows(EntityDoesNotExistException.class, + () -> { manager.removeUserByCode(referenceUser3.getCode()); }); + } + + @Test + void testRemoveUserByEmail1() { + this.referenceManager.removeUserByEmail(referenceUser2.getEmail()); + + List users = this.referenceManager.getAllUsers(); + assertEquals(2, users.size()); + assertTrue(users.contains(this.referenceUser1)); + assertTrue(users.contains(this.referenceUser3)); + } + + @Test + void testRemoveUserByEmail2() { + this.referenceManager.removeUserByEmail(referenceUser2.getEmail()); + + assertTrue(this.referenceManager.existsUserWithEmail(this.referenceUser1.getEmail())); + assertFalse(this.referenceManager.existsUserWithEmail(this.referenceUser2.getEmail())); + assertTrue(this.referenceManager.existsUserWithEmail(this.referenceUser3.getEmail())); + } + + @Test + void testRemoveUserByEmail3() { + this.referenceManager.removeUserByEmail(referenceUser3.getEmail()); + + assertSame(this.referenceUser1, + this.referenceManager.getUserByCode(this.referenceUser1.getCode())); + assertSame(this.referenceUser2, + this.referenceManager.getUserByCode(this.referenceUser2.getCode())); + assertThrows(EntityDoesNotExistException.class, + () -> { this.referenceManager.getUserByCode(this.referenceUser3.getCode()); }); + } + + @Test + void testRemoveUserByEmail4() { + this.referenceManager.removeUserByEmail(referenceUser2.getEmail().toUpperCase()); + + List users = this.referenceManager.getAllUsers(); + assertEquals(2, users.size()); + assertTrue(users.contains(this.referenceUser1)); + assertTrue(users.contains(this.referenceUser3)); + } + + @Test + void testRemoveUserByEmail5() { + UserManager manager = new UserManager(); + manager.insertUser(this.referenceUser1); + manager.insertUser(this.referenceUser2); + + assertThrows(EntityDoesNotExistException.class, + () -> { manager.removeUserByEmail(referenceUser3.getEmail()); }); + } + + @Test + void testExistsUserWithEmail1() { + assertTrue(this.referenceManager.existsUserWithEmail(this.referenceUser3.getEmail())); + } + + @Test + void testExistsUserWithEmail2() { + assertTrue(this.referenceManager.existsUserWithEmail(this.referenceUser3.getEmail())); + } + + @Test + void testExistsUserWithEmail3() { + assertTrue(this.referenceManager.existsUserWithEmail( + this.referenceUser1.getEmail().toUpperCase())); + } + + @Test + void testExistsUserWithEmail4() { + assertFalse(this.referenceManager.existsUserWithEmail("inexistente@ats.pt")); + } + + @Test + void testGetUserByCode1() { + assertSame(this.referenceUser1, + this.referenceManager.getUserByCode(this.referenceUser1.getCode())); + } + + @Test + void testGetUserByCode2() { + UserManager manager = new UserManager(); + manager.insertUser(this.referenceUser3); + + assertThrows(EntityDoesNotExistException.class, + () -> { manager.getUserByCode(this.referenceUser2.getCode()); }); + } + + @Test + void testGetUserByEmail1() { + assertSame(this.referenceUser1, + this.referenceManager.getUserByEmail(this.referenceUser1.getEmail())); + } + + @Test + void testGetUserByEmail2() { + assertSame( + this.referenceUser1, + this.referenceManager.getUserByEmail(this.referenceUser1.getEmail().toUpperCase())); + } + + @Test + void testGetUserByEmail3() { + UserManager manager = new UserManager(); + manager.insertUser(this.referenceUser3); + + assertThrows(EntityDoesNotExistException.class, + () -> { manager.getUserByEmail(this.referenceUser2.getEmail()); }); + } + + @Test + void testUpdateUser1() { + this.referenceUser1.setName("Joaquina"); + this.referenceManager.updateUser(this.referenceUser1); + assertSame(this.referenceUser1, + this.referenceManager.getUserByCode(this.referenceUser1.getCode())); + } + + @Test + void testUpdateUser2() { + UserManager manager = new UserManager(); + manager.insertUser(this.referenceUser1); + assertThrows(EntityDoesNotExistException.class, + () -> { manager.updateUser(this.referenceUser2); }); + } + + @Test + void testUpdateUser3() { + this.referenceUser1.setEmail("novo-email@proton.me"); + assertThrows(EntityDoesNotExistException.class, + () -> { this.referenceManager.updateUser(this.referenceUser1); }); + } + + @Test + void testUpdateUser4() { + this.referenceUser1.setEmail(this.referenceUser3.getEmail()); + assertThrows(EntityDoesNotExistException.class, + () -> { this.referenceManager.updateUser(this.referenceUser1); }); + } + + @Test + void testGetActivitiesFromUser1() { + assertEquals(List.of(), + this.referenceManager.getActivitiesFromUser(this.referenceUser1.getEmail())); + } + + @Test + void testGetActivitiesFromUser2() { + this.referenceManager.addActivityToUser(this.referenceUser1.getEmail(), + this.referenceActivity); + assertEquals(List.of(this.referenceActivity), + this.referenceManager.getActivitiesFromUser(this.referenceUser1.getEmail())); + } + + @Test + void testGetActivitiesFromUser3() { + assertThrows(EntityDoesNotExistException.class, + () -> { this.referenceManager.getActivitiesFromUser("EMAIL-INVALIDO@1234"); }); + } + + @Test + void testAddActivityToUser1() { + this.referenceManager.addActivityToUser(this.referenceUser3.getEmail(), + this.referenceActivity); + + assertEquals(0, this.referenceUser1.getListActivities().size()); + assertEquals(0, this.referenceUser2.getListActivities().size()); + assertEquals(1, this.referenceUser3.getListActivities().size()); + } + + @Test + void testAddActivityToUser2() { + this.referenceManager.addActivityToUser(this.referenceUser1.getEmail(), + this.referenceActivity); + this.referenceManager.addActivityToUser(this.referenceUser1.getEmail(), + this.referenceActivity); + + assertEquals(2, this.referenceUser1.getListActivities().size()); + assertEquals(0, this.referenceUser2.getListActivities().size()); + assertEquals(0, this.referenceUser3.getListActivities().size()); + } + + @Test + void testAddActivityToUser3() { + assertThrows(EntityDoesNotExistException.class, () -> { + this.referenceManager.addActivityToUser("", this.referenceActivity); + }); + } + + @Test + void testRemoveActivityFromUser1() { + assertThrows(EntityDoesNotExistException.class, () -> { + this.referenceManager.removeActivityFromUser("", this.referenceActivity.getCode()); + }); + } + + @Test + void testRemoveActivityFromUser2() { + this.referenceManager.removeActivityFromUser(this.referenceUser3.getEmail(), + this.referenceActivity.getCode()); + + assertEquals(0, this.referenceUser1.getListActivities().size()); + assertEquals(0, this.referenceUser2.getListActivities().size()); + assertEquals(0, this.referenceUser3.getListActivities().size()); + } + + @Test + void testRemoveActivityFromUser3() { + this.referenceManager.addActivityToUser(this.referenceUser2.getEmail(), + this.referenceActivity); + this.referenceManager.removeActivityFromUser(this.referenceUser2.getEmail(), + this.referenceActivity.getCode()); + + assertEquals(0, this.referenceUser1.getListActivities().size()); + assertEquals(0, this.referenceUser2.getListActivities().size()); + assertEquals(0, this.referenceUser3.getListActivities().size()); + } + + @Test + void testRemoveActivityFromUser4() { + this.referenceManager.addActivityToUser(this.referenceUser1.getEmail(), + this.referenceActivity); + this.referenceManager.removeActivityFromUser(this.referenceUser1.getEmail(), + UUID.randomUUID()); + + assertEquals(1, this.referenceUser1.getListActivities().size()); + assertEquals(0, this.referenceUser2.getListActivities().size()); + assertEquals(0, this.referenceUser3.getListActivities().size()); + } + + @Test + void testAddActivitiesToUser1() { + this.referenceManager.addActivitiesToUser( + this.referenceUser3.getCode(), + List.of(this.referenceActivity, this.referenceActivity)); + + assertEquals(0, this.referenceUser1.getListActivities().size()); + assertEquals(0, this.referenceUser2.getListActivities().size()); + assertEquals(2, this.referenceUser3.getListActivities().size()); + } + + @Test + void testAddActivitiesToUser2() { + assertThrows(EntityDoesNotExistException.class, () -> { + this.referenceManager.addActivitiesToUser(UUID.randomUUID(), List.of()); + }); + } + + @Test + void testAddActivitiesToUser3() { + this.referenceManager.addActivitiesToUser(this.referenceUser2.getCode(), List.of()); + + assertEquals(0, this.referenceUser1.getListActivities().size()); + assertEquals(0, this.referenceUser2.getListActivities().size()); + assertEquals(0, this.referenceUser3.getListActivities().size()); + } + + @Test + void testAddActivitiesToUser4() { + this.referenceManager.addActivitiesToUser( + this.referenceUser2.getCode(), + List.of(this.referenceActivity, this.referenceActivity)); + this.referenceManager.addActivitiesToUser( + this.referenceUser2.getCode(), + List.of(this.referenceActivity, this.referenceActivity)); + + assertEquals(0, this.referenceUser1.getListActivities().size()); + assertEquals(4, this.referenceUser2.getListActivities().size()); + assertEquals(0, this.referenceUser3.getListActivities().size()); + } + + @Test + void testUpdateSystem() { + assertTrue(this.referenceActivity.getCaloricWaste() == 0); + + this.referenceManager.addActivityToUser(this.referenceUser3.getEmail(), + this.referenceActivity); + this.referenceManager.updateSystem(); + + Activity newActivity = + this.referenceManager.getActivitiesFromUser(this.referenceUser3.getEmail()).get(0); + + assertEquals("PushUp", ((Professional) this.referenceUser3).getSpecialization()); + assertTrue(newActivity.getCaloricWaste() > 0); + } +} diff --git a/src/unittests/java/MakeItFit/users/UserTest.java b/src/unittests/java/MakeItFit/users/UserTest.java new file mode 100644 index 0000000..1b6dd73 --- /dev/null +++ b/src/unittests/java/MakeItFit/users/UserTest.java @@ -0,0 +1,437 @@ +package MakeItFit.users; + +import java.util.List; +import java.util.UUID; + +import MakeItFit.activities.Activity; +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +public class UserTest { + // A simple stub to test some unreachable code + private class UserStub extends User { + public UserStub() { + super(); + } + + public UserStub(UserStub user) { + super(user); + } + + public User clone() { + return new UserStub(this); + } + } + + UserStub referenceUser; + PushUp referenceActivity; + + @BeforeEach + public void initializeReferenceUser() { + this.referenceUser = new UserStub(); + this.referenceActivity = + new PushUp(this.referenceUser.getCode(), new MakeItFitDate(), 1, "", "", 1, 1); + } + + @Test + public void testConstructorSimpleFields() { + assertEquals("", this.referenceUser.getName()); + assertEquals(0, this.referenceUser.getAge()); + assertEquals(Gender.Other, this.referenceUser.getGender()); + assertEquals(1.0f, this.referenceUser.getWeight()); + assertEquals(1, this.referenceUser.getHeight()); + assertEquals(1, this.referenceUser.getBpm()); + assertEquals(0, this.referenceUser.getLevel()); + assertEquals("", this.referenceUser.getAddress()); + assertEquals("", this.referenceUser.getPhone()); + assertEquals("", this.referenceUser.getEmail()); + } + + @Test + public void testConstructorActivities() { + assertEquals(List.of(), this.referenceUser.getListActivities()); + } + + @Test + public void testCopyConstructorEquals() { + assertEquals(this.referenceUser, new UserStub(this.referenceUser)); + } + + @Test + public void testCopyConstructorCode() { + // equals() does not test for equal code + assertEquals(this.referenceUser.getCode(), (new UserStub(this.referenceUser)).getCode()); + } + + // TODO + // @Test(expected = IllegalArgumentException.class) + public void testGetIndex() { + // assertTrue(Float.isNaN(this.referenceUser.getIndex())); + } + + @Test + public void testSetAge1() { + this.referenceUser.setAge(20); + assertEquals(20, this.referenceUser.getAge()); + } + + @Test + public void testSetAge2() { + this.referenceUser.setAge(0); + assertEquals(0, this.referenceUser.getAge()); + } + + @Test + public void testSetAge3() { + assertThrows(IllegalArgumentException.class, () -> { this.referenceUser.setAge(-1); }); + } + + @Test + public void testSetWeight1() { + this.referenceUser.setWeight(50.0f); + assertEquals(50.0f, this.referenceUser.getWeight()); + } + + @Test + public void testSetWeight2() { + this.referenceUser.setWeight(0.0f); + assertEquals(0.0f, this.referenceUser.getWeight()); + } + + @Test + public void testSetWeight3() { + assertThrows(IllegalArgumentException.class, + () -> { this.referenceUser.setWeight(-1.0f); }); + } + + @Test + public void testSetHeight1() { + this.referenceUser.setHeight(160); + assertEquals(160, this.referenceUser.getHeight()); + } + + @Test + public void testSetHeight2() { + this.referenceUser.setHeight(0); + assertEquals(0, this.referenceUser.getHeight()); + } + + @Test + public void testSetHeight3() { + assertThrows(IllegalArgumentException.class, () -> { this.referenceUser.setHeight(-1); }); + } + + @Test + public void testSetBpm1() { + this.referenceUser.setBpm(65); + assertEquals(65, this.referenceUser.getBpm()); + } + + @Test + public void testSetBpm2() { + this.referenceUser.setBpm(0); + assertEquals(0, this.referenceUser.getBpm()); + } + + @Test + public void testSetBpm3() { + assertThrows(IllegalArgumentException.class, () -> { this.referenceUser.setBpm(-1); }); + } + + @Test + public void testGetActivitiesComposition1() { + List list1 = this.referenceUser.getListActivities(); + List list2 = this.referenceUser.getListActivities(); + + assertNotSame(list1, list2); + assertEquals(list1, list2); + } + + @Test + public void testGetActivitiesComposition2() { + this.referenceUser.addActivity(this.referenceActivity); + + List list1 = this.referenceUser.getListActivities(); + List list2 = this.referenceUser.getListActivities(); + + assertNotSame(list1.get(0), list2.get(0)); + assertEquals(list1.get(0), list2.get(0)); + } + + @Test + public void testAddActivity1() { + this.referenceUser.addActivity(this.referenceActivity); + + List activities = this.referenceUser.getListActivities(); + + assertEquals(1, activities.size()); + assertEquals(activities.get(0).getCode(), this.referenceActivity.getCode()); + } + + @Test + public void testAddActivity2() { + this.referenceUser.addActivity(this.referenceActivity); + this.referenceActivity.setDesignation("changed"); + + List activities = this.referenceUser.getListActivities(); + assertNotEquals(activities.get(0).getDesignation(), + this.referenceActivity.getDesignation()); + } + + @Test + public void testAddActivities1() { + this.referenceUser.addActivity(this.referenceActivity); + + List activities = this.referenceUser.getListActivities(); + + assertEquals(1, activities.size()); + assertEquals(activities.get(0).getCode(), this.referenceActivity.getCode()); + } + + @Test + public void testAddActivities2() { + this.referenceUser.addActivities(List.of(this.referenceActivity)); + this.referenceActivity.setDesignation("changed"); + + List activities = this.referenceUser.getListActivities(); + assertNotEquals(activities.get(0).getDesignation(), + this.referenceActivity.getDesignation()); + } + + @Test + public void testRemoveActivity1() { + assertDoesNotThrow(() -> { this.referenceUser.removeActivity(UUID.randomUUID()); }); + } + + @Test + public void testRemoveActivity2() { + this.referenceUser.addActivity(this.referenceActivity); + this.referenceUser.addActivity(this.referenceActivity); + + this.referenceUser.removeActivity(this.referenceActivity.getCode()); + assertEquals(List.of(), this.referenceUser.getListActivities()); + } + + @Test + public void testRemoveActivity3() { + PushUp newActivity = + new PushUp(this.referenceUser.getCode(), new MakeItFitDate(), 1, "", "", 1, 1); + + this.referenceUser.addActivity(this.referenceActivity); + this.referenceUser.addActivity(newActivity); + + this.referenceUser.removeActivity(this.referenceActivity.getCode()); + assertEquals(List.of(newActivity), this.referenceUser.getListActivities()); + } + + @Test + public void updateActivities() { + this.referenceUser.setWeight(80.0f); + this.referenceUser.setHeight(180); + this.referenceUser.addActivity(this.referenceActivity); + this.referenceUser.addActivity(this.referenceActivity); + + this.referenceUser.updateActivities(); + + List activities = this.referenceUser.getListActivities(); + assertNotEquals(0, activities.get(0).getCaloricWaste()); + assertNotEquals(0, activities.get(1).getCaloricWaste()); + } + + @Test + public void testCalculateIndex1() { + float index = (new UserStub()).calculateIndex(70.0f, 180, 90); + assertEquals(23.85f, index, 0.01f); + } + + @Test + public void testCalculateIndex2() { + float index = (new UserStub()).calculateIndex(60.0f, 150, 100); + assertEquals(29.16f, index, 0.01f); + } + + @Test + public void testCalculateIndex3() { + assertThrows(IllegalArgumentException.class, + () -> { (new UserStub()).calculateIndex(-0.1f, 150, 60); }); + } + + @Test + public void testCalculateIndex4() { + assertThrows(IllegalArgumentException.class, + () -> { (new UserStub()).calculateIndex(0.0f, 150, 60); }); + } + + @Test + public void testCalculateIndex5() { + float index = (new UserStub()).calculateIndex(0.1f, 150, 100); + assertEquals(2.54, index, 0.01f); + } + + @Test + public void testCalculateIndex6() { + assertThrows(IllegalArgumentException.class, + () -> { (new UserStub()).calculateIndex(100.0f, 0, 60); }); + } + + @Test + public void testCalculateIndex7() { + assertThrows(IllegalArgumentException.class, + () -> { (new UserStub()).calculateIndex(100.0f, -1, 60); }); + } + + @Test + public void testCalculateIndex8() { + float index = (new UserStub()).calculateIndex(60.0f, 1, 100); + assertEquals(600002.5f, index, 0.01f); + } + + @Test + public void testCalculateIndex9() { + assertThrows(IllegalArgumentException.class, + () -> { (new UserStub()).calculateIndex(100.0f, 150, 0); }); + } + + @Test + public void testCalculateIndex10() { + assertThrows(IllegalArgumentException.class, + () -> { (new UserStub()).calculateIndex(100.0f, 150, -1); }); + } + + @Test + public void testCalculateIndex11() { + float index = (new UserStub()).calculateIndex(60.0f, 150, 1); + assertEquals(26.69f, index, 0.01f); + } + + @Test + public void testEquals1() { + assertEquals(this.referenceUser, this.referenceUser); + } + + @Test + public void testEquals2() { + assertNotEquals(this.referenceUser, null); + } + + @Test + public void testEquals4() { + User copy = new UserStub(this.referenceUser); + copy.setName("a"); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals5() { + User copy = new UserStub(this.referenceUser); + copy.setAge(1); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals6() { + User copy = new UserStub(this.referenceUser); + copy.setGender(Gender.Female); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals7() { + User copy = new UserStub(this.referenceUser); + copy.setWeight(0.1f); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals8() { + User copy = new UserStub(this.referenceUser); + copy.setHeight(2); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals9() { + User copy = new UserStub(this.referenceUser); + copy.setBpm(2); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals10() { + User copy = new UserStub(this.referenceUser); + copy.setLevel(10); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals11() { + User copy = new UserStub(this.referenceUser); + copy.setAddress("Casa"); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals12() { + User copy = new UserStub(this.referenceUser); + copy.setPhone("112"); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals13() { + User copy = new UserStub(this.referenceUser); + copy.setEmail("abc@def.com"); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals14() { + User copy = new UserStub(this.referenceUser); + copy.addActivity(this.referenceActivity); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testCompareTo1() { + this.referenceUser.setName("a"); + + User copy = new UserStub(this.referenceUser); + assertEquals(0, this.referenceUser.compareTo(copy)); + } + + @Test + public void testCompareTo2() { + this.referenceUser.setName("a"); + + User copy = new UserStub(this.referenceUser); + copy.setName("b"); + assertTrue(this.referenceUser.compareTo(copy) < 0); + } + + @Test + public void testCompareTo3() { + this.referenceUser.setName("a"); + + User copy = new UserStub(this.referenceUser); + copy.setName("A"); + assertTrue(this.referenceUser.compareTo(copy) > 0); + } + + @Test + public void testCompareTo4() { + User copy = new UserStub(this.referenceUser); + this.referenceUser.setAge(10); + assertTrue(this.referenceUser.compareTo(copy) > 0); + } + + @Test + public void testCompareTo5() { + User copy = new UserStub(this.referenceUser); + copy.setAge(1); + assertTrue(this.referenceUser.compareTo(copy) < 0); + } +} diff --git a/src/unittests/java/MakeItFit/users/types/AmateurTest.java b/src/unittests/java/MakeItFit/users/types/AmateurTest.java new file mode 100644 index 0000000..9a38200 --- /dev/null +++ b/src/unittests/java/MakeItFit/users/types/AmateurTest.java @@ -0,0 +1,189 @@ +package MakeItFit.users.types; + +import java.util.List; + +import MakeItFit.users.Gender; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +public class AmateurTest { + Amateur referenceUser; + + @BeforeEach + public void initializeReferenceUser() { + this.referenceUser = new Amateur("João", + 30, + Gender.Male, + 80.5f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com"); + } + + @Test + public void testConstructorSimpleFields() { + assertEquals("João", this.referenceUser.getName()); + assertEquals(30, this.referenceUser.getAge()); + assertEquals(Gender.Male, this.referenceUser.getGender()); + assertEquals(80.5f, this.referenceUser.getWeight()); + assertEquals(180, this.referenceUser.getHeight()); + assertEquals(70, this.referenceUser.getBpm()); + assertEquals(0, this.referenceUser.getLevel()); + assertEquals("Casa", this.referenceUser.getAddress()); + assertEquals("+351 123", this.referenceUser.getPhone()); + assertEquals("abc@def.com", this.referenceUser.getEmail()); + } + + @Test + public void testConstructorActivities() { + assertEquals(List.of(), this.referenceUser.getListActivities()); + } + + @Test + public void testConstructorInvalidFields1() { + assertThrows(IllegalArgumentException.class, () -> { + new Amateur("João", + -1, + Gender.Male, + 65.0f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com"); + }); + } + + @Test + public void testConstructorInvalidFields2() { + assertThrows(IllegalArgumentException.class, () -> { + new Amateur("João", + 30, + Gender.Male, + -0.1f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com"); + }); + } + + @Test + public void testConstructorInvalidFields3() { + assertThrows(IllegalArgumentException.class, () -> { + new Amateur("João", + 30, + Gender.Male, + 1.0f, + -1, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com"); + }); + } + + @Test + public void testConstructorInvalidFields4() { + assertThrows(IllegalArgumentException.class, () -> { + new Amateur("João", 30, Gender.Male, 1.0f, 1, -1, 0, "Casa", "+351 123", "abc@def.com"); + }); + } + + @Test + public void testConstructorInvalidFields5() { + assertThrows(IllegalArgumentException.class, () -> { + new Amateur("João", + 30, + Gender.Male, + 1.0f, + 1, + 70, + -1, + "Casa", + "+351 123", + "abc@def.com"); + }); + } + + @Test + public void testCloneEquals() { + assertEquals(this.referenceUser, this.referenceUser.clone()); + } + + @Test + public void testCloneCode() { + // equals() does not test for equal code + assertEquals(this.referenceUser.getCode(), this.referenceUser.clone().getCode()); + } + + @Test + public void testEquals1() { + assertEquals(this.referenceUser, this.referenceUser); + } + + @Test + public void testEquals2() { + assertNotEquals(this.referenceUser, null); + } + + @Test + public void testEquals3() { + Amateur user1 = new Amateur("João", + 30, + Gender.Male, + 80.5f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com"); + + Professional user2 = new Professional("João", + 30, + Gender.Male, + 80.5f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com", + 0); + + assertNotEquals(user1, user2); + } + + @Test + public void testToString() { + // clang-format off + String format = "== (User details) ==\n"+ + "Code: %s\n"+ + "Name: João\n"+ + "Age: 30\n"+ + "Gender: Male\n"+ + "Weight: 80.50 kg\n"+ + "Height: 180 cm\n"+ + "Bpm: 70\n"+ + "Level: 0\n"+ + "Address: Casa\n"+ + "Phone: +351 123\n"+ + "Email: abc@def.com\n"+ + "Activities: []\n"+ + "====================\n"; + + assertEquals(String.format(format, this.referenceUser.getCode()), + this.referenceUser.toString()); + // clang-format on + } +} diff --git a/src/unittests/java/MakeItFit/users/types/OccasionalTest.java b/src/unittests/java/MakeItFit/users/types/OccasionalTest.java new file mode 100644 index 0000000..abd4c77 --- /dev/null +++ b/src/unittests/java/MakeItFit/users/types/OccasionalTest.java @@ -0,0 +1,188 @@ +package MakeItFit.users.types; + +import java.util.List; + +import MakeItFit.users.Gender; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +public class OccasionalTest { + Occasional referenceUser; + + @BeforeEach + public void initializeReferenceUser() { + this.referenceUser = new Occasional("Maria", + 25, + Gender.Female, + 60.2f, + 165, + 74, + 1, + "Mi casa tu casa", + "+351 456", + "ghi@jkl.com", + 10); + } + + @Test + public void testConstructorSimpleFields() { + assertEquals("Maria", this.referenceUser.getName()); + assertEquals(25, this.referenceUser.getAge()); + assertEquals(Gender.Female, this.referenceUser.getGender()); + assertEquals(60.2f, this.referenceUser.getWeight()); + assertEquals(165, this.referenceUser.getHeight()); + assertEquals(74, this.referenceUser.getBpm()); + assertEquals(1, this.referenceUser.getLevel()); + assertEquals("Mi casa tu casa", this.referenceUser.getAddress()); + assertEquals("+351 456", this.referenceUser.getPhone()); + assertEquals("ghi@jkl.com", this.referenceUser.getEmail()); + assertEquals(10, this.referenceUser.getFrequency()); + } + + @Test + public void testConstructorInvalidFields() { + assertThrows(IllegalArgumentException.class, () -> { + new Occasional("João", + -1, + Gender.Male, + 65.0f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com", + -1); + }); + } + + @Test + public void testConstructorActivities() { + assertEquals(List.of(), this.referenceUser.getListActivities()); + } + + @Test + public void testConstructorInvalidFrequency() { + assertThrows(IllegalArgumentException.class, () -> { + new Occasional("João", + -1, + Gender.Male, + 65.0f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com", + -1); + }); + } + + @Test + public void testSetFrequency1() { + this.referenceUser.setFrequency(4); + assertEquals(4, this.referenceUser.getFrequency()); + } + + @Test + public void testSetFrequency2() { + this.referenceUser.setFrequency(0); + assertEquals(0, this.referenceUser.getFrequency()); + } + + @Test + public void testSetAge3() { + assertThrows(IllegalArgumentException.class, + () -> { this.referenceUser.setFrequency(-1); }); + } + + @Test + public void testCloneEquals() { + assertEquals(this.referenceUser, this.referenceUser.clone()); + } + + @Test + public void testCloneCode() { + // equals() does not test for equal code + assertEquals(this.referenceUser.getCode(), this.referenceUser.clone().getCode()); + } + + @Test + public void testEquals1() { + assertEquals(this.referenceUser, this.referenceUser); + } + + @Test + public void testEquals2() { + assertNotEquals(this.referenceUser, null); + } + + @Test + public void testEquals3() { + Occasional user1 = new Occasional("João", + 30, + Gender.Male, + 80.5f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com", + 5); + + Professional user2 = new Professional("João", + 30, + Gender.Male, + 80.5f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com", + 5); + + assertNotEquals(user1, user2); + } + + @Test + public void testEquals4() { + Occasional copy = new Occasional(this.referenceUser); + copy.setFrequency(1); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals5() { + Occasional copy = new Occasional(this.referenceUser); + copy.setName("Teresa"); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testToString() { + // clang-format off + String format = "== (User details) ==\n"+ + "Code: %s\n"+ + "Name: Maria\n"+ + "Age: 25\n"+ + "Gender: Female\n"+ + "Weight: 60.20 kg\n"+ + "Height: 165 cm\n"+ + "Bpm: 74\n"+ + "Level: 1\n"+ + "Address: Mi casa tu casa\n"+ + "Phone: +351 456\n"+ + "Email: ghi@jkl.com\n"+ + "Activities: []\n"+ + "Frequency: 10\n"+ + "====================\n"; + + assertEquals(String.format(format, this.referenceUser.getCode()), + this.referenceUser.toString()); + // clang-format on + } +} diff --git a/src/unittests/java/MakeItFit/users/types/ProfessionalTest.java b/src/unittests/java/MakeItFit/users/types/ProfessionalTest.java new file mode 100644 index 0000000..0b3d52f --- /dev/null +++ b/src/unittests/java/MakeItFit/users/types/ProfessionalTest.java @@ -0,0 +1,255 @@ +package MakeItFit.users.types; + +import java.util.List; + +import MakeItFit.activities.implementation.PushUp; +import MakeItFit.activities.implementation.Running; +import MakeItFit.users.Gender; +import MakeItFit.utils.MakeItFitDate; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +public class ProfessionalTest { + Professional referenceUser; + PushUp referenceActivity; + + @BeforeEach + public void initializeReferenceUser() { + this.referenceUser = new Professional("Alex", + 40, + Gender.Other, + 65.0f, + 170, + 68, + 1, + "Morada", + "+351 789", + "mno@pqr.com", + 7); + this.referenceActivity = + new PushUp(this.referenceUser.getCode(), new MakeItFitDate(), 1, "", "", 1, 1); + } + + @Test + public void testConstructorSimpleFields() { + assertEquals("Alex", this.referenceUser.getName()); + assertEquals(40, this.referenceUser.getAge()); + assertEquals(Gender.Other, this.referenceUser.getGender()); + assertEquals(65.0f, this.referenceUser.getWeight()); + assertEquals(170, this.referenceUser.getHeight()); + assertEquals(68, this.referenceUser.getBpm()); + assertEquals(1, this.referenceUser.getLevel()); + assertEquals("Morada", this.referenceUser.getAddress()); + assertEquals("+351 789", this.referenceUser.getPhone()); + assertEquals("mno@pqr.com", this.referenceUser.getEmail()); + assertEquals(7, this.referenceUser.getFrequency()); + assertEquals("No specialization", this.referenceUser.getSpecialization()); + } + + @Test + public void testConstructorActivities() { + assertEquals(List.of(), this.referenceUser.getListActivities()); + } + + @Test + public void testSetFrequency1() { + this.referenceUser.setFrequency(4); + assertEquals(4, this.referenceUser.getFrequency()); + } + + @Test + public void testSetFrequency2() { + this.referenceUser.setFrequency(0); + assertEquals(0, this.referenceUser.getFrequency()); + } + + @Test + public void testSetFrequency3() { + assertThrows(IllegalArgumentException.class, + () -> { this.referenceUser.setFrequency(-1); }); + } + + @Test + public void testCloneEquals() { + assertEquals(this.referenceUser, this.referenceUser.clone()); + } + + @Test + public void testCloneCode() { + // equals() does not test for equal code + assertEquals(this.referenceUser.getCode(), this.referenceUser.clone().getCode()); + } + + @Test + public void testUpdateSpecialization1() { + this.referenceUser.updateSpecialization(); + assertEquals("No specialization", this.referenceUser.getSpecialization()); + } + + @Test + public void testUpdateSpecialization2() { + this.referenceUser.addActivity(this.referenceActivity); + this.referenceUser.updateSpecialization(); + assertEquals("PushUp", this.referenceUser.getSpecialization()); + } + + @Test + public void testUpdateSpecialization3() { + this.referenceUser.addActivity(this.referenceActivity); + this.referenceUser.updateSpecialization(); + this.referenceUser.removeActivity(this.referenceActivity.getCode()); + this.referenceUser.updateSpecialization(); + + assertEquals("No specialization", this.referenceUser.getSpecialization()); + } + + @Test + public void testUpdateSpecialization4() { + this.referenceUser.addActivity(this.referenceActivity); + this.referenceUser.addActivity(this.referenceActivity); + this.referenceUser.updateSpecialization(); + + assertEquals("PushUp", this.referenceUser.getSpecialization()); + } + + @Test + public void testUpdateSpecialization5() { + Running newActivity = + new Running(this.referenceUser.getCode(), new MakeItFitDate(), 1, "", "", 1, 1); + + this.referenceUser.addActivity(this.referenceActivity); + this.referenceUser.addActivity(this.referenceActivity); + this.referenceUser.addActivity(newActivity); + this.referenceUser.updateSpecialization(); + + assertEquals("PushUp", this.referenceUser.getSpecialization()); + } + + @Test + public void testUpdateSpecialization6() { + Running newActivity = + new Running(this.referenceUser.getCode(), new MakeItFitDate(), 1, "", "", 1, 1); + + this.referenceUser.addActivity(this.referenceActivity); + this.referenceUser.addActivity(newActivity); + this.referenceUser.addActivity(this.referenceActivity); + this.referenceUser.addActivity(newActivity); + this.referenceUser.addActivity(newActivity); + this.referenceUser.updateSpecialization(); + + assertEquals("Running", this.referenceUser.getSpecialization()); + } + + @Test + public void testEquals1() { + assertEquals(this.referenceUser, this.referenceUser); + } + + @Test + public void testEquals2() { + assertNotEquals(this.referenceUser, null); + } + + @Test + public void testEquals3() { + Professional user1 = new Professional("João", + 30, + Gender.Male, + 80.5f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com", + 5); + + Amateur user2 = new Amateur("João", + 30, + Gender.Male, + 80.5f, + 180, + 70, + 0, + "Casa", + "+351 123", + "abc@def.com"); + + assertNotEquals(user1, user2); + } + + @Test + public void testEquals4() { + Professional copy = new Professional(this.referenceUser); + copy.setFrequency(1); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals5() { + Professional copy = new Professional(this.referenceUser); + copy.setSpecialization("Sedentarismo"); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testEquals6() { + Professional copy = new Professional(this.referenceUser); + copy.setName("Alexa"); + assertNotEquals(this.referenceUser, copy); + } + + @Test + public void testToString1() { + // clang-format off + String format = "== (User details) ==\n"+ + "Code: %s\n"+ + "Name: Alex\n"+ + "Age: 40\n"+ + "Gender: Other\n"+ + "Weight: 65.00 kg\n"+ + "Height: 170 cm\n"+ + "Bpm: 68\n"+ + "Level: 1\n"+ + "Address: Morada\n"+ + "Phone: +351 789\n"+ + "Email: mno@pqr.com\n"+ + "Activities: []\n"+ + "Specialization: No specialization\n"+ + "Frequency: 7\n"+ + "====================\n"; + + assertEquals(String.format(format, this.referenceUser.getCode()), + this.referenceUser.toString()); + // clang-format on + } + + @Test + public void testToString2() { + this.referenceUser.addActivity(this.referenceActivity); + + // clang-format off + String format = "== (User details) ==\n"+ + "Code: %s\n"+ + "Name: Alex\n"+ + "Age: 40\n"+ + "Gender: Other\n"+ + "Weight: 65.00 kg\n"+ + "Height: 170 cm\n"+ + "Bpm: 68\n"+ + "Level: 1\n"+ + "Address: Morada\n"+ + "Phone: +351 789\n"+ + "Email: mno@pqr.com\n"+ + "Activities: [%s]\n"+ + "Specialization: No specialization\n"+ + "Frequency: 7\n"+ + "====================\n"; + + assertEquals(String.format(format, this.referenceUser.getCode(), this.referenceActivity), + this.referenceUser.toString()); + // clang-format on + } +}