diff --git a/src/Tests/UnitTestsEntities/ActivityEntityTests.cs b/src/Tests/UnitTestsEntities/ActivityEntityTests.cs
index ed9c7f0..f505bd7 100644
--- a/src/Tests/UnitTestsEntities/ActivityEntityTests.cs
+++ b/src/Tests/UnitTestsEntities/ActivityEntityTests.cs
@@ -134,5 +134,90 @@ public class ActivityEntityTests (DatabaseFixture fixture) : IClassFixture<Datab
             Assert.Null(deletedActivity);
         }
     }
+
+    [Fact]
+    public void Add_Activity_With_All_Properties_Success()
+    {
+        // Arrange
+        var activity = new ActivityEntity
+        {
+            Type = "Running",
+            Date = new DateOnly(2024, 3, 15),
+            StartTime = new TimeOnly(9, 0),
+            EndTime = new TimeOnly(10, 0),
+            EffortFelt = 7,
+            Variability = 0.5f,
+            Variance = 0.2f,
+            StandardDeviation = 0.3f,
+            Average = 0.4f,
+            Maximum = 200,
+            Minimum = 100,
+            AverageTemperature = 25.5f,
+            HasAutoPause = true,
+            DataSourceId = 1,
+            AthleteId = 1
+        };
+
+        // Act
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.ActivitiesSet.Add(activity);
+            context.SaveChanges();
+        }
+
+        // Assert
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            var savedActivity = context.ActivitiesSet.First(a => a.Type == "Running"  && a.Date == new DateOnly(2024, 3, 15));
+            Assert.NotNull(savedActivity);
+            Assert.Equal("Running", savedActivity.Type);
+            Assert.Equal(new DateOnly(2024, 3, 15), savedActivity.Date);
+            Assert.Equal(new TimeOnly(9, 0), savedActivity.StartTime);
+            Assert.Equal(new TimeOnly(10, 0), savedActivity.EndTime);
+            Assert.Equal(7, savedActivity.EffortFelt);
+            Assert.Equal(0.5f, savedActivity.Variability);
+            Assert.Equal(0.2f, savedActivity.Variance);
+            Assert.Equal(0.3f, savedActivity.StandardDeviation);
+            Assert.Equal(0.4f, savedActivity.Average);
+            Assert.Equal(200, savedActivity.Maximum);
+            Assert.Equal(100, savedActivity.Minimum);
+            Assert.Equal(25.5f, savedActivity.AverageTemperature);
+            Assert.True(savedActivity.HasAutoPause);
+            Assert.Equal(1, savedActivity.DataSourceId);
+            Assert.Equal(1, savedActivity.AthleteId);
+        }
+    }
+
+    // Test for error cases, e.g., null values
+    [Fact]
+    public void Add_Activity_With_Null_Values_Fails()
+    {
+        var activity = new ActivityEntity
+        {
+            Type = null,
+            Date = default, 
+            StartTime = default, 
+            EndTime = default,
+            EffortFelt = 0, 
+            Variability = 0,
+            Variance = 0,
+            StandardDeviation = 0,
+            Average = 0,
+            Maximum = 0, 
+            Minimum = 0, 
+            AverageTemperature = 0,
+            HasAutoPause = false,
+            DataSourceId = 0, 
+            AthleteId = 0 
+        };
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.ActivitiesSet.Add(activity);
+            Assert.Throws<DbUpdateException>(() => context.SaveChanges());
+        }
+    }
 }
 
diff --git a/src/Tests/UnitTestsEntities/AthleteEntityTests.cs b/src/Tests/UnitTestsEntities/AthleteEntityTests.cs
index 10193dc..701f27b 100644
--- a/src/Tests/UnitTestsEntities/AthleteEntityTests.cs
+++ b/src/Tests/UnitTestsEntities/AthleteEntityTests.cs
@@ -117,5 +117,71 @@ public class AthleteEntityTests (DatabaseFixture fixture) : IClassFixture<Databa
             Assert.Null(deletedAthlete);
         }
     }
+
+    [Fact]
+    public void Add_Athlete_With_All_Properties_Success()
+    {
+        var athlete = new AthleteEntity
+        {
+            Username = "john_doe",
+            LastName = "Doe",
+            FirstName = "John",
+            Email = "john.doe@example.com",
+            Sexe = "M",
+            Length = 180.0,
+            Weight = 75.5f,
+            Password = "password",
+            DateOfBirth = new DateOnly(1990, 1, 1),
+            IsCoach = false
+        };
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.AthletesSet.Add(athlete);
+            context.SaveChanges();
+        }
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            var savedAthlete = context.AthletesSet.First(a => a.Username == "john_doe");
+            Assert.NotNull(savedAthlete);
+            Assert.Equal("john_doe", savedAthlete.Username);
+            Assert.Equal("Doe", savedAthlete.LastName);
+            Assert.Equal("John", savedAthlete.FirstName);
+            Assert.Equal("john.doe@example.com", savedAthlete.Email);
+            Assert.Equal("M", savedAthlete.Sexe);
+            Assert.Equal(180.0, savedAthlete.Length);
+            Assert.Equal(75.5f, savedAthlete.Weight);
+            Assert.Equal("password", savedAthlete.Password);
+            Assert.Equal(new DateOnly(1990, 1, 1), savedAthlete.DateOfBirth);
+            Assert.False(savedAthlete.IsCoach);
+        }
+    }
+
+    [Fact]
+    public void Add_Athlete_With_Null_Values_Fails()
+    {
+        var athlete = new AthleteEntity
+        {
+            Username = null,
+            LastName = null,
+            FirstName = null,
+            Email = null,
+            Sexe = null,
+            Length = 0,
+            Weight = 0,
+            Password = null,
+            DateOfBirth = default,
+            IsCoach = false
+        };
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.AthletesSet.Add(athlete);
+            Assert.Throws<DbUpdateException>(() => context.SaveChanges());
+        }
+    }
 }
 
diff --git a/src/Tests/UnitTestsEntities/DataSourceEntityTests.cs b/src/Tests/UnitTestsEntities/DataSourceEntityTests.cs
index 1e0d1e0..925242c 100644
--- a/src/Tests/UnitTestsEntities/DataSourceEntityTests.cs
+++ b/src/Tests/UnitTestsEntities/DataSourceEntityTests.cs
@@ -95,5 +95,50 @@ public class DataSourceEntityTests (DatabaseFixture fixture) : IClassFixture<Dat
             Assert.Null(deletedDataSource);
         }
     }
+
+    [Fact]
+    public void Add_DataSource_With_All_Properties_Success()
+    {
+        var dataSource = new DataSourceEntity
+        {
+            Type = "GPS",
+            Model = "Garmin Forerunner 945",
+            Precision = 0.1f
+        };
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.DataSourcesSet.Add(dataSource);
+            context.SaveChanges();
+        }
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            var savedDataSource = context.DataSourcesSet.First(d => d.Type == "GPS");
+            Assert.NotNull(savedDataSource);
+            Assert.Equal("GPS", savedDataSource.Type);
+            Assert.Equal("Garmin Forerunner 945", savedDataSource.Model);
+            Assert.Equal(0.1f, savedDataSource.Precision);
+        }
+    }
+
+    [Fact]
+    public void Add_DataSource_With_Null_Values_Fails()
+    {
+        var dataSource = new DataSourceEntity
+        {
+            Type = null,
+            Model = null,
+            Precision = 0
+        };
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.DataSourcesSet.Add(dataSource);
+            Assert.Throws<DbUpdateException>(() => context.SaveChanges());
+        }
+    }
 }
 
diff --git a/src/Tests/UnitTestsEntities/HeartRateEntityTests.cs b/src/Tests/UnitTestsEntities/HeartRateEntityTests.cs
index 377d960..baeabc1 100644
--- a/src/Tests/UnitTestsEntities/HeartRateEntityTests.cs
+++ b/src/Tests/UnitTestsEntities/HeartRateEntityTests.cs
@@ -169,5 +169,62 @@ public class HeartRateEntityTests (DatabaseFixture fixture) : IClassFixture<Data
             Assert.Null(deletedHeartRate);
         }
     }
+
+    [Fact]
+    public void Add_HeartRate_With_All_Properties_Success()
+    {
+        // Arrange
+        var activity = new ActivityEntity
+        {
+            Type = "Running",
+            Date = new DateOnly(2024, 3, 15),
+            StartTime = new TimeOnly(9, 0),
+            EndTime = new TimeOnly(10, 0),
+            EffortFelt = 7,
+            Variability = 0.5f,
+            Variance = 0.2f,
+            StandardDeviation = 0.3f,
+            Average = 0.4f,
+            Maximum = 200,
+            Minimum = 100,
+            AverageTemperature = 25.5f,
+            HasAutoPause = true,
+            DataSourceId = 1,
+            AthleteId = 1
+        };
+
+        var heartRateEntry = new HeartRateEntity
+        {
+            Altitude = 100.0,
+            Time = new TimeOnly(9, 30),
+            Temperature = 20.0f,
+            Bpm = 150,
+            Longitude = 45.12345f,
+            Latitude = 35.6789f,
+            Activity = activity
+        };
+
+        // Act
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.ActivitiesSet.Add(activity);
+            context.HeartRatesSet.Add(heartRateEntry);
+            context.SaveChanges();
+        }
+
+        // Assert
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            var savedHeartRate = context.HeartRatesSet.FirstOrDefault(h => h.Altitude == 100.0 && h.Temperature == 20.0f);
+            Assert.NotNull(savedHeartRate);
+            Assert.Equal(100.0, savedHeartRate.Altitude);
+            Assert.Equal(new TimeOnly(9, 30), savedHeartRate.Time);
+            Assert.Equal(20.0f, savedHeartRate.Temperature);
+            Assert.Equal(150, savedHeartRate.Bpm);
+            Assert.Equal(45.12345f, savedHeartRate.Longitude);
+            Assert.Equal(35.6789f, savedHeartRate.Latitude);
+        }
+    }
 }
 
diff --git a/src/Tests/UnitTestsEntities/NotificationEntityTests.cs b/src/Tests/UnitTestsEntities/NotificationEntityTests.cs
index 1fbc3a6..9858911 100644
--- a/src/Tests/UnitTestsEntities/NotificationEntityTests.cs
+++ b/src/Tests/UnitTestsEntities/NotificationEntityTests.cs
@@ -145,5 +145,70 @@ public class NotificationEntityTests (DatabaseFixture fixture) : IClassFixture<D
             Assert.Null(deletedNotification);
         }
     }
+
+    [Fact]
+    public void Add_Notification_With_All_Properties_Success()
+    {
+        var sender = new AthleteEntity
+        {
+            Username = "sender_user",
+            LastName = "Sender",
+            FirstName = "User",
+            Email = "sender.user@example.com",
+            Sexe = "M",
+            Length = 170.0,
+            Weight = 70.0f,
+            Password = "senderpassword",
+            DateOfBirth = new DateOnly(1990, 1, 1),
+            IsCoach = false
+        };
+
+        var notification = new NotificationEntity
+        {
+            Message = "Test notification",
+            Date = DateTime.Now,
+            Statut = false,
+            Urgence = "High",
+            Sender = sender
+        };
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.AthletesSet.Add(sender);
+            context.NotificationsSet.Add(notification);
+            context.SaveChanges();
+        }
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            var savedNotification = context.NotificationsSet.FirstOrDefault(n => n.Message == "Test notification" && n.Statut == false && n.Urgence == "High");
+            Assert.NotNull(savedNotification);
+            Assert.Equal("Test notification", savedNotification.Message);
+            Assert.Equal(DateTime.Today, savedNotification.Date.Date);
+            Assert.False(savedNotification.Statut);
+            Assert.Equal("High", savedNotification.Urgence);
+        }
+    }
+
+    [Fact]
+    public void Add_Notification_With_Null_Values_Fails()
+    {
+        var notification = new NotificationEntity
+        {
+            Message = null,
+            Date = default,
+            Statut = false,
+            Urgence = null,
+            Sender = null
+        };
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.NotificationsSet.Add(notification);
+            Assert.Throws<DbUpdateException>(() => context.SaveChanges());
+        }
+    }
 }
 
diff --git a/src/Tests/UnitTestsEntities/StatisticEntityTests.cs b/src/Tests/UnitTestsEntities/StatisticEntityTests.cs
index d466d34..7c1c878 100644
--- a/src/Tests/UnitTestsEntities/StatisticEntityTests.cs
+++ b/src/Tests/UnitTestsEntities/StatisticEntityTests.cs
@@ -148,5 +148,55 @@ public class StatisticEntityTests (DatabaseFixture fixture) : IClassFixture<Data
             Assert.Null(deletedStatistic);
         }
     }
+
+    [Fact]
+    public void Add_Statistic_With_All_Properties_Success()
+    {
+        // Arrange
+        var athlete = new AthleteEntity
+        {
+            Username = "athlete_user",
+            LastName = "Athlete",
+            FirstName = "User",
+            Email = "athlete.user@example.com",
+            Sexe = "M",
+            Length = 170.0,
+            Weight = 70.0f,
+            Password = "athletepassword",
+            DateOfBirth = new DateOnly(1990, 1, 1),
+            IsCoach = false
+        };
+
+        var statistic = new StatisticEntity
+        {
+            Weight = 75.0f,
+            AverageHeartRate = 150.0,
+            MaximumHeartRate = 180.0,
+            AverageCaloriesBurned = 500.0,
+            Date = new DateOnly(2024, 3, 15),
+            Athlete = athlete
+        };
+
+        // Act
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.AthletesSet.Add(athlete);
+            context.StatisticsSet.Add(statistic);
+            context.SaveChanges();
+        }
+
+        // Assert
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            var savedStatistic = context.StatisticsSet.FirstOrDefault(s => s.AverageHeartRate == 150.0 && s.MaximumHeartRate == 180.0);
+            Assert.NotNull(savedStatistic);
+            Assert.Equal(75.0f, savedStatistic.Weight);
+            Assert.Equal(150.0, savedStatistic.AverageHeartRate);
+            Assert.Equal(180.0, savedStatistic.MaximumHeartRate);
+            Assert.Equal(500.0, savedStatistic.AverageCaloriesBurned);
+            Assert.Equal(new DateOnly(2024, 3, 15), savedStatistic.Date);
+        }
+    }
 }
 
diff --git a/src/Tests/UnitTestsEntities/TrainingEntityTests.cs b/src/Tests/UnitTestsEntities/TrainingEntityTests.cs
index 7503bed..04e8589 100644
--- a/src/Tests/UnitTestsEntities/TrainingEntityTests.cs
+++ b/src/Tests/UnitTestsEntities/TrainingEntityTests.cs
@@ -196,4 +196,90 @@ public class TrainingEntityTests (DatabaseFixture fixture) : IClassFixture<Datab
             Assert.Null(deletedTraining);
         }
     }
+
+    [Fact]
+    public void Add_Training_With_All_Properties_Success()
+    {
+        var coach = new AthleteEntity
+        {
+            Username = "coach_user",
+            LastName = "Coach",
+            FirstName = "User",
+            Email = "coach.user@example.com",
+            Sexe = "M",
+            Length = 180.0,
+            Weight = 75.0f,
+            Password = "coachpassword",
+            DateOfBirth = new DateOnly(1985, 5, 15),
+            IsCoach = true
+        };
+
+        var athlete = new AthleteEntity
+        {
+            Username = "athlete_user",
+            LastName = "Athlete",
+            FirstName = "User",
+            Email = "athlete.user@example.com",
+            Sexe = "F",
+            Length = 165.0,
+            Weight = 60.0f,
+            Password = "athletepassword",
+            DateOfBirth = new DateOnly(1990, 3, 20),
+            IsCoach = false
+        };
+
+        var training = new TrainingEntity
+        {
+            Date = new DateOnly(2024, 3, 15),
+            Description = "Training DescriptionAll",
+            Latitude = 40.12345f,
+            Longitude = -74.56789f,
+            FeedBack = "Training feedbackAll",
+            Coach = coach,
+            Athletes = { athlete }
+        };
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.AthletesSet.Add(coach);
+            context.AthletesSet.Add(athlete);
+            context.TrainingsSet.Add(training);
+            context.SaveChanges();
+        }
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            var savedTraining = context.TrainingsSet.FirstOrDefault(t => t.Description == "Training DescriptionAll" && t.FeedBack == "Training feedbackAll");
+            Assert.NotNull(savedTraining);
+            Assert.Equal(new DateOnly(2024, 3, 15), savedTraining.Date);
+            Assert.Equal("Training DescriptionAll", savedTraining.Description);
+            Assert.Equal(40.12345f, savedTraining.Latitude);
+            Assert.Equal(-74.56789f, savedTraining.Longitude);
+            Assert.Equal("Training feedbackAll", savedTraining.FeedBack);
+        }
+    }
+
+    [Fact]
+    public void Add_Training_With_Null_Values_Fails()
+    {
+        var training = new TrainingEntity
+        {
+            Date = default,
+            Description = null,
+            Latitude = 45,
+            Longitude = 45,
+            FeedBack = null,
+            Coach = null,
+            Athletes = null 
+        };
+
+        using (var context = new TrainingStubbedContext(fixture._options))
+        {
+            context.Database.EnsureCreated();
+            context.TrainingsSet.Add(training);
+            Assert.Throws<DbUpdateException>(() => context.SaveChanges());
+        }
+    }
+
 }