HeartDev
/
API
6
1
Fork 0
Code Issues 6 Pull Requests Packages Projects 1 Releases Wiki Activity

✅ Add model's tests
continuous-integration/drone/push Build is failing Details

Browse Source
WORK-KMO2
Antoine PEREDERII 1 year ago
parent 9142dc8cef
commit 72b35b38a2
12 changed files with 527 additions and 145 deletions
Show Stats Download Patch File Download Diff File

280
src/Tests/UnitTestsModel/ActivityTest.cs
Unescape View File

@ -1,152 +1,166 @@
//-----------------------------------------------------------------------
// FILENAME: ActivityTests.cs
// PROJECT: UnitTestsModel
// DATE CREATED: 16/03/2024
// AUTHOR: HeartTeam
// PURPOSE: Contains unit tests for the Activity class in the Model namespace.
//-----------------------------------------------------------------------
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using Model; using Model;
using Xunit; using Xunit;
namespace UnitTestsModel; namespace UnitTestsModel
public class ActivityTests
{ {
[Fact] /// <summary>
public void Constructor_WithValidEffort_SetsEffort() /// Contains unit tests for the <see cref="Activity"/> class.
/// </summary>
public class ActivityTests
{ {
// Arrange /// <summary>
var date = DateTime.Now; /// Verifies that the constructor sets the effort property correctly when a valid effort is provided.
var validEffort = 3; /// </summary>
[Fact]
public void Constructor_WithValidEffort_SetsEffort()
{
var date = DateTime.Now;
var validEffort = 3;
// Act var activity = new Activity(
var activity = new Activity( id: 1,
id: 1, type: "Running",
type: "Running", date: date,
date: date, startTime: date.AddHours(1),
startTime: date.AddHours(1), endTime: date.AddHours(2),
endTime: date.AddHours(2), effort: validEffort,
effort: validEffort, variability: 0.5f,
variability: 0.5f, variance: 0.3f,
variance: 0.3f, standardDeviation: 0.2f,
standardDeviation: 0.2f, average: 150,
average: 150, maximum: 180,
maximum: 180, minimum: 120,
minimum: 120, averageTemperature: 25.5f,
averageTemperature: 25.5f, hasAutoPause: false,
hasAutoPause: false, user: new User(),
user: new User(), dataSource: new DataSource(1, "Type", "Model", 0.1f, new List<User>(), new List<Activity>()),
dataSource: new DataSource(1, "Type", "Model", 0.1f, new List<User>(), new List<Activity>()), heartRates: null
heartRates: null );
);
// Assert Assert.Equal(validEffort, activity.Effort);
Assert.Equal(validEffort, activity.Effort); }
}
[Fact] /// <summary>
public void Constructor_WithInvalidEffort_ThrowsArgumentException() /// Verifies that the constructor throws an ArgumentException when an invalid effort is provided.
{ /// </summary>
// Arrange [Fact]
var date = DateTime.Now; public void Constructor_WithInvalidEffort_ThrowsArgumentException()
var invalidEffort = 6; {
var date = DateTime.Now;
var invalidEffort = 6;
// Act & Assert Assert.Throws<ArgumentException>(() => new Activity(
Assert.Throws<ArgumentException>(() => new Activity( id: 1,
id: 1, type: "Running",
type: "Running", date: date,
date: date, startTime: date.AddHours(1),
startTime: date.AddHours(1), endTime: date.AddHours(2),
endTime: date.AddHours(2), effort: invalidEffort,
effort: invalidEffort, variability: 0.5f,
variability: 0.5f, variance: 0.3f,
variance: 0.3f, standardDeviation: 0.2f,
standardDeviation: 0.2f, average: 150,
average: 150, maximum: 180,
maximum: 180, minimum: 120,
minimum: 120, averageTemperature: 25.5f,
averageTemperature: 25.5f, hasAutoPause: false,
hasAutoPause: false, user: new User(),
user: new User(), dataSource: new DataSource(1, "Type", "Model", 0.1f, new List<User>(), new List<Activity>()),
dataSource: new DataSource(1, "Type", "Model", 0.1f, new List<User>(), new List<Activity>()), heartRates: null
heartRates: null ));
)); }
}
[Fact] /// <summary>
public void ToString_ReturnsExpectedString() /// Verifies that the ToString method returns the expected string representation of the activity.
{ /// </summary>
// Arrange [Fact]
var date = new DateTime(2023, 3, 16, 10, 0, 0); public void ToString_ReturnsExpectedString()
var activity = new Activity( {
id: 1, var date = new DateTime(2023, 3, 16, 10, 0, 0);
type: "Running", var activity = new Activity(
date: date, id: 1,
startTime: date.AddHours(1), type: "Running",
endTime: date.AddHours(2), date: date,
effort: 3, startTime: date.AddHours(1),
variability: 0.5f, endTime: date.AddHours(2),
variance: 0.3f, effort: 3,
standardDeviation: 0.2f, variability: 0.5f,
average: 150, variance: 0.3f,
maximum: 180, standardDeviation: 0.2f,
minimum: 120, average: 150,
averageTemperature: 25.5f, maximum: 180,
hasAutoPause: false, minimum: 120,
user: new User(), averageTemperature: 25.5f,
dataSource: new DataSource(1, "Type", "Model", 0.1f, new List<User>(), new List<Activity>()), hasAutoPause: false,
heartRates: null user: new User(),
); dataSource: new DataSource(1, "Type", "Model", 0.1f, new List<User>(), new List<Activity>()),
heartRates: null
);
// Act var result = activity.ToString();
var result = activity.ToString();
// Assert Assert.Contains("Activity #1: Running on 16/3/2023 from 11:00:00 to 12:00:00", result);
Assert.Contains("Activity #1: Running on 16/3/2023 from 11:00:00 to 12:00:00", result); }
}
[Fact] /// <summary>
public void Constructor_SetsPropertiesCorrectly() /// Verifies that the constructor sets all properties correctly.
{ /// </summary>
// Arrange [Fact]
var date = DateTime.Now; public void Constructor_SetsPropertiesCorrectly()
var user = new User(); {
var dataSource = new DataSource(1, "Type", "Model", 0.1f, new List<User>(), new List<Activity>()); var date = DateTime.Now;
var heartRates = new List<HeartRate>(); var user = new User();
var dataSource = new DataSource(1, "Type", "Model", 0.1f, new List<User>(), new List<Activity>());
var heartRates = new List<HeartRate>();
// Act var activity = new Activity(
var activity = new Activity( id: 1,
id: 1, type: "Running",
type: "Running", date: date,
date: date, startTime: date.AddHours(1),
startTime: date.AddHours(1), endTime: date.AddHours(2),
endTime: date.AddHours(2), effort: 3,
effort: 3, variability: 0.5f,
variability: 0.5f, variance: 0.3f,
variance: 0.3f, standardDeviation: 0.2f,
standardDeviation: 0.2f, average: 150,
average: 150, maximum: 180,
maximum: 180, minimum: 120,
minimum: 120, averageTemperature: 25.5f,
averageTemperature: 25.5f, hasAutoPause: false,
hasAutoPause: false, user: user,
user: user, dataSource: dataSource,
dataSource: dataSource, heartRates: heartRates
heartRates: heartRates );
);
// Assert Assert.Equal(1, activity.Id);
Assert.Equal(1, activity.Id); Assert.Equal("Running", activity.Type);
Assert.Equal("Running", activity.Type); Assert.Equal(date, activity.Date);
Assert.Equal(date, activity.Date); Assert.Equal(date.AddHours(1), activity.StartTime);
Assert.Equal(date.AddHours(1), activity.StartTime); Assert.Equal(date.AddHours(2), activity.EndTime);
Assert.Equal(date.AddHours(2), activity.EndTime); Assert.Equal(3, activity.Effort);
Assert.Equal(3, activity.Effort); Assert.Equal(0.5f, activity.Variability);
Assert.Equal(0.5f, activity.Variability); Assert.Equal(0.3f, activity.Variance);
Assert.Equal(0.3f, activity.Variance); Assert.Equal(0.2f, activity.StandardDeviation);
Assert.Equal(0.2f, activity.StandardDeviation); Assert.Equal(150, activity.Average);
Assert.Equal(150, activity.Average); Assert.Equal(180, activity.Maximum);
Assert.Equal(180, activity.Maximum); Assert.Equal(120, activity.Minimum);
Assert.Equal(120, activity.Minimum); Assert.Equal(25.5f, activity.AverageTemperature);
Assert.Equal(25.5f, activity.AverageTemperature); Assert.False(activity.HasAutoPause);
Assert.False(activity.HasAutoPause); Assert.Equal(user, activity.Athlete);
Assert.Equal(user, activity.Athlete); Assert.Equal(dataSource, activity.DataSource);
Assert.Equal(dataSource, activity.DataSource); Assert.Equal(heartRates, activity.HeartRates);
Assert.Equal(heartRates, activity.HeartRates); }
}
}
} }

49
src/Tests/UnitTestsModel/AthleteTest.cs
Unescape View File

@ -0,0 +1,49 @@
using Model;
using Xunit;
namespace Model.Tests
{
public class AthleteTests
{
[Fact]
public void CheckAdd_ValidUser_ReturnsTrue()
{
// Arrange
var athlete = new Athlete();
// Act
var user = new User();
var result = athlete.CheckAdd(user);
// Assert
Assert.True(result);
}
[Fact]
public void CheckAdd_NullUser_ReturnsFalse()
{
// Arrange
var athlete = new Athlete();
// Act
var result = athlete.CheckAdd(null);
// Assert
Assert.False(result);
}
[Fact]
public void CheckAdd_NonAthleteUser_ReturnsFalse()
{
// Arrange
var athlete = new Athlete();
// Act
var user = new User { Role = new Coach() }; // Assuming Coach inherits from Role
var result = athlete.CheckAdd(user);
// Assert
Assert.False(result);
}
}
}

49
src/Tests/UnitTestsModel/CoachTest.cs
Unescape View File

@ -0,0 +1,49 @@
using Model;
using Xunit;
namespace Model.Tests
{
public class CoachTests
{
[Fact]
public void CheckAdd_AthleteUser_ReturnsTrue()
{
// Arrange
var coach = new Coach();
// Act
var user = new User { Role = new Athlete() };
var result = coach.CheckAdd(user);
// Assert
Assert.True(result);
}
[Fact]
public void CheckAdd_NonAthleteUser_ReturnsFalse()
{
// Arrange
var coach = new Coach();
// Act
var user = new User { Role = new Coach() };
var result = coach.CheckAdd(user);
// Assert
Assert.False(result);
}
[Fact]
public void CheckAdd_NullUser_ReturnsFalse()
{
// Arrange
var coach = new Coach();
// Act
var result = coach.CheckAdd(null);
// Assert
Assert.False(result);
}
}
}

32
src/Tests/UnitTestsModel/DataSource.cs
Unescape View File

@ -0,0 +1,32 @@
using Model;
using System.Collections.Generic;
using Xunit;
namespace Model.Tests
{
public class DataSourceTests
{
[Fact]
public void Constructor_WithArguments_InitializesProperties()
{
// Arrange
var id = 1;
var type = "Type";
var model = "Model";
var precision = 0.5f;
var athletes = new List<User>();
var activities = new List<Activity>();
// Act
var dataSource = new DataSource(id, type, model, precision, athletes, activities);
// Assert
Assert.Equal(id, dataSource.Id);
Assert.Equal(type, dataSource.Type);
Assert.Equal(model, dataSource.Model);
Assert.Equal(precision, dataSource.Precision);
Assert.Same(athletes, dataSource.Athletes);
Assert.Same(activities, dataSource.Activities);
}
}
}

1
src/Tests/UnitTestsModel/GlobalUsings.cs
Unescape View File

@ -1 +0,0 @@
global using Xunit;

73
src/Tests/UnitTestsModel/HeartRateTest.cs
Unescape View File

@ -0,0 +1,73 @@
using Xunit;
using System;
namespace Model.Tests
{
public class HeartRateTests
{
[Fact]
public void HeartRate_Constructor_WithValidParameters()
{
// Arrange
int id = 1;
int bpm = 80;
TimeOnly timestamp = new TimeOnly(12, 30, 0);
Activity activity = new Activity();
double? latitude = 40.7128;
double? longitude = -74.0060;
double? altitude = 10.5;
int? cadence = 120;
double? distance = 5.2;
double? speed = 10.5;
int? power = 200;
double? temperature = 25.5;
// Act
var heartRate = new HeartRate(id, bpm, timestamp, activity, latitude, longitude, altitude, cadence, distance, speed, power, temperature);
// Assert
Assert.Equal(id, heartRate.Id);
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 HeartRate_ToString_ReturnsExpectedString()
{
// Arrange
int id = 1;
int bpm = 80;
TimeOnly timestamp = new TimeOnly(12, 30, 0);
Activity activity = new Activity();
double? latitude = 40.7128;
double? longitude = -74.0060;
double? altitude = 10.5;
int? cadence = 120;
double? distance = 5.2;
double? speed = 10.5;
int? power = 200;
double? temperature = 25.5;
var heartRate = new HeartRate(id, bpm, timestamp, activity, latitude, longitude, altitude, cadence, distance, speed, power, temperature);
// Act
var result = heartRate.ToString();
// Assert
Assert.Contains($"HeartRate #{id}", result);
Assert.Contains($"{bpm} bpm", result);
Assert.Contains($"{timestamp:HH:mm:ss}", result);
Assert.Contains($"temperature of {temperature}°C", result);
Assert.Contains($"altitude of {altitude}m", result);
Assert.Contains($"at {longitude}°E and {latitude}°N", result);
}
}
}

38
src/Tests/UnitTestsModel/LargeImageTest.cs
Unescape View File

@ -0,0 +1,38 @@
using Xunit;
namespace Model.Tests
{
public class LargeImageTests
{
[Fact]
public void Equals_ReturnsTrue_WhenBase64StringsAreEqual()
{
// Arrange
var base64String = "VGhpcyBpcyBhIGJhc2U2NCBlbmNvZGVkIHN0cmluZw==";
var image1 = new LargeImage(base64String);
var image2 = new LargeImage(base64String);
// Act
var result = image1.Equals(image2);
// Assert
Assert.True(result);
}
[Fact]
public void Equals_ReturnsFalse_WhenBase64StringsAreDifferent()
{
// Arrange
var base64String1 = "VGhpcyBpcyBhIGJhc2U2NCBlbmNvZGVkIHN0cmluZw==";
var base64String2 = "VGhpcyBpcyBhIGJhc2U2NSBlbmNvZGVkIHN0cmluZw==";
var image1 = new LargeImage(base64String1);
var image2 = new LargeImage(base64String2);
// Act
var result = image1.Equals(image2);
// Assert
Assert.False(result);
}
}
}

30
src/Tests/UnitTestsModel/NotificationTest.cs
Unescape View File

@ -0,0 +1,30 @@
using Xunit;
namespace Model.Tests
{
public class NotificationTests
{
[Fact]
public void Constructor_InitializesPropertiesCorrectly()
{
// Arrange
int id = 1;
string message = "Test notification";
DateTime date = DateTime.Now;
bool status = false;
string urgency = "High";
int toUserId = 10;
// Act
var notification = new Notification(id, message, date, status, urgency, toUserId);
// Assert
Assert.Equal(id, notification.IdNotif);
Assert.Equal(message, notification.Message);
Assert.Equal(date, notification.Date);
Assert.Equal(status, notification.Statut);
Assert.Equal(urgency, notification.Urgence);
Assert.Equal(toUserId, notification.ToUserId);
}
}
}

31
src/Tests/UnitTestsModel/RelationshipTest.cs
Unescape View File

@ -0,0 +1,31 @@
using Xunit;
namespace Model.Tests
{
public class RelationshipRequestTests
{
[Fact]
public void Constructor_InitializesPropertiesCorrectly()
{
// Arrange
int id = 1;
int fromUserId = 2;
int toUserId = 3;
string status = "Pending";
// Act
var request = new RelationshipRequest
{
Id = id,
FromUser = fromUserId,
ToUser = toUserId
};
// Assert
Assert.Equal(id, request.Id);
Assert.Equal(fromUserId, request.FromUser);
Assert.Equal(toUserId, request.ToUser);
Assert.Equal(status, request.Status);
}
}
}

36
src/Tests/UnitTestsModel/RoleTest.cs
Unescape View File

@ -0,0 +1,36 @@
using Xunit;
namespace Model.Tests
{
public class RoleTests
{
[Fact]
public void AddUser_WithValidUser_ReturnsTrue()
{
// Arrange
var role = new Athlete(); // Vous pouvez utiliser Athlete ou Coach selon votre besoin
var user = new User(); // Créez un objet User valide
// Act
bool result = role.AddUser(user);
// Assert
Assert.True(result);
}
[Fact]
public void AddUser_WithInvalidUser_ReturnsFalse()
{
// Arrange
var role = new Athlete(); // Vous pouvez utiliser Athlete ou Coach selon votre besoin
var user = new User(); // Créez un objet User invalide
// Act
bool result = role.AddUser(user);
// Assert
Assert.False(result);
}
}
}

10
src/Tests/UnitTestsModel/UnitTest1.cs
Unescape View File

@ -1,10 +0,0 @@
namespace UnitTestsModel;
public class UnitTest1
{
[Fact]
public void Test1()
{
}
}

41
src/Tests/UnitTestsModel/UserTest.cs
Unescape View File

@ -0,0 +1,41 @@
using Xunit;
namespace Model.Tests
{
public class UserTests
{
[Fact]
public void UserConstructor_ValidParameters_ConstructsObject()
{
// Arrange
string username = "john_doe";
string profilePicture = "profile.jpg";
string lastName = "Doe";
string firstName = "John";
string email = "john.doe@example.com";
string password = "password";
string sex = "Male";
float length = 180.5f;
float weight = 75.3f;
DateTime dateOfBirth = new DateTime(1990, 5, 15);
Role role = new Athlete(); // You can change this to the appropriate role
// Act
User user = new User(username, profilePicture, lastName, firstName, email, password, sex, length, weight, dateOfBirth, role);
// Assert
Assert.NotNull(user);
Assert.Equal(username, user.Username);
Assert.Equal(profilePicture, user.ProfilePicture);
Assert.Equal(lastName, user.LastName);
Assert.Equal(firstName, user.FirstName);
Assert.Equal(email, user.Email);
Assert.Equal(password, user.MotDePasse);
Assert.Equal(sex, user.Sexe);
Assert.Equal(length, user.Lenght);
Assert.Equal(weight, user.Weight);
Assert.Equal(dateOfBirth, user.DateOfBirth);
Assert.Equal(role, user.Role);
}
}
}
Write Preview
Loading…
Cancel
Save