Sulley
/
Jarvis
1
0
Fork 0
Code Issues 22 Pull Requests 1 Projects Releases Wiki Activity

Add new tests, fix some tests and update some tests.

This commit is contained in:
Gregory Trullemans 2024-05-19 19:38:21 +02:00
parent ca629fd1fb
commit 2f1a0365e3
8 changed files with 332 additions and 223 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
jarvis/core/tests.py
View File

@ -6,7 +6,7 @@ from django.urls import reverse
USER = get_user_model() USER = get_user_model()
class HomeTests(TestCase): class HomePageTests(TestCase):
def setUp(self): def setUp(self):
self.user = USER.objects.create( self.user = USER.objects.create(
username="jbond", email="james@hms.co.uk", password="007" username="jbond", email="james@hms.co.uk", password="007"

39
jarvis/core/tests_models.py Normal file
View File

@ -0,0 +1,39 @@
from django.test import TestCase
from jarvis.core.models import Citation, Email
import markdown
class CitationModelTests(TestCase):
def test_citation_str(self):
"""Test the __str__ method to ensure it returns the correct string representation of a Citation instance."""
citation = Citation(
quote="Be yourself; everyone else is already taken.",
author="Oscar Wilde"
)
citation.save()
expected_str = "Be yourself; everyone else is already taken. - Oscar Wilde"
self.assertEqual(str(citation), expected_str, "The __str__ method does not return the expected string.")
def test_to_markdown(self):
"""Test the to_markdown method to ensure it correctly converts the quote to Markdown."""
citation = Citation(
quote="**Bold** text and _italic_ text."
)
citation.save()
expected_markdown = markdown.markdown(citation.quote)
self.assertEqual(citation.to_markdown(), expected_markdown, "The to_markdown method does not return the expected Markdown string.")
class EmailModelTests(TestCase):
def test_email_str(self):
"""Test the __str__ method to ensure it returns the correct string representation of an Email instance."""
email = Email(
title="Meeting Reminder",
receivers="john@example.com, jane@example.com"
)
email.save()
expected_str = "`Meeting Reminder` sent to john@example.com, jane@example.com"
self.assertEqual(str(email), expected_str, "The __str__ method does not return the expected string.")

33
jarvis/followup/tests_models.py
View File

@ -36,13 +36,16 @@ class TestModels(TestCase):
Injury.objects.create( Injury.objects.create(
gymnast=gymnast, location=0, injury_type=0, body_side=0, mechanism=0 gymnast=gymnast, location=0, injury_type=0, body_side=0, mechanism=0
) )
WellBeing.objects.create(gymnast=gymnast, mindstate=9, sleep=8, stress=7, fatigue=6, muscle_soreness=5)
def test_chrono_to_string(self): def test_chrono_str(self):
"""Test the __str__ method to ensure it returns the correct string representation of a Chrono instance."""
gymnast = Gymnast.objects.get(last_name="Pauchou") gymnast = Gymnast.objects.get(last_name="Pauchou")
chrono = Chrono.objects.get(gymnast=gymnast) chrono = Chrono.objects.get(gymnast=gymnast)
today = pendulum.now().to_date_string() today = pendulum.now().to_date_string()
print(today)
self.assertEqual(str(chrono), f"Fred Pauchou - 13.000 ({today} - 0)") expected_str = f"{gymnast} - 13.000 ({today} - 0)"
self.assertEqual(str(chrono), expected_str, "The __str__ method does not return the expected string.")
# def test_chrono_timeline_representation(self): # def test_chrono_timeline_representation(self):
# gymnast = Gymnast.objects.get(last_name="Pauchou") # gymnast = Gymnast.objects.get(last_name="Pauchou")
@ -62,3 +65,27 @@ class TestModels(TestCase):
injury = Injury.objects.get(gymnast=gymnast) injury = Injury.objects.get(gymnast=gymnast)
today = pendulum.now().date() today = pendulum.now().date()
self.assertEqual(str(injury), f"Fred Pauchou ({today})") self.assertEqual(str(injury), f"Fred Pauchou ({today})")
def test_get_inversed_stress(self):
"""Test the get_inversed_stress method to ensure it correctly calculates the inversed stress."""
gymnast = Gymnast.objects.get(last_name="Pauchou")
well_being = WellBeing.objects.get(gymnast=gymnast)
inversed_stress = well_being.get_inversed_stress
self.assertEqual(inversed_stress, 3, "The inversed stress should be 3 for a stress value of 7")
def test_get_inversed_fatigue(self):
"""Test the get_inversed_fatigue property to ensure it correctly calculates the inversed fatigue."""
gymnast = Gymnast.objects.get(last_name="Pauchou")
well_being = WellBeing.objects.get(gymnast=gymnast)
inversed_fatigue = well_being.get_inversed_fatigue
self.assertEqual(inversed_fatigue, 4, "The inversed fatigue should be 4 for a fatigue value of 6")
def test_get_inversed_muscle_soreness(self):
"""Test the get_inversed_muscle_soreness property to ensure it correctly calculates the inversed muscle soreness."""
gymnast = Gymnast.objects.get(last_name="Pauchou")
well_being = WellBeing.objects.get(gymnast=gymnast)
inversed_muscle_soreness = well_being.get_inversed_muscle_soreness
self.assertEqual(inversed_muscle_soreness, 5, "The inversed muscle soreness should be 5 for a muscle soreness value of 5")

160
jarvis/followup/views_chrono.py
View File

@ -42,33 +42,35 @@ def jump_chrono_details(request, chrono_id):
Args: Args:
chrono_id (int) identifiant chrono chrono_id (int) identifiant chrono
QTF : Est-ce que je ne devrais pas faire un prefetch_related sur mon objet chrono pour
optimiser mon affichage ?
chrono = Chrono.object.get(pk=chrono_id).prefetch_related('chrono_details') ?
""" """
chrono = get_object_or_404(Chrono, pk=chrono_id) # Using prefetch_related to optimize database access for related details
chrono = get_object_or_404(Chrono.objects.prefetch_related('details'), pk=chrono_id)
# Access control for non-superusers
if not request.user.is_superuser and ( if not request.user.is_superuser and (
request.session.has_key("available_gymnast") request.session.has_key("available_gymnast") and
and chrono.gymnast.id not in request.session["available_gymnast"] chrono.gymnast.id not in request.session["available_gymnast"]
): ):
return chrono_listing(request) return chrono_listing(request)
sum_value = chrono.details.all().aggregate(total=Sum("value")) # Aggregate values from details
details = chrono.details.all()
sum_value = details.aggregate(total=Sum("value"))['total']
mean_value = details.aggregate(mean=Avg("value"))['mean']
min_value = details.aggregate(min=Min("value"))['min']
max_value = details.aggregate(max=Max("value"))['max']
if chrono.score != sum_value["total"]: # Update chrono score if different
chrono.score = sum_value["total"] if chrono.score != sum_value:
chrono.score = sum_value
if chrono.score_type == 0: if chrono.score_type == 0:
chrono.tof = Chrono.compute_tof(sum_value["total"]) chrono.tof = Chrono.compute_tof(sum_value)
chrono.save() chrono.save()
mean_value = chrono.details.all().aggregate(mean=Avg("value"))["mean"] # Calculate chart values
tmp_min_value = chrono.details.all().aggregate(min=Min("value"))["min"] chart_min_value = mean_value - (min_value / 20)
tmp_max_value = chrono.details.all().aggregate(max=Max("value"))["max"] chart_max_value = mean_value + (max_value / 20)
chart_min_value = mean_value - (tmp_min_value / 20)
chart_max_value = mean_value - (tmp_max_value / 20)
context = { context = {
"chrono": chrono, "chrono": chrono,
@ -79,6 +81,38 @@ def jump_chrono_details(request, chrono_id):
return render(request, "chronos/details.html", context) return render(request, "chronos/details.html", context)
# @login_required
# @require_http_methods(["GET"])
# def average_jump_chrono_details_for_gymnast(
# request, gymnast_id, routine_type=1, season=None, week_number=None
# ):
# """Retrieves all the chronos for a gymnast and a type of routine within a specific season and week.
# Args:
# gymnast_id (int) Identifiant d'un gymnaste
# routine_type (int) Type de série (cf. jarvis/followup/models.py > ROUTINE_CHOICE)
# season (string) Saison sous forme "xxxx-xxxy"
# week_number (int) numéro de semaine (1, …, 52)
# """
# if season is None or week_number is None:
# today = pendulum.now().date()
# season, week_number = from_date_to_week_number(today)
# else:
# # Ensure week_number is within the valid range
# week_number = max(1, min(week_number, 52))
# # Ensure season is properly formatted or converted
# season = Season(season).label if isinstance(season, str) else season
# return average_jump_chrono_details_for_season_and_week(
# request,
# gymnast_id,
# routine_type,
# season,
# week_number,
# )
@login_required @login_required
@require_http_methods(["GET"]) @require_http_methods(["GET"])
def average_jump_chrono_details_for_gymnast( def average_jump_chrono_details_for_gymnast(
@ -109,20 +143,32 @@ def average_jump_chrono_details_for_gymnast(
) )
@require_http_methods(["POST"]) @require_http_methods(["POST"])
def remove_jump_chrono_value(request): def remove_jump_chrono_value(request):
""" """
Recoit trois informations permettant de supprimer le chrono d'un saut à un chrono. Receives information to remove a jump time from a Chrono record.
""" """
chrono_id = request.POST.get("chrono_id", None) chrono_id = request.POST.get("chrono_id")
order = request.POST.get("order", None) order = request.POST.get("order")
chrono = get_object_or_404(Chrono, pk=chrono_id)
try:
ChronoDetails.objects.filter(chrono=chrono, order=order).delete()
except Exception:
return HttpResponse(409)
return HttpResponse(200) print("delete jump chrono")
# Validate required parameters
if not chrono_id or not order:
return HttpResponse(400, "Missing required parameters.")
# Retrieve the Chrono object or return 404 if not found
chrono = get_object_or_404(Chrono, pk=chrono_id)
# Attempt to delete the specified ChronoDetails record
deleted, _ = ChronoDetails.objects.filter(chrono=chrono, order=order).delete()
# Check if any records were deleted
if deleted:
return HttpResponse(200) # OK status, deletion successful
return HttpResponse(404, "Chrono detail not found.") # Not found status if no records were deleted
@require_http_methods(["POST"]) @require_http_methods(["POST"])
@ -166,12 +212,10 @@ def jump_chrono_values_create_or_update(request, chrono_id):
""" """
chrono = get_object_or_404(Chrono, pk=chrono_id) chrono = get_object_or_404(Chrono, pk=chrono_id)
jump_list = chrono.details.all()
number_of_jump = jump_list.count()
context = { context = {
"chrono": chrono, "chrono": chrono,
"jump_list": jump_list, "jump_list": chrono.details.all(),
"number_of_jump": number_of_jump, "number_of_jump": jump_list.count(),
"score_type": chrono.score_type, "score_type": chrono.score_type,
} }
return render(request, "chronos/add_details.html", context) return render(request, "chronos/add_details.html", context)
@ -245,15 +289,19 @@ def average_jump_chrono_details_between_two_date(
@require_http_methods(["GET"]) @require_http_methods(["GET"])
def get_chrono_detail_distinct_season(request, gymnast_id): def get_chrono_detail_distinct_season(request, gymnast_id):
"""Récupère toutes les saisons pour lesquelles le gymnaste a des chronos détaillés. """Retrieves all distinct seasons for which the gymnast has detailed chronos.
Args: Args:
gymnast_id (int) Identifiant d'un gymnaste gymnast_id (int) Identifiant d'un gymnaste
""" """
gymnast = get_object_or_404(Gymnast, pk=gymnast_id) # Ensure the gymnast exists
get_object_or_404(Gymnast, pk=gymnast_id)
# Directly query the Chrono model for distinct seasons
season_list = list( season_list = list(
gymnast.chronos.values_list("season", flat=True) Chrono.objects.filter(gymnast_id=gymnast_id)
.distinct("season") .values_list("season", flat=True)
.distinct()
.order_by("season") .order_by("season")
) )
return JsonResponse(season_list, safe=False) return JsonResponse(season_list, safe=False)
@ -261,18 +309,20 @@ def get_chrono_detail_distinct_season(request, gymnast_id):
@require_http_methods(["GET"]) @require_http_methods(["GET"])
def get_chrono_detail_distinct_weeknumber_for_season(request, gymnast_id, season): def get_chrono_detail_distinct_weeknumber_for_season(request, gymnast_id, season):
"""Récupère toutes les week_number pour lesquelles le gymnaste a des chronos détaillés au cours """Retrieves all distinct week numbers for which the gymnast has detailed chronos during a specific season.
d'une saison.
Args: Args:
gymnast_id (int) Identifiant d'un gymnaste gymnast_id (int) Identifiant d'un gymnaste
season (string) Season season (string) Season
""" """
gymnast = get_object_or_404(Gymnast, pk=gymnast_id) # Ensure the gymnast exists
get_object_or_404(Gymnast, pk=gymnast_id)
# Directly query the Chrono model for distinct week numbers in a specific season
weeknumber_list = list( weeknumber_list = list(
gymnast.chronos.values_list("week_number", flat=True) Chrono.objects.filter(gymnast_id=gymnast_id, season=season)
.filter(season=season) .values_list("week_number", flat=True)
.distinct("week_number") .distinct()
.order_by("week_number") .order_by("week_number")
) )
return JsonResponse(weeknumber_list, safe=False) return JsonResponse(weeknumber_list, safe=False)
@ -282,27 +332,27 @@ def get_chrono_detail_distinct_weeknumber_for_season(request, gymnast_id, season
def get_average_jump_chrono_details_for_season_and_week( def get_average_jump_chrono_details_for_season_and_week(
request, gymnast_id, routine_type, season, week_number request, gymnast_id, routine_type, season, week_number
): ):
"""Récupère tout les chronos moyen par saut pour une saison & semaine d'un gymnaste """Retrieves average jump chronos per jump for a season and week for a gymnast.
Args: Args:
gymnast_id (int) Identifiant d'un gymnaste gymnast_id (int) Gymnast ID
routine_type (int) Type de série (cf. jarvis/followup/models.py > ROUTINE_CHOICE) routine_type (int) Type of routine (cf. jarvis/followup/models.py > ROUTINE_CHOICE)
season (string) Season season (string) Season
week_number (int) Numero de la semaine week_number (int) Number of week
""" """
stat_values = list( # Optimize query by directly annotating and ordering in a single query
ChronoDetails.objects.filter( stat_values = ChronoDetails.objects.filter(
chrono__gymnast=gymnast_id, chrono__gymnast=gymnast_id,
chrono__chrono_type=routine_type, chrono__chrono_type=routine_type,
chrono__season=season, chrono__season=season,
chrono__week_number=week_number, chrono__week_number=week_number,
) ).values("order").annotate(avg_score=Avg("value")).order_by("order")
.values("order")
.annotate(avg_score=Avg("value")) # Convert QuerySet to list for JSON serialization
.order_by("order") stat_values_list = list(stat_values)
)
return JsonResponse(stat_values, safe=False) return JsonResponse(stat_values_list, safe=False)
@login_required @login_required

290
jarvis/objective/tests_models.py
View File

@ -5,7 +5,7 @@ from jarvis.objective.models import (
TouchPosition, TouchPosition,
Routine, Routine,
RoutineSkill, RoutineSkill,
Passe, # Passe,
) )
from jarvis.core.global_vars import ROUTINE_TYPE_CHOICE from jarvis.core.global_vars import ROUTINE_TYPE_CHOICE
@ -106,154 +106,154 @@ class ToolsModels(TestCase):
) )
class PasseTestCase(TestCase): # class PasseTestCase(TestCase):
def setUp(self): # def setUp(self):
""" # """
Structure finale : # Structure finale :
1 -> 2 # 1 -> 2
1 -> 6 # 1 -> 6
3 -> 4 -> 5 -> 6 -> 7 # 3 -> 4 -> 5 -> 6 -> 7
1 -> 2 -> 9 # 1 -> 2 -> 9
3 -> 4 -> 5 -> 6 -> 7 -> 9 # 3 -> 4 -> 5 -> 6 -> 7 -> 9
""" # """
# 1 et 3 Eductative sans pre-requis # # 1 et 3 Eductative sans pre-requis
educ_1 = Educative.objects.create( # educ_1 = Educative.objects.create(
long_label="1/2 vrille", difficulty=0.1, level=1, rank=1 # long_label="1/2 vrille", difficulty=0.1, level=1, rank=1
) # )
educ_3 = Educative.objects.create( # educ_3 = Educative.objects.create(
long_label="4 pattes", difficulty=0.1, level=1, rank=1 # long_label="4 pattes", difficulty=0.1, level=1, rank=1
) # )
def test_is_valid_dot(self): # def test_is_valid_dot(self):
arg = "" # arg = ""
self.assertEqual(Passe.is_valid_dot(arg), True) # self.assertEqual(Passe.is_valid_dot(arg), True)
arg = "Q1R1" # arg = "Q1R1"
self.assertEqual(Passe.is_valid_dot(arg), True) # self.assertEqual(Passe.is_valid_dot(arg), True)
arg = ".Q1R1" # arg = ".Q1R1"
self.assertEqual(Passe.is_valid_dot(arg), True) # self.assertEqual(Passe.is_valid_dot(arg), True)
arg = "Q1R1." # arg = "Q1R1."
self.assertEqual(Passe.is_valid_dot(arg), True) # self.assertEqual(Passe.is_valid_dot(arg), True)
arg = "Q1.R1" # arg = "Q1.R1"
self.assertEqual(Passe.is_valid_dot(arg), False) # self.assertEqual(Passe.is_valid_dot(arg), False)
arg = ".Q1.R1." # arg = ".Q1.R1."
self.assertEqual(Passe.is_valid_dot(arg), False) # self.assertEqual(Passe.is_valid_dot(arg), False)
def test_is_valid_subset(self): # def test_is_valid_subset(self):
subset = "" # subset = ""
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "[2-8]" # subset = "[2-8]"
self.assertEqual(Passe.is_valid_subset(subset), True) # self.assertEqual(Passe.is_valid_subset(subset), True)
subset = "[2--8]" # subset = "[2--8]"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "[-5]" # subset = "[-5]"
self.assertEqual(Passe.is_valid_subset(subset), True) # self.assertEqual(Passe.is_valid_subset(subset), True)
subset = "[3-]" # subset = "[3-]"
self.assertEqual(Passe.is_valid_subset(subset), True) # self.assertEqual(Passe.is_valid_subset(subset), True)
subset = "[8-2]" # subset = "[8-2]"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "[-]" # subset = "[-]"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "[1-]" # subset = "[1-]"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "[-1]" # subset = "[-1]"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "[4]" # subset = "[4]"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "[6-6]" # subset = "[6-6]"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "4" # subset = "4"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "[6-6" # subset = "[6-6"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "[66]" # subset = "[66]"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "4-8" # subset = "4-8"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "6-]" # subset = "6-]"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "[4-" # subset = "[4-"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "[6" # subset = "[6"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "Q1R1 [4-8]" # subset = "Q1R1 [4-8]"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
subset = "Q1R1 [-8]" # subset = "Q1R1 [-8]"
self.assertEqual(Passe.is_valid_subset(subset), False) # self.assertEqual(Passe.is_valid_subset(subset), False)
def test_is_valid_routine_type(self): # def test_is_valid_routine_type(self):
for item in ROUTINE_TYPE_CHOICE: # for item in ROUTINE_TYPE_CHOICE:
self.assertEqual(Passe.is_valid_routine_type(item[1]), True) # self.assertEqual(Passe.is_valid_routine_type(item[1]), True)
routine_type = "" # routine_type = ""
self.assertEqual(Passe.is_valid_routine_type(routine_type), False) # self.assertEqual(Passe.is_valid_routine_type(routine_type), False)
routine_type = ".Q1R1" # routine_type = ".Q1R1"
self.assertEqual(Passe.is_valid_routine_type(routine_type), False) # self.assertEqual(Passe.is_valid_routine_type(routine_type), False)
routine_type = "SFS." # routine_type = "SFS."
self.assertEqual(Passe.is_valid_routine_type(routine_type), False) # self.assertEqual(Passe.is_valid_routine_type(routine_type), False)
routine_type = "Q1R1 [4-8]" # routine_type = "Q1R1 [4-8]"
self.assertEqual(Passe.is_valid_routine_type(routine_type), False) # self.assertEqual(Passe.is_valid_routine_type(routine_type), False)
routine_type = "SFS [-8]" # routine_type = "SFS [-8]"
self.assertEqual(Passe.is_valid_routine_type(routine_type), False) # self.assertEqual(Passe.is_valid_routine_type(routine_type), False)
def test_is_valid_regexp_one_arg(self): # def test_is_valid_regexp_one_arg(self):
arg = "" # arg = ""
self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) # self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False)
arg = "WC" # arg = "WC"
self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) # self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True)
arg = "1|" # arg = "1|"
self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) # self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True)
arg = ".Q1R1" # arg = ".Q1R1"
self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) # self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True)
arg = "Q1R2." # arg = "Q1R2."
self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) # self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True)
arg = ".Q1R1 [4-8" # arg = ".Q1R1 [4-8"
self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) # self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False)
arg = "Q1R2. [4-8" # arg = "Q1R2. [4-8"
self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) # self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False)
arg = "Q1R1 [4-8]" # arg = "Q1R1 [4-8]"
self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) # self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False)
arg = "Q1R1 [8-4]" # arg = "Q1R1 [8-4]"
self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) # self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False)
def test_is_valid_regexp_two_args(self): # def test_is_valid_regexp_two_args(self):
arg1 = "" # arg1 = ""
arg2 = "" # arg2 = ""
self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) # self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False)
arg1 = "Q1R1" # arg1 = "Q1R1"
self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) # self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False)
arg2 = "[4-8]" # arg2 = "[4-8]"
self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) # self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True)
arg2 = "[8-8]" # arg2 = "[8-8]"
self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) # self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False)
arg2 = "[8-4]" # arg2 = "[8-4]"
self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) # self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False)
arg2 = "[-8]" # arg2 = "[-8]"
self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) # self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True)
arg2 = "[4-]" # arg2 = "[4-]"
self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) # self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True)
arg1 = "Q1R1." # arg1 = "Q1R1."
self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) # self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True)
def test_is_valid_regexp(self): # def test_is_valid_regexp(self):
regexp = "" # regexp = ""
self.assertEqual(Passe.is_valid_regexp(regexp), False) # self.assertEqual(Passe.is_valid_regexp(regexp), False)
regexp = "Q1R1 [4-8]" # regexp = "Q1R1 [4-8]"
self.assertEqual(Passe.is_valid_regexp(regexp), True) # self.assertEqual(Passe.is_valid_regexp(regexp), True)
regexp = "Q1R1 [8-8]" # regexp = "Q1R1 [8-8]"
self.assertEqual(Passe.is_valid_regexp(regexp), False) # self.assertEqual(Passe.is_valid_regexp(regexp), False)
regexp = "Q1R1 [8-4]" # regexp = "Q1R1 [8-4]"
self.assertEqual(Passe.is_valid_regexp(regexp), False) # self.assertEqual(Passe.is_valid_regexp(regexp), False)
regexp = "Q1R1 [-8]" # regexp = "Q1R1 [-8]"
self.assertEqual(Passe.is_valid_regexp(regexp), True) # self.assertEqual(Passe.is_valid_regexp(regexp), True)
regexp = "Q1R1 [4-]" # regexp = "Q1R1 [4-]"
self.assertEqual(Passe.is_valid_regexp(regexp), True) # self.assertEqual(Passe.is_valid_regexp(regexp), True)
regexp = "Q1R1. [4-8]" # regexp = "Q1R1. [4-8]"
self.assertEqual(Passe.is_valid_regexp(regexp), True) # self.assertEqual(Passe.is_valid_regexp(regexp), True)
regexp = "Q1R1. [4-]" # regexp = "Q1R1. [4-]"
self.assertEqual(Passe.is_valid_regexp(regexp), True) # self.assertEqual(Passe.is_valid_regexp(regexp), True)
regexp = ".Q1R1 [-8]" # regexp = ".Q1R1 [-8]"
self.assertEqual(Passe.is_valid_regexp(regexp), True) # self.assertEqual(Passe.is_valid_regexp(regexp), True)
regexp = "Q1R1. [8-8]" # regexp = "Q1R1. [8-8]"
self.assertEqual(Passe.is_valid_regexp(regexp), False) # self.assertEqual(Passe.is_valid_regexp(regexp), False)
regexp = ".Q1R1 [8-4]" # regexp = ".Q1R1 [8-4]"
self.assertEqual(Passe.is_valid_regexp(regexp), False) # self.assertEqual(Passe.is_valid_regexp(regexp), False)

7
jarvis/objective/tests_tools.py
View File

@ -133,7 +133,6 @@ class ToolsTestCase(TestCase):
self.assertEqual(nb_skill_lte_type(4, "level"), 9) self.assertEqual(nb_skill_lte_type(4, "level"), 9)
def test_compute_completude(self): def test_compute_completude(self):
self.assertEqual(compute_completude(10, 1, 4), ("10%", 0)) self.assertEqual(compute_completude(10, 1, 4), ('10%', 0, 10))
self.assertEqual(compute_completude(10, 1, 4), ("10%", 0)) self.assertEqual(compute_completude(10, 5, 4), ('50%', 2, 50))
self.assertEqual(compute_completude(10, 5, 4), ("50%", 2)) self.assertEqual(compute_completude(10, 10, 4), ('100%', 4, 100))
self.assertEqual(compute_completude(10, 10, 4), ("100%", 4))

4
jarvis/tools/tests_date_week_transition.py
View File

@ -61,11 +61,11 @@ class FunctionTestCase(TestCase):
get_number_of_weeks_between( get_number_of_weeks_between(
pendulum.date(2022, 9, 1), pendulum.date(2023, 7, 5) pendulum.date(2022, 9, 1), pendulum.date(2023, 7, 5)
), ),
44, 43,
) )
self.assertEqual( self.assertEqual(
get_number_of_weeks_between( get_number_of_weeks_between(
pendulum.date(2023, 2, 5), pendulum.date(2023, 7, 5) pendulum.date(2023, 2, 5), pendulum.date(2023, 7, 5)
), ),
22, 21,
) )

20
jarvis/tools/tests_models.py
View File

@ -6,33 +6,27 @@ from .models import Season, max_even_if_none
class ModelTestCase(TestCase): class ModelTestCase(TestCase):
def test_init_season(self): def test_init_season(self):
actual_season = Season()
season = Season("2022-2023") season = Season("2022-2023")
self.assertEqual(season.is_valid(), True)
self.assertEqual(season.label, "2022-2023") self.assertEqual(season.label, "2022-2023")
season = Season("2022-2024") season = Season("2022-2024")
self.assertEqual(season.is_valid(), True) self.assertEqual(season.label, actual_season.label)
self.assertEqual(season.label, "2022-2023")
season = Season("2024-2023") season = Season("2024-2023")
self.assertEqual(season.is_valid(), True) self.assertEqual(season.label, actual_season.label)
self.assertEqual(season.label, "2022-2023")
season = Season("1358-5682") season = Season("1358-5682")
self.assertEqual(season.is_valid(), True) self.assertEqual(season.label, actual_season.label)
self.assertEqual(season.label, "2022-2023")
season = Season("fgkrs-gkml") season = Season("fgkrs-gkml")
self.assertEqual(season.is_valid(), True) self.assertEqual(season.label, actual_season.label)
self.assertEqual(season.label, "2022-2023")
season = Season("drgnldsjgklfdtngl") season = Season("drgnldsjgklfdtngl")
self.assertEqual(season.is_valid(), True) self.assertEqual(season.label, actual_season.label)
self.assertEqual(season.label, "2022-2023")
season = Season("12675353878354") season = Season("12675353878354")
self.assertEqual(season.is_valid(), True) self.assertEqual(season.label, actual_season.label)
self.assertEqual(season.label, "2022-2023")
def test_season_is_valid(self): def test_season_is_valid(self):
season = Season("2022-2023") season = Season("2022-2023")