✅ Update model's tests

src/Model/RelationshipRequest.cs

@@ -5,5 +5,5 @@ public class RelationshipRequest  // : Observable
     public int Id { get ; set ; }
     public int FromUser { get ; set; }
     public int ToUser { get; set ; }
-    public string Status { get ; }
+    public required string Status { get ; set; }
 }

src/Tests/UnitTestsModel/ActivityTest.cs

@@ -215,5 +215,40 @@ namespace UnitTestsModel
             Assert.Equal(hasAutoPause, activity.HasAutoPause);
             Assert.Equal(user, activity.Athlete);
         }
+
+        [Fact]
+        public void ToString_ReturnsCorrectStringRepresentation()
+        {
+            var date = DateTime.Now;
+            var user = new User();
+            var dataSource = new DataSource(1, "Type", "Model", 0.1f, new List<User>(), new List<Activity>());
+            var heartRates = new List<HeartRate>();
+
+            var activity = new Activity(
+                id: 1,
+                type: "Running",
+                date: date,
+                startTime: date.AddHours(1),
+                endTime: date.AddHours(2),
+                effort: 3,
+                variability: 0.5f,
+                variance: 0.3f,
+                standardDeviation: 0.2f,
+                average: 150,
+                maximum: 180,
+                minimum: 120,
+                averageTemperature: 25.5f,
+                hasAutoPause: false,
+                user: user,
+                dataSource: dataSource,
+                heartRates: heartRates
+            );
+
+            var result = activity.ToString();
+
+            Console.WriteLine(result);
+
+            Assert.Equal($"Activity #1: Running on {date:d/M/yyyy} from {date.AddHours(1):HH:mm:ss} to {date.AddHours(2):HH:mm:ss} with an effort of 3/5 and an average temperature of 25,5°C and a heart rate variability of 0,5 bpm and a variance of 0,3 bpm and a standard deviation of 0,2 bpm and an average of 150 bpm and a maximum of 180 bpm and a minimum of 120 bpm and auto pause is disabled.", result);
+        }
     }
 }

src/Tests/UnitTestsModel/DataSource.cs

@@ -25,5 +25,17 @@ namespace Model.Tests
             Assert.Same(athletes, dataSource.Athletes);
             Assert.Same(activities, dataSource.Activities);
         }
+
+        [Fact]
+        public void ToString_ReturnsExpectedString()
+        {
+            var athletes = new List<User>();
+            var activities = new List<Activity>();
+            var dataSource = new DataSource("Type", "Model", 0.1f, athletes, activities);
+
+            var result = dataSource.ToString();
+
+            Assert.Equal("DataSource #0: Type Model with a precision of 0,1", result);
+        }
     }
 }

src/Tests/UnitTestsModel/HeartRateTest.cs

@@ -64,5 +64,57 @@ namespace Model.Tests
             Assert.Contains($"altitude of {altitude}m", result);
             Assert.Contains($"at {longitude}°E and {latitude}°N", result);
         }
+        [Fact]
+        public void Constructor_WithAllParameters_ShouldInitializeCorrectly()
+        {
+            int bpm = 70;
+            var timestamp = new TimeOnly(12, 0);
+            var activity = new Activity();
+            double? latitude = 40.7128;
+            double? longitude = -74.0060;
+            double? altitude = 10.0;
+            int? cadence = 80;
+            double? distance = 5.0;
+            double? speed = 10.0;
+            int? power = 200;
+            double? temperature = 20.0;
+
+            var heartRate = new HeartRate(bpm, timestamp, activity, latitude, longitude, altitude, cadence, distance, speed, power, temperature);
+
+            Assert.NotNull(heartRate);
+            Assert.Equal(bpm, heartRate.Bpm);
+            Assert.Equal(timestamp, heartRate.Timestamp);
+            Assert.Equal(activity, heartRate.Activity);
+            Assert.Equal(latitude, heartRate.Latitude);
+            Assert.Equal(longitude, heartRate.Longitude);
+            Assert.Equal(altitude, heartRate.Altitude);
+            Assert.Equal(cadence, heartRate.Cadence);
+            Assert.Equal(distance, heartRate.Distance);
+            Assert.Equal(speed, heartRate.Speed);
+            Assert.Equal(power, heartRate.Power);
+            Assert.Equal(temperature, heartRate.Temperature);
+        }
+
+        [Fact]
+        public void Constructor_WithMinimalParameters_ShouldInitializeCorrectly()
+        {
+            int bpm = 70;
+            var timestamp = new TimeOnly(12, 0);
+
+            var heartRate = new HeartRate(bpm, timestamp, 1, null, null, null, null, null, null, null, null);
+
+            Assert.NotNull(heartRate);
+            Assert.Equal(bpm, heartRate.Bpm);
+            Assert.Equal(timestamp, heartRate.Timestamp);
+            Assert.Null(heartRate.Activity);
+            Assert.Null(heartRate.Latitude);
+            Assert.Null(heartRate.Longitude);
+            Assert.Null(heartRate.Altitude);
+            Assert.Null(heartRate.Cadence);
+            Assert.Null(heartRate.Distance);
+            Assert.Null(heartRate.Speed);
+            Assert.Null(heartRate.Power);
+            Assert.Null(heartRate.Temperature);
+        }
     }
 }

src/Tests/UnitTestsModel/LargeImageTest.cs

@@ -100,5 +100,59 @@ namespace Model.Tests
 
             Assert.Equal(hashCode1, hashCode2);
         }
+
+        [Fact]
+        public void Equals_ReturnsTrue_WhenComparingWithItself()
+        {
+            var largeImage = new LargeImage("base64String");
+
+            var result = largeImage.Equals(largeImage);
+
+            Assert.True(result);
+        }
+
+        [Fact]
+        public void Equals_ReturnsFalse_WhenComparingWithNull()
+        {
+            var largeImage = new LargeImage("base64String");
+
+            var result = largeImage.Equals(null);
+
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void Equals_ReturnsFalse_WhenComparingWithDifferentType()
+        {
+            var largeImage = new LargeImage("base64String");
+            var otherObject = new object();
+
+            var result = largeImage.Equals(otherObject);
+
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void Equals_ReturnsFalse_WhenComparingWithDifferentLargeImage()
+        {
+            var largeImage1 = new LargeImage("base64String1");
+            var largeImage2 = new LargeImage("base64String2");
+
+            var result = largeImage1.Equals(largeImage2);
+
+            Assert.False(result);
+        }
+
+        [Fact]
+        public void Equals_ReturnsTrue_WhenComparingWithEqualLargeImage()
+        {
+            var base64String = "base64String";
+            var largeImage1 = new LargeImage(base64String);
+            var largeImage2 = new LargeImage(base64String);
+
+            var result = largeImage1.Equals(largeImage2);
+
+            Assert.True(result);
+        }
     }
 }

src/Tests/UnitTestsModel/NotificationTest.cs

@@ -23,5 +23,13 @@ namespace Model.Tests
             Assert.Equal(urgency, notification.Urgence);
             Assert.Equal(toUserId, notification.ToUserId);
         }
+
+        [Fact]
+        public void Constructor_DefaultConstructor_ShouldInitializeCorrectly()
+        {
+            var notification = new Notification();
+
+            Assert.NotNull(notification);
+        }
     }
 }

src/Tests/UnitTestsModel/RelationshipTest.cs

@@ -10,17 +10,20 @@ namespace Model.Tests
             int id = 1;
             int fromUserId = 2;
             int toUserId = 3;
+            string status = "Pending";
 
             var request = new RelationshipRequest
             {
                 Id = id,
                 FromUser = fromUserId,
-                ToUser = toUserId
+                ToUser = toUserId,
+                Status = status
             };
 
             Assert.Equal(id, request.Id);
             Assert.Equal(fromUserId, request.FromUser);
             Assert.Equal(toUserId, request.ToUser);
+            Assert.Equal(status, request.Status);
         }
     }
 }