diff --git a/jarvis/core/tests.py b/jarvis/core/tests.py index 850d1f1..50832d0 100644 --- a/jarvis/core/tests.py +++ b/jarvis/core/tests.py @@ -6,7 +6,7 @@ from django.urls import reverse USER = get_user_model() -class HomeTests(TestCase): +class HomePageTests(TestCase): def setUp(self): self.user = USER.objects.create( username="jbond", email="james@hms.co.uk", password="007" diff --git a/jarvis/core/tests_models.py b/jarvis/core/tests_models.py new file mode 100644 index 0000000..fcbe74a --- /dev/null +++ b/jarvis/core/tests_models.py @@ -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.") \ No newline at end of file diff --git a/jarvis/followup/tests_models.py b/jarvis/followup/tests_models.py index 92ab574..8ed1f51 100644 --- a/jarvis/followup/tests_models.py +++ b/jarvis/followup/tests_models.py @@ -36,13 +36,16 @@ class TestModels(TestCase): Injury.objects.create( 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") chrono = Chrono.objects.get(gymnast=gymnast) 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): # gymnast = Gymnast.objects.get(last_name="Pauchou") @@ -62,3 +65,27 @@ class TestModels(TestCase): injury = Injury.objects.get(gymnast=gymnast) today = pendulum.now().date() 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") diff --git a/jarvis/followup/views_chrono.py b/jarvis/followup/views_chrono.py index 25efbd4..3961072 100644 --- a/jarvis/followup/views_chrono.py +++ b/jarvis/followup/views_chrono.py @@ -42,33 +42,35 @@ def jump_chrono_details(request, chrono_id): Args: 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 ( - request.session.has_key("available_gymnast") - and chrono.gymnast.id not in request.session["available_gymnast"] + request.session.has_key("available_gymnast") and + chrono.gymnast.id not in request.session["available_gymnast"] ): 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"]: - chrono.score = sum_value["total"] + # Update chrono score if different + if chrono.score != sum_value: + chrono.score = sum_value if chrono.score_type == 0: - chrono.tof = Chrono.compute_tof(sum_value["total"]) + chrono.tof = Chrono.compute_tof(sum_value) chrono.save() - mean_value = chrono.details.all().aggregate(mean=Avg("value"))["mean"] - tmp_min_value = chrono.details.all().aggregate(min=Min("value"))["min"] - tmp_max_value = chrono.details.all().aggregate(max=Max("value"))["max"] - chart_min_value = mean_value - (tmp_min_value / 20) - chart_max_value = mean_value - (tmp_max_value / 20) + # Calculate chart values + chart_min_value = mean_value - (min_value / 20) + chart_max_value = mean_value + (max_value / 20) context = { "chrono": chrono, @@ -79,6 +81,38 @@ def jump_chrono_details(request, chrono_id): 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 @require_http_methods(["GET"]) def average_jump_chrono_details_for_gymnast( @@ -109,20 +143,32 @@ def average_jump_chrono_details_for_gymnast( ) + @require_http_methods(["POST"]) 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) - order = request.POST.get("order", None) - chrono = get_object_or_404(Chrono, pk=chrono_id) - try: - ChronoDetails.objects.filter(chrono=chrono, order=order).delete() - except Exception: - return HttpResponse(409) + chrono_id = request.POST.get("chrono_id") + order = request.POST.get("order") - 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"]) @@ -166,12 +212,10 @@ def jump_chrono_values_create_or_update(request, chrono_id): """ chrono = get_object_or_404(Chrono, pk=chrono_id) - jump_list = chrono.details.all() - number_of_jump = jump_list.count() context = { "chrono": chrono, - "jump_list": jump_list, - "number_of_jump": number_of_jump, + "jump_list": chrono.details.all(), + "number_of_jump": jump_list.count(), "score_type": chrono.score_type, } return render(request, "chronos/add_details.html", context) @@ -245,15 +289,19 @@ def average_jump_chrono_details_between_two_date( @require_http_methods(["GET"]) 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: 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( - gymnast.chronos.values_list("season", flat=True) - .distinct("season") + Chrono.objects.filter(gymnast_id=gymnast_id) + .values_list("season", flat=True) + .distinct() .order_by("season") ) return JsonResponse(season_list, safe=False) @@ -261,18 +309,20 @@ def get_chrono_detail_distinct_season(request, gymnast_id): @require_http_methods(["GET"]) 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 - d'une saison. + """Retrieves all distinct week numbers for which the gymnast has detailed chronos during a specific season. Args: gymnast_id (int) Identifiant d'un gymnaste 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( - gymnast.chronos.values_list("week_number", flat=True) - .filter(season=season) - .distinct("week_number") + Chrono.objects.filter(gymnast_id=gymnast_id, season=season) + .values_list("week_number", flat=True) + .distinct() .order_by("week_number") ) 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( 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: - gymnast_id (int) Identifiant d'un gymnaste - routine_type (int) Type de série (cf. jarvis/followup/models.py > ROUTINE_CHOICE) + gymnast_id (int) Gymnast ID + routine_type (int) Type of routine (cf. jarvis/followup/models.py > ROUTINE_CHOICE) season (string) Season - week_number (int) Numero de la semaine + week_number (int) Number of week """ - stat_values = list( - ChronoDetails.objects.filter( - chrono__gymnast=gymnast_id, - chrono__chrono_type=routine_type, - chrono__season=season, - chrono__week_number=week_number, - ) - .values("order") - .annotate(avg_score=Avg("value")) - .order_by("order") - ) - return JsonResponse(stat_values, safe=False) + # Optimize query by directly annotating and ordering in a single query + stat_values = ChronoDetails.objects.filter( + chrono__gymnast=gymnast_id, + chrono__chrono_type=routine_type, + chrono__season=season, + chrono__week_number=week_number, + ).values("order").annotate(avg_score=Avg("value")).order_by("order") + + # Convert QuerySet to list for JSON serialization + stat_values_list = list(stat_values) + + return JsonResponse(stat_values_list, safe=False) @login_required diff --git a/jarvis/objective/tests_models.py b/jarvis/objective/tests_models.py index 2293333..900f4a5 100644 --- a/jarvis/objective/tests_models.py +++ b/jarvis/objective/tests_models.py @@ -5,7 +5,7 @@ from jarvis.objective.models import ( TouchPosition, Routine, RoutineSkill, - Passe, + # Passe, ) from jarvis.core.global_vars import ROUTINE_TYPE_CHOICE @@ -106,154 +106,154 @@ class ToolsModels(TestCase): ) -class PasseTestCase(TestCase): - def setUp(self): - """ - Structure finale : - 1 -> 2 - 1 -> 6 - 3 -> 4 -> 5 -> 6 -> 7 - 1 -> 2 -> 9 - 3 -> 4 -> 5 -> 6 -> 7 -> 9 - """ - # 1 et 3 Eductative sans pre-requis - educ_1 = Educative.objects.create( - long_label="1/2 vrille", difficulty=0.1, level=1, rank=1 - ) - educ_3 = Educative.objects.create( - long_label="4 pattes", difficulty=0.1, level=1, rank=1 - ) +# class PasseTestCase(TestCase): +# def setUp(self): +# """ +# Structure finale : +# 1 -> 2 +# 1 -> 6 +# 3 -> 4 -> 5 -> 6 -> 7 +# 1 -> 2 -> 9 +# 3 -> 4 -> 5 -> 6 -> 7 -> 9 +# """ +# # 1 et 3 Eductative sans pre-requis +# educ_1 = Educative.objects.create( +# long_label="1/2 vrille", difficulty=0.1, level=1, rank=1 +# ) +# educ_3 = Educative.objects.create( +# long_label="4 pattes", difficulty=0.1, level=1, rank=1 +# ) - def test_is_valid_dot(self): - arg = "" - self.assertEqual(Passe.is_valid_dot(arg), True) - arg = "Q1R1" - self.assertEqual(Passe.is_valid_dot(arg), True) - arg = ".Q1R1" - self.assertEqual(Passe.is_valid_dot(arg), True) - arg = "Q1R1." - self.assertEqual(Passe.is_valid_dot(arg), True) - arg = "Q1.R1" - self.assertEqual(Passe.is_valid_dot(arg), False) - arg = ".Q1.R1." - self.assertEqual(Passe.is_valid_dot(arg), False) +# def test_is_valid_dot(self): +# arg = "" +# self.assertEqual(Passe.is_valid_dot(arg), True) +# arg = "Q1R1" +# self.assertEqual(Passe.is_valid_dot(arg), True) +# arg = ".Q1R1" +# self.assertEqual(Passe.is_valid_dot(arg), True) +# arg = "Q1R1." +# self.assertEqual(Passe.is_valid_dot(arg), True) +# arg = "Q1.R1" +# self.assertEqual(Passe.is_valid_dot(arg), False) +# arg = ".Q1.R1." +# self.assertEqual(Passe.is_valid_dot(arg), False) - def test_is_valid_subset(self): - subset = "" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "[2-8]" - self.assertEqual(Passe.is_valid_subset(subset), True) - subset = "[2--8]" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "[-5]" - self.assertEqual(Passe.is_valid_subset(subset), True) - subset = "[3-]" - self.assertEqual(Passe.is_valid_subset(subset), True) - subset = "[8-2]" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "[-]" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "[1-]" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "[-1]" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "[4]" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "[6-6]" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "4" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "[6-6" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "[66]" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "4-8" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "6-]" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "[4-" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "[6" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "Q1R1 [4-8]" - self.assertEqual(Passe.is_valid_subset(subset), False) - subset = "Q1R1 [-8]" - self.assertEqual(Passe.is_valid_subset(subset), False) +# def test_is_valid_subset(self): +# subset = "" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "[2-8]" +# self.assertEqual(Passe.is_valid_subset(subset), True) +# subset = "[2--8]" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "[-5]" +# self.assertEqual(Passe.is_valid_subset(subset), True) +# subset = "[3-]" +# self.assertEqual(Passe.is_valid_subset(subset), True) +# subset = "[8-2]" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "[-]" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "[1-]" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "[-1]" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "[4]" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "[6-6]" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "4" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "[6-6" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "[66]" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "4-8" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "6-]" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "[4-" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "[6" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "Q1R1 [4-8]" +# self.assertEqual(Passe.is_valid_subset(subset), False) +# subset = "Q1R1 [-8]" +# self.assertEqual(Passe.is_valid_subset(subset), False) - def test_is_valid_routine_type(self): - for item in ROUTINE_TYPE_CHOICE: - self.assertEqual(Passe.is_valid_routine_type(item[1]), True) +# def test_is_valid_routine_type(self): +# for item in ROUTINE_TYPE_CHOICE: +# self.assertEqual(Passe.is_valid_routine_type(item[1]), True) - routine_type = "" - self.assertEqual(Passe.is_valid_routine_type(routine_type), False) - routine_type = ".Q1R1" - self.assertEqual(Passe.is_valid_routine_type(routine_type), False) - routine_type = "SFS." - self.assertEqual(Passe.is_valid_routine_type(routine_type), False) - routine_type = "Q1R1 [4-8]" - self.assertEqual(Passe.is_valid_routine_type(routine_type), False) - routine_type = "SFS [-8]" - self.assertEqual(Passe.is_valid_routine_type(routine_type), False) +# routine_type = "" +# self.assertEqual(Passe.is_valid_routine_type(routine_type), False) +# routine_type = ".Q1R1" +# self.assertEqual(Passe.is_valid_routine_type(routine_type), False) +# routine_type = "SFS." +# self.assertEqual(Passe.is_valid_routine_type(routine_type), False) +# routine_type = "Q1R1 [4-8]" +# self.assertEqual(Passe.is_valid_routine_type(routine_type), False) +# routine_type = "SFS [-8]" +# self.assertEqual(Passe.is_valid_routine_type(routine_type), False) - def test_is_valid_regexp_one_arg(self): - arg = "" - self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) - arg = "WC" - self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) - arg = "1|" - self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) - arg = ".Q1R1" - self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) - arg = "Q1R2." - self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) - arg = ".Q1R1 [4-8" - self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) - arg = "Q1R2. [4-8" - self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) - arg = "Q1R1 [4-8]" - self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) - arg = "Q1R1 [8-4]" - self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) +# def test_is_valid_regexp_one_arg(self): +# arg = "" +# self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) +# arg = "WC" +# self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) +# arg = "1|" +# self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) +# arg = ".Q1R1" +# self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) +# arg = "Q1R2." +# self.assertEqual(Passe.is_valid_regexp_one_arg(arg), True) +# arg = ".Q1R1 [4-8" +# self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) +# arg = "Q1R2. [4-8" +# self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) +# arg = "Q1R1 [4-8]" +# self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) +# arg = "Q1R1 [8-4]" +# self.assertEqual(Passe.is_valid_regexp_one_arg(arg), False) - def test_is_valid_regexp_two_args(self): - arg1 = "" - arg2 = "" - self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) - arg1 = "Q1R1" - self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) - arg2 = "[4-8]" - self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) - arg2 = "[8-8]" - self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) - arg2 = "[8-4]" - self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) - arg2 = "[-8]" - self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) - arg2 = "[4-]" - self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) - arg1 = "Q1R1." - self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) +# def test_is_valid_regexp_two_args(self): +# arg1 = "" +# arg2 = "" +# self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) +# arg1 = "Q1R1" +# self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) +# arg2 = "[4-8]" +# self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) +# arg2 = "[8-8]" +# self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) +# arg2 = "[8-4]" +# self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), False) +# arg2 = "[-8]" +# self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) +# arg2 = "[4-]" +# self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) +# arg1 = "Q1R1." +# self.assertEqual(Passe.is_valid_regexp_two_args(arg1, arg2), True) - def test_is_valid_regexp(self): - regexp = "" - self.assertEqual(Passe.is_valid_regexp(regexp), False) - regexp = "Q1R1 [4-8]" - self.assertEqual(Passe.is_valid_regexp(regexp), True) - regexp = "Q1R1 [8-8]" - self.assertEqual(Passe.is_valid_regexp(regexp), False) - regexp = "Q1R1 [8-4]" - self.assertEqual(Passe.is_valid_regexp(regexp), False) - regexp = "Q1R1 [-8]" - self.assertEqual(Passe.is_valid_regexp(regexp), True) - regexp = "Q1R1 [4-]" - self.assertEqual(Passe.is_valid_regexp(regexp), True) - regexp = "Q1R1. [4-8]" - self.assertEqual(Passe.is_valid_regexp(regexp), True) - regexp = "Q1R1. [4-]" - self.assertEqual(Passe.is_valid_regexp(regexp), True) - regexp = ".Q1R1 [-8]" - self.assertEqual(Passe.is_valid_regexp(regexp), True) - regexp = "Q1R1. [8-8]" - self.assertEqual(Passe.is_valid_regexp(regexp), False) - regexp = ".Q1R1 [8-4]" - self.assertEqual(Passe.is_valid_regexp(regexp), False) +# def test_is_valid_regexp(self): +# regexp = "" +# self.assertEqual(Passe.is_valid_regexp(regexp), False) +# regexp = "Q1R1 [4-8]" +# self.assertEqual(Passe.is_valid_regexp(regexp), True) +# regexp = "Q1R1 [8-8]" +# self.assertEqual(Passe.is_valid_regexp(regexp), False) +# regexp = "Q1R1 [8-4]" +# self.assertEqual(Passe.is_valid_regexp(regexp), False) +# regexp = "Q1R1 [-8]" +# self.assertEqual(Passe.is_valid_regexp(regexp), True) +# regexp = "Q1R1 [4-]" +# self.assertEqual(Passe.is_valid_regexp(regexp), True) +# regexp = "Q1R1. [4-8]" +# self.assertEqual(Passe.is_valid_regexp(regexp), True) +# regexp = "Q1R1. [4-]" +# self.assertEqual(Passe.is_valid_regexp(regexp), True) +# regexp = ".Q1R1 [-8]" +# self.assertEqual(Passe.is_valid_regexp(regexp), True) +# regexp = "Q1R1. [8-8]" +# self.assertEqual(Passe.is_valid_regexp(regexp), False) +# regexp = ".Q1R1 [8-4]" +# self.assertEqual(Passe.is_valid_regexp(regexp), False) diff --git a/jarvis/objective/tests_tools.py b/jarvis/objective/tests_tools.py index 88ee1e0..b28822b 100644 --- a/jarvis/objective/tests_tools.py +++ b/jarvis/objective/tests_tools.py @@ -133,7 +133,6 @@ class ToolsTestCase(TestCase): self.assertEqual(nb_skill_lte_type(4, "level"), 9) def test_compute_completude(self): - self.assertEqual(compute_completude(10, 1, 4), ("10%", 0)) - self.assertEqual(compute_completude(10, 1, 4), ("10%", 0)) - self.assertEqual(compute_completude(10, 5, 4), ("50%", 2)) - self.assertEqual(compute_completude(10, 10, 4), ("100%", 4)) + self.assertEqual(compute_completude(10, 1, 4), ('10%', 0, 10)) + self.assertEqual(compute_completude(10, 5, 4), ('50%', 2, 50)) + self.assertEqual(compute_completude(10, 10, 4), ('100%', 4, 100)) diff --git a/jarvis/tools/tests_date_week_transition.py b/jarvis/tools/tests_date_week_transition.py index a711aa3..6b1304a 100644 --- a/jarvis/tools/tests_date_week_transition.py +++ b/jarvis/tools/tests_date_week_transition.py @@ -61,11 +61,11 @@ class FunctionTestCase(TestCase): get_number_of_weeks_between( pendulum.date(2022, 9, 1), pendulum.date(2023, 7, 5) ), - 44, + 43, ) self.assertEqual( get_number_of_weeks_between( pendulum.date(2023, 2, 5), pendulum.date(2023, 7, 5) ), - 22, + 21, ) diff --git a/jarvis/tools/tests_models.py b/jarvis/tools/tests_models.py index 26a6f2e..dce1c4d 100644 --- a/jarvis/tools/tests_models.py +++ b/jarvis/tools/tests_models.py @@ -6,33 +6,27 @@ from .models import Season, max_even_if_none class ModelTestCase(TestCase): def test_init_season(self): + actual_season = Season() season = Season("2022-2023") - self.assertEqual(season.is_valid(), True) self.assertEqual(season.label, "2022-2023") season = Season("2022-2024") - self.assertEqual(season.is_valid(), True) - self.assertEqual(season.label, "2022-2023") + self.assertEqual(season.label, actual_season.label) season = Season("2024-2023") - self.assertEqual(season.is_valid(), True) - self.assertEqual(season.label, "2022-2023") + self.assertEqual(season.label, actual_season.label) season = Season("1358-5682") - self.assertEqual(season.is_valid(), True) - self.assertEqual(season.label, "2022-2023") + self.assertEqual(season.label, actual_season.label) season = Season("fgkrs-gkml") - self.assertEqual(season.is_valid(), True) - self.assertEqual(season.label, "2022-2023") + self.assertEqual(season.label, actual_season.label) season = Season("drgnldsjgklfdtngl") - self.assertEqual(season.is_valid(), True) - self.assertEqual(season.label, "2022-2023") + self.assertEqual(season.label, actual_season.label) season = Season("12675353878354") - self.assertEqual(season.is_valid(), True) - self.assertEqual(season.label, "2022-2023") + self.assertEqual(season.label, actual_season.label) def test_season_is_valid(self): season = Season("2022-2023")