From 3baaa02ff8d7694ebee42d1203c29a38ef2613a0 Mon Sep 17 00:00:00 2001 From: Luis Aleixo Date: Thu, 28 Jul 2022 16:37:49 +0200 Subject: [PATCH 01/11] Server-side validation in lunch break times within the activity times --- cara/apps/calculator/model_generator.py | 17 ++++++ .../apps/calculator/test_model_generator.py | 52 +++++++++++++++++++ 2 files changed, 69 insertions(+) diff --git a/cara/apps/calculator/model_generator.py b/cara/apps/calculator/model_generator.py index cb6738f7..43779f26 100644 --- a/cara/apps/calculator/model_generator.py +++ b/cara/apps/calculator/model_generator.py @@ -202,6 +202,23 @@ class FormData: raise ValueError( f"{start_name} must be less than {end_name}. Got {start} and {end}.") + # Validate lunch time within the activity times. + def validate_lunch(start, finish, time): + return start < time < finish + if (self.exposed_lunch_option and ( + not validate_lunch(self.exposed_start, self.exposed_finish, self.exposed_lunch_start) or + not validate_lunch(self.exposed_start, self.exposed_finish, self.exposed_lunch_finish))): + raise ValueError( + "Exposed lunch break must be within presence times." + ) + + if (self.infected_dont_have_breaks_with_exposed and self.infected_lunch_option and ( + not validate_lunch(self.infected_start, self.infected_finish, self.infected_lunch_start) or + not validate_lunch(self.infected_start, self.infected_finish, self.infected_lunch_finish))): + raise ValueError( + "Infected lunch break must be within presence times." + ) + validation_tuples = [('activity_type', ACTIVITY_TYPES), ('exposed_coffee_break_option', COFFEE_OPTIONS_INT), ('infected_coffee_break_option', COFFEE_OPTIONS_INT), diff --git a/cara/tests/apps/calculator/test_model_generator.py b/cara/tests/apps/calculator/test_model_generator.py index cd7de105..fa4ab587 100644 --- a/cara/tests/apps/calculator/test_model_generator.py +++ b/cara/tests/apps/calculator/test_model_generator.py @@ -255,6 +255,58 @@ def test_exposed_present_lunch_end_before_beginning(baseline_form: model_generat baseline_form.validate() +def test_exposed_presence_lunch_start_before_begining(baseline_form: model_generator.FormData): + baseline_form.exposed_lunch_start = minutes_since_midnight(8 * 60) + with pytest.raises(ValueError, match='Exposed lunch break must be within presence times.'): + baseline_form.validate() + + +def test_exposed_presence_lunch_start_after_finishing(baseline_form: model_generator.FormData): + baseline_form.exposed_lunch_start = minutes_since_midnight(19 * 60) + baseline_form.exposed_lunch_finish = minutes_since_midnight(20 * 60) + with pytest.raises(ValueError, match='Exposed lunch break must be within presence times.'): + baseline_form.validate() + + +def test_exposed_presence_lunch_finish_before_begining(baseline_form: model_generator.FormData): + baseline_form.exposed_lunch_start = minutes_since_midnight(7 * 60) + baseline_form.exposed_lunch_finish = minutes_since_midnight(8 * 60) + with pytest.raises(ValueError, match='Exposed lunch break must be within presence times.'): + baseline_form.validate() + + +def test_exposed_presence_lunch_finish_after_finishing(baseline_form: model_generator.FormData): + baseline_form.exposed_lunch_finish = minutes_since_midnight(19 * 60) + with pytest.raises(ValueError, match='Exposed lunch break must be within presence times.'): + baseline_form.validate() + + +def test_infected_presence_lunch_start_before_begining(baseline_form: model_generator.FormData): + baseline_form.infected_lunch_start = minutes_since_midnight(8 * 60) + with pytest.raises(ValueError, match='Infected lunch break must be within presence times.'): + baseline_form.validate() + + +def test_infected_presence_lunch_start_after_finishing(baseline_form: model_generator.FormData): + baseline_form.infected_lunch_start = minutes_since_midnight(19 * 60) + baseline_form.infected_lunch_finish = minutes_since_midnight(20 * 60) + with pytest.raises(ValueError, match='Infected lunch break must be within presence times.'): + baseline_form.validate() + + +def test_infected_presence_lunch_finish_before_begining(baseline_form: model_generator.FormData): + baseline_form.infected_lunch_start = minutes_since_midnight(7 * 60) + baseline_form.infected_lunch_finish = minutes_since_midnight(8 * 60) + with pytest.raises(ValueError, match='Infected lunch break must be within presence times.'): + baseline_form.validate() + + +def test_infected_presence_lunch_finish_after_finishing(baseline_form: model_generator.FormData): + baseline_form.infected_lunch_finish = minutes_since_midnight(19 * 60) + with pytest.raises(ValueError, match='Infected lunch break must be within presence times.'): + baseline_form.validate() + + @pytest.fixture def coffee_break_between_1045_and_1115(baseline_form: model_generator.FormData): baseline_form.exposed_coffee_break_option = 'coffee_break_1' From a16e1f1fc9b954ec9d070d062af32cc57a6e88eb Mon Sep 17 00:00:00 2001 From: Luis Aleixo Date: Fri, 29 Jul 2022 09:50:15 +0200 Subject: [PATCH 02/11] Added validation for length of breaks <= length of activity --- cara/apps/calculator/model_generator.py | 32 ++++++++++------ .../apps/calculator/test_model_generator.py | 37 +++++++++++++++---- 2 files changed, 49 insertions(+), 20 deletions(-) diff --git a/cara/apps/calculator/model_generator.py b/cara/apps/calculator/model_generator.py index 43779f26..89366b04 100644 --- a/cara/apps/calculator/model_generator.py +++ b/cara/apps/calculator/model_generator.py @@ -205,19 +205,27 @@ class FormData: # Validate lunch time within the activity times. def validate_lunch(start, finish, time): return start < time < finish - if (self.exposed_lunch_option and ( - not validate_lunch(self.exposed_start, self.exposed_finish, self.exposed_lunch_start) or - not validate_lunch(self.exposed_start, self.exposed_finish, self.exposed_lunch_finish))): - raise ValueError( - "Exposed lunch break must be within presence times." - ) - if (self.infected_dont_have_breaks_with_exposed and self.infected_lunch_option and ( - not validate_lunch(self.infected_start, self.infected_finish, self.infected_lunch_start) or - not validate_lunch(self.infected_start, self.infected_finish, self.infected_lunch_finish))): - raise ValueError( - "Infected lunch break must be within presence times." - ) + populations = ['exposed', 'infected'] if self.infected_dont_have_breaks_with_exposed else ['exposed'] + for population in populations: + + if (getattr(self, f'{population}_lunch_option') and ( + not validate_lunch(getattr(self, f'{population}_start'), getattr(self, f'{population}_finish'), getattr(self, f'{population}_lunch_start')) or + not validate_lunch(getattr(self, f'{population}_start'), getattr(self, f'{population}_finish'), getattr(self, f'{population}_lunch_finish')))): + raise ValueError( + f"{population} lunch break must be within presence times." + ) + + # Length of breaks < length of activity + lunch_mins, coffee_mins = 0, 0 + if getattr(self, f'{population}_lunch_option'): + lunch_mins = getattr(self, f'{population}_lunch_finish') - getattr(self, f'{population}_lunch_start') + if getattr(self, f'{population}_coffee_break_option') != 'coffee_break_0': + coffee_mins = COFFEE_OPTIONS_INT[getattr(self, f'{population}_coffee_break_option')] * getattr(self, f'{population}_coffee_duration') + if (lunch_mins + coffee_mins) >= (getattr(self, f'{population}_finish') - getattr(self, f'{population}_start')) : + raise ValueError( + f"Length of breaks >= Length of {population} presence." + ) validation_tuples = [('activity_type', ACTIVITY_TYPES), ('exposed_coffee_break_option', COFFEE_OPTIONS_INT), diff --git a/cara/tests/apps/calculator/test_model_generator.py b/cara/tests/apps/calculator/test_model_generator.py index fa4ab587..f925497e 100644 --- a/cara/tests/apps/calculator/test_model_generator.py +++ b/cara/tests/apps/calculator/test_model_generator.py @@ -257,53 +257,74 @@ def test_exposed_present_lunch_end_before_beginning(baseline_form: model_generat def test_exposed_presence_lunch_start_before_begining(baseline_form: model_generator.FormData): baseline_form.exposed_lunch_start = minutes_since_midnight(8 * 60) - with pytest.raises(ValueError, match='Exposed lunch break must be within presence times.'): + with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): baseline_form.validate() def test_exposed_presence_lunch_start_after_finishing(baseline_form: model_generator.FormData): baseline_form.exposed_lunch_start = minutes_since_midnight(19 * 60) baseline_form.exposed_lunch_finish = minutes_since_midnight(20 * 60) - with pytest.raises(ValueError, match='Exposed lunch break must be within presence times.'): + with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): baseline_form.validate() def test_exposed_presence_lunch_finish_before_begining(baseline_form: model_generator.FormData): baseline_form.exposed_lunch_start = minutes_since_midnight(7 * 60) baseline_form.exposed_lunch_finish = minutes_since_midnight(8 * 60) - with pytest.raises(ValueError, match='Exposed lunch break must be within presence times.'): + with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): baseline_form.validate() def test_exposed_presence_lunch_finish_after_finishing(baseline_form: model_generator.FormData): baseline_form.exposed_lunch_finish = minutes_since_midnight(19 * 60) - with pytest.raises(ValueError, match='Exposed lunch break must be within presence times.'): + with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): baseline_form.validate() def test_infected_presence_lunch_start_before_begining(baseline_form: model_generator.FormData): baseline_form.infected_lunch_start = minutes_since_midnight(8 * 60) - with pytest.raises(ValueError, match='Infected lunch break must be within presence times.'): + with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): baseline_form.validate() def test_infected_presence_lunch_start_after_finishing(baseline_form: model_generator.FormData): baseline_form.infected_lunch_start = minutes_since_midnight(19 * 60) baseline_form.infected_lunch_finish = minutes_since_midnight(20 * 60) - with pytest.raises(ValueError, match='Infected lunch break must be within presence times.'): + with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): baseline_form.validate() def test_infected_presence_lunch_finish_before_begining(baseline_form: model_generator.FormData): baseline_form.infected_lunch_start = minutes_since_midnight(7 * 60) baseline_form.infected_lunch_finish = minutes_since_midnight(8 * 60) - with pytest.raises(ValueError, match='Infected lunch break must be within presence times.'): + with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): baseline_form.validate() def test_infected_presence_lunch_finish_after_finishing(baseline_form: model_generator.FormData): baseline_form.infected_lunch_finish = minutes_since_midnight(19 * 60) - with pytest.raises(ValueError, match='Infected lunch break must be within presence times.'): + with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): + baseline_form.validate() + + +def test_exposed_breaks_length(baseline_form: model_generator.FormData): + baseline_form.exposed_coffee_break_option = 'coffee_break_4' + baseline_form.exposed_coffee_duration = 30 + baseline_form.exposed_start = minutes_since_midnight(10 * 60) + baseline_form.exposed_finish = minutes_since_midnight(11 * 60) + baseline_form.exposed_lunch_option = False + with pytest.raises(ValueError, match='Length of breaks >= Length of exposed presence.'): + baseline_form.validate() + + +def test_infected_breaks_length(baseline_form: model_generator.FormData): + baseline_form.infected_start = minutes_since_midnight(9 * 60) + baseline_form.infected_finish = minutes_since_midnight(12 * 60) + baseline_form.infected_lunch_start = minutes_since_midnight(10 * 60) + baseline_form.infected_lunch_finish = minutes_since_midnight(11 * 60) + baseline_form.infected_coffee_break_option = 'coffee_break_4' + baseline_form.infected_coffee_duration = 30 + with pytest.raises(ValueError, match='Length of breaks >= Length of infected presence.'): baseline_form.validate() From 814f1dc625f809dd21195afdedd113577f48ea5d Mon Sep 17 00:00:00 2001 From: Luis Aleixo Date: Fri, 29 Jul 2022 09:50:39 +0200 Subject: [PATCH 03/11] added validation for window venting duration < window venting frequency --- cara/apps/calculator/model_generator.py | 5 +++++ cara/tests/apps/calculator/test_model_generator.py | 8 ++++++++ 2 files changed, 13 insertions(+) diff --git a/cara/apps/calculator/model_generator.py b/cara/apps/calculator/model_generator.py index 89366b04..2e10b1f2 100644 --- a/cara/apps/calculator/model_generator.py +++ b/cara/apps/calculator/model_generator.py @@ -254,6 +254,11 @@ class FormData: "window_opening_regime cannot be 'not-applicable' if " "ventilation_type is 'natural_ventilation'" ) + if (self.window_opening_regime == 'windows_open_periodically' and + self.windows_duration > self.windows_frequency): + raise ValueError( + 'Duration cannot be bigger than frequency.' + ) if (self.ventilation_type == 'mechanical_ventilation' and self.mechanical_ventilation_type == 'not-applicable'): diff --git a/cara/tests/apps/calculator/test_model_generator.py b/cara/tests/apps/calculator/test_model_generator.py index f925497e..c1d1f2c2 100644 --- a/cara/tests/apps/calculator/test_model_generator.py +++ b/cara/tests/apps/calculator/test_model_generator.py @@ -508,6 +508,14 @@ def test_key_validation_natural_ventilation_window_opening_regime_na(baseline_fo model_generator.FormData.from_dict(baseline_form_data) +def test_natural_ventilation_window_opening_periodically(baseline_form: model_generator.FormData): + baseline_form.window_opening_regime = 'windows_open_periodically' + baseline_form.windows_duration = 20 + baseline_form.windows_frequency = 10 + with pytest.raises(ValueError, match='Duration cannot be bigger than frequency.'): + baseline_form.validate() + + def test_key_validation_mech_ventilation_type_na(baseline_form_data): baseline_form_data['ventilation_type'] = 'mechanical_ventilation' baseline_form_data['mechanical_ventilation_type'] = 'not-applicable' From fc20bc9e9ddc91dbb0c8427b3566e9838aab0e9d Mon Sep 17 00:00:00 2001 From: Luis Aleixo Date: Fri, 29 Jul 2022 10:01:34 +0200 Subject: [PATCH 04/11] Added validation for number of infected people <= number of total people --- cara/apps/calculator/model_generator.py | 4 ++++ cara/tests/apps/calculator/test_model_generator.py | 7 +++++++ 2 files changed, 11 insertions(+) diff --git a/cara/apps/calculator/model_generator.py b/cara/apps/calculator/model_generator.py index 2e10b1f2..c6eeeeae 100644 --- a/cara/apps/calculator/model_generator.py +++ b/cara/apps/calculator/model_generator.py @@ -185,6 +185,10 @@ class FormData: return form_dict def validate(self): + # Validate number of infected <= number of total people + if self.infected_people > self.total_people: + raise ValueError('Number of infected people should be less than number of total people.') + # Validate time intervals selected by user time_intervals = [ ['exposed_start', 'exposed_finish'], diff --git a/cara/tests/apps/calculator/test_model_generator.py b/cara/tests/apps/calculator/test_model_generator.py index c1d1f2c2..534d038d 100644 --- a/cara/tests/apps/calculator/test_model_generator.py +++ b/cara/tests/apps/calculator/test_model_generator.py @@ -167,6 +167,13 @@ def test_ventilation_window_hepa(baseline_form: model_generator.FormData): assert ventilation == baseline_vent +def test_infected_less_than_total_people(baseline_form: model_generator.FormData): + baseline_form.total_people = 10 + baseline_form.infected_people = 11 + with pytest.raises(ValueError, match='Number of infected people should be less than number of total people.'): + baseline_form.validate() + + def present_times(interval: models.Interval) -> models.BoundarySequence_t: assert isinstance(interval, models.SpecificInterval) return interval.present_times From a6454987f27f031cce99930ee14d6cf9fa43830b Mon Sep 17 00:00:00 2001 From: Luis Aleixo Date: Fri, 12 Aug 2022 11:51:32 +0100 Subject: [PATCH 05/11] Update on validation string error --- cara/apps/calculator/model_generator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cara/apps/calculator/model_generator.py b/cara/apps/calculator/model_generator.py index c6eeeeae..cd5418df 100644 --- a/cara/apps/calculator/model_generator.py +++ b/cara/apps/calculator/model_generator.py @@ -187,7 +187,7 @@ class FormData: def validate(self): # Validate number of infected <= number of total people if self.infected_people > self.total_people: - raise ValueError('Number of infected people should be less than number of total people.') + raise ValueError('Number of infected people cannot be more than number of total people.') # Validate time intervals selected by user time_intervals = [ From 833ed39e57f8b3830630e21da0f8eae0e9350d03 Mon Sep 17 00:00:00 2001 From: Luis Aleixo Date: Fri, 12 Aug 2022 11:51:55 +0100 Subject: [PATCH 06/11] updated the validation condition for lunch break --- cara/apps/calculator/model_generator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cara/apps/calculator/model_generator.py b/cara/apps/calculator/model_generator.py index cd5418df..849ff6d6 100644 --- a/cara/apps/calculator/model_generator.py +++ b/cara/apps/calculator/model_generator.py @@ -208,7 +208,7 @@ class FormData: # Validate lunch time within the activity times. def validate_lunch(start, finish, time): - return start < time < finish + return start <= time <= finish populations = ['exposed', 'infected'] if self.infected_dont_have_breaks_with_exposed else ['exposed'] for population in populations: From e9f7417001f6d5a7cba3048b9f3c30433b7e8405 Mon Sep 17 00:00:00 2001 From: Luis Aleixo Date: Fri, 12 Aug 2022 12:11:21 +0100 Subject: [PATCH 07/11] parametrization of some lunch presence validation tests --- .../apps/calculator/test_model_generator.py | 35 +++++++------------ 1 file changed, 12 insertions(+), 23 deletions(-) diff --git a/cara/tests/apps/calculator/test_model_generator.py b/cara/tests/apps/calculator/test_model_generator.py index 534d038d..75ddbc0d 100644 --- a/cara/tests/apps/calculator/test_model_generator.py +++ b/cara/tests/apps/calculator/test_model_generator.py @@ -170,7 +170,7 @@ def test_ventilation_window_hepa(baseline_form: model_generator.FormData): def test_infected_less_than_total_people(baseline_form: model_generator.FormData): baseline_form.total_people = 10 baseline_form.infected_people = 11 - with pytest.raises(ValueError, match='Number of infected people should be less than number of total people.'): + with pytest.raises(ValueError, match='Number of infected people cannot be more than number of total people.'): baseline_form.validate() @@ -262,56 +262,45 @@ def test_exposed_present_lunch_end_before_beginning(baseline_form: model_generat baseline_form.validate() -def test_exposed_presence_lunch_start_before_begining(baseline_form: model_generator.FormData): +def test_exposed_presence_lunch_break(baseline_form: model_generator.FormData): + # lunch_start before the presence begining baseline_form.exposed_lunch_start = minutes_since_midnight(8 * 60) with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): baseline_form.validate() - - -def test_exposed_presence_lunch_start_after_finishing(baseline_form: model_generator.FormData): + # lunch_start after the presence finishing baseline_form.exposed_lunch_start = minutes_since_midnight(19 * 60) baseline_form.exposed_lunch_finish = minutes_since_midnight(20 * 60) with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): baseline_form.validate() - - -def test_exposed_presence_lunch_finish_before_begining(baseline_form: model_generator.FormData): + # lunch_finish before the presence begining baseline_form.exposed_lunch_start = minutes_since_midnight(7 * 60) baseline_form.exposed_lunch_finish = minutes_since_midnight(8 * 60) with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): baseline_form.validate() - - -def test_exposed_presence_lunch_finish_after_finishing(baseline_form: model_generator.FormData): + # lunch_finish after the presence finishing baseline_form.exposed_lunch_finish = minutes_since_midnight(19 * 60) with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): baseline_form.validate() - -def test_infected_presence_lunch_start_before_begining(baseline_form: model_generator.FormData): +def test_infected_presence_lunch_break(baseline_form: model_generator.FormData): + # lunch_start before the presence begining baseline_form.infected_lunch_start = minutes_since_midnight(8 * 60) with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): baseline_form.validate() - - -def test_infected_presence_lunch_start_after_finishing(baseline_form: model_generator.FormData): + # lunch_start after the presence finishing baseline_form.infected_lunch_start = minutes_since_midnight(19 * 60) baseline_form.infected_lunch_finish = minutes_since_midnight(20 * 60) with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): baseline_form.validate() - - -def test_infected_presence_lunch_finish_before_begining(baseline_form: model_generator.FormData): + # lunch_finish before the presence begining baseline_form.infected_lunch_start = minutes_since_midnight(7 * 60) baseline_form.infected_lunch_finish = minutes_since_midnight(8 * 60) with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): baseline_form.validate() - - -def test_infected_presence_lunch_finish_after_finishing(baseline_form: model_generator.FormData): + # lunch_finish after the presence finishing baseline_form.infected_lunch_finish = minutes_since_midnight(19 * 60) with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): - baseline_form.validate() + baseline_form.validate() def test_exposed_breaks_length(baseline_form: model_generator.FormData): From b528a9ba7cfef14e092ba30d6f8d6cd719605101 Mon Sep 17 00:00:00 2001 From: Luis Aleixo Date: Fri, 12 Aug 2022 12:38:40 +0100 Subject: [PATCH 08/11] refactor validation on lunch time --- cara/apps/calculator/model_generator.py | 36 ++++++++++++++++--------- 1 file changed, 23 insertions(+), 13 deletions(-) diff --git a/cara/apps/calculator/model_generator.py b/cara/apps/calculator/model_generator.py index 849ff6d6..f7a73ea2 100644 --- a/cara/apps/calculator/model_generator.py +++ b/cara/apps/calculator/model_generator.py @@ -206,27 +206,37 @@ class FormData: raise ValueError( f"{start_name} must be less than {end_name}. Got {start} and {end}.") - # Validate lunch time within the activity times. - def validate_lunch(start, finish, time): - return start <= time <= finish + def validate_lunch(start, finish): + lunch_start = getattr(self, f'{population}_lunch_start') + lunch_finish = getattr(self, f'{population}_lunch_finish') + return (start <= lunch_start <= finish and + start <= lunch_finish <= finish) + + def get_lunch_mins(population): + if getattr(self, f'{population}_lunch_option'): + return getattr(self, f'{population}_lunch_finish') - getattr(self, f'{population}_lunch_start') + return 0 + + def get_coffee_mins(population): + if getattr(self, f'{population}_coffee_break_option') != 'coffee_break_0': + return COFFEE_OPTIONS_INT[getattr(self, f'{population}_coffee_break_option')] * getattr(self, f'{population}_coffee_duration') + return 0 + + def get_activity_mins(population): + return getattr(self, f'{population}_finish') - getattr(self, f'{population}_start') populations = ['exposed', 'infected'] if self.infected_dont_have_breaks_with_exposed else ['exposed'] for population in populations: - - if (getattr(self, f'{population}_lunch_option') and ( - not validate_lunch(getattr(self, f'{population}_start'), getattr(self, f'{population}_finish'), getattr(self, f'{population}_lunch_start')) or - not validate_lunch(getattr(self, f'{population}_start'), getattr(self, f'{population}_finish'), getattr(self, f'{population}_lunch_finish')))): + # Validate lunch time within the activity times. + if (getattr(self, f'{population}_lunch_option') and + not validate_lunch(getattr(self, f'{population}_start'), getattr(self, f'{population}_finish')) + ): raise ValueError( f"{population} lunch break must be within presence times." ) # Length of breaks < length of activity - lunch_mins, coffee_mins = 0, 0 - if getattr(self, f'{population}_lunch_option'): - lunch_mins = getattr(self, f'{population}_lunch_finish') - getattr(self, f'{population}_lunch_start') - if getattr(self, f'{population}_coffee_break_option') != 'coffee_break_0': - coffee_mins = COFFEE_OPTIONS_INT[getattr(self, f'{population}_coffee_break_option')] * getattr(self, f'{population}_coffee_duration') - if (lunch_mins + coffee_mins) >= (getattr(self, f'{population}_finish') - getattr(self, f'{population}_start')) : + if (get_lunch_mins(population) + get_coffee_mins(population)) >= get_activity_mins(population): raise ValueError( f"Length of breaks >= Length of {population} presence." ) From c4541b6d5b6027abe5e43e7b04cbabe96048bcbd Mon Sep 17 00:00:00 2001 From: Luis Aleixo Date: Fri, 12 Aug 2022 14:06:25 +0100 Subject: [PATCH 09/11] refactor the get_lunch_mins and get_coffee_mins --- cara/apps/calculator/model_generator.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/cara/apps/calculator/model_generator.py b/cara/apps/calculator/model_generator.py index f7a73ea2..9f9dbce3 100644 --- a/cara/apps/calculator/model_generator.py +++ b/cara/apps/calculator/model_generator.py @@ -213,14 +213,16 @@ class FormData: start <= lunch_finish <= finish) def get_lunch_mins(population): + lunch_mins = 0 if getattr(self, f'{population}_lunch_option'): - return getattr(self, f'{population}_lunch_finish') - getattr(self, f'{population}_lunch_start') - return 0 + lunch_mins = getattr(self, f'{population}_lunch_finish') - getattr(self, f'{population}_lunch_start') + return lunch_mins def get_coffee_mins(population): + coffee_mins = 0 if getattr(self, f'{population}_coffee_break_option') != 'coffee_break_0': - return COFFEE_OPTIONS_INT[getattr(self, f'{population}_coffee_break_option')] * getattr(self, f'{population}_coffee_duration') - return 0 + coffee_mins = COFFEE_OPTIONS_INT[getattr(self, f'{population}_coffee_break_option')] * getattr(self, f'{population}_coffee_duration') + return coffee_mins def get_activity_mins(population): return getattr(self, f'{population}_finish') - getattr(self, f'{population}_start') From 09eaf969e6375faa8d35c9f5af09258885edd4b5 Mon Sep 17 00:00:00 2001 From: Luis Aleixo Date: Fri, 12 Aug 2022 16:37:37 +0100 Subject: [PATCH 10/11] used pytest parametrizing fixture for lunch break tests --- .../apps/calculator/test_model_generator.py | 59 ++++++++----------- 1 file changed, 25 insertions(+), 34 deletions(-) diff --git a/cara/tests/apps/calculator/test_model_generator.py b/cara/tests/apps/calculator/test_model_generator.py index 75ddbc0d..36a82b41 100644 --- a/cara/tests/apps/calculator/test_model_generator.py +++ b/cara/tests/apps/calculator/test_model_generator.py @@ -262,45 +262,36 @@ def test_exposed_present_lunch_end_before_beginning(baseline_form: model_generat baseline_form.validate() -def test_exposed_presence_lunch_break(baseline_form: model_generator.FormData): - # lunch_start before the presence begining - baseline_form.exposed_lunch_start = minutes_since_midnight(8 * 60) - with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): - baseline_form.validate() - # lunch_start after the presence finishing - baseline_form.exposed_lunch_start = minutes_since_midnight(19 * 60) - baseline_form.exposed_lunch_finish = minutes_since_midnight(20 * 60) - with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): - baseline_form.validate() - # lunch_finish before the presence begining - baseline_form.exposed_lunch_start = minutes_since_midnight(7 * 60) - baseline_form.exposed_lunch_finish = minutes_since_midnight(8 * 60) - with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): - baseline_form.validate() - # lunch_finish after the presence finishing - baseline_form.exposed_lunch_finish = minutes_since_midnight(19 * 60) +@pytest.mark.parametrize( + "exposed_lunch_start, exposed_lunch_finish", + [ + [8, 14], # lunch_start before the presence begining + [19, 20], # lunch_start after the presence finishing + [7, 8], # lunch_finish before the presence begining + [19, 20], # lunch_finish after the presence finishing + ], +) +def test_exposed_presence_lunch_break(baseline_form: model_generator.FormData, exposed_lunch_start, exposed_lunch_finish): + baseline_form.exposed_lunch_start = minutes_since_midnight(exposed_lunch_start * 60) + baseline_form.exposed_lunch_finish = minutes_since_midnight(exposed_lunch_finish * 60) with pytest.raises(ValueError, match='exposed lunch break must be within presence times.'): baseline_form.validate() -def test_infected_presence_lunch_break(baseline_form: model_generator.FormData): - # lunch_start before the presence begining - baseline_form.infected_lunch_start = minutes_since_midnight(8 * 60) + +@pytest.mark.parametrize( + "infected_lunch_start, infected_lunch_finish", + [ + [8, 14], # lunch_start before the presence begining + [19, 20], # lunch_start after the presence finishing + [7, 8], # lunch_finish before the presence begining + [19, 20], # lunch_finish after the presence finishing + ], +) +def test_infected_presence_lunch_break(baseline_form: model_generator.FormData, infected_lunch_start, infected_lunch_finish): + baseline_form.infected_lunch_start = minutes_since_midnight(infected_lunch_start * 60) + baseline_form.infected_lunch_finish = minutes_since_midnight(infected_lunch_finish * 60) with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): baseline_form.validate() - # lunch_start after the presence finishing - baseline_form.infected_lunch_start = minutes_since_midnight(19 * 60) - baseline_form.infected_lunch_finish = minutes_since_midnight(20 * 60) - with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): - baseline_form.validate() - # lunch_finish before the presence begining - baseline_form.infected_lunch_start = minutes_since_midnight(7 * 60) - baseline_form.infected_lunch_finish = minutes_since_midnight(8 * 60) - with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): - baseline_form.validate() - # lunch_finish after the presence finishing - baseline_form.infected_lunch_finish = minutes_since_midnight(19 * 60) - with pytest.raises(ValueError, match='infected lunch break must be within presence times.'): - baseline_form.validate() def test_exposed_breaks_length(baseline_form: model_generator.FormData): From dac0dfa57d6930fbb5c315a58e8700cb4823ef87 Mon Sep 17 00:00:00 2001 From: Luis Aleixo Date: Mon, 22 Aug 2022 08:48:59 +0100 Subject: [PATCH 11/11] fixed bug on test lunch time tests --- cara/tests/apps/calculator/test_model_generator.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cara/tests/apps/calculator/test_model_generator.py b/cara/tests/apps/calculator/test_model_generator.py index 36a82b41..3f531d17 100644 --- a/cara/tests/apps/calculator/test_model_generator.py +++ b/cara/tests/apps/calculator/test_model_generator.py @@ -268,7 +268,7 @@ def test_exposed_present_lunch_end_before_beginning(baseline_form: model_generat [8, 14], # lunch_start before the presence begining [19, 20], # lunch_start after the presence finishing [7, 8], # lunch_finish before the presence begining - [19, 20], # lunch_finish after the presence finishing + [9, 20], # lunch_finish after the presence finishing ], ) def test_exposed_presence_lunch_break(baseline_form: model_generator.FormData, exposed_lunch_start, exposed_lunch_finish): @@ -284,7 +284,7 @@ def test_exposed_presence_lunch_break(baseline_form: model_generator.FormData, e [8, 14], # lunch_start before the presence begining [19, 20], # lunch_start after the presence finishing [7, 8], # lunch_finish before the presence begining - [19, 20], # lunch_finish after the presence finishing + [9, 20], # lunch_finish after the presence finishing ], ) def test_infected_presence_lunch_break(baseline_form: model_generator.FormData, infected_lunch_start, infected_lunch_finish):