TMSS-770: Update tests for project reporting; update fraction percentages by rounding decimals

SAS/TMSS/backend/src/tmss/tmssapp/adapters/reports.py

@@ -56,9 +56,9 @@ def _get_telescope_time_distribution(cycle: models.Cycle, start: datetime, stop:
                     failed += sub.observed_duration.total_seconds() if sup and sup.results_accepted is False else 0
         # Calculate derived and store durations
         idle = total - succeeded - failed
-        succeeded_perc = succeeded * 100.0 / total if total > 0 else None
-        failed_perc = failed * 100.0 / total if total > 0 else None
-        idle_perc = idle * 100.0 / total if total > 0 else None
+        succeeded_perc = round(succeeded * 100.0 / total, 2) if total > 0 else None
+        failed_perc = round(failed * 100.0 / total, 2) if total > 0 else None
+        idle_perc = round(idle * 100.0 / total, 2) if total > 0 else None
         durations = {'total': total, 'succeeded': succeeded, 'succeeded_perc': succeeded_perc, 'failed': failed, 'failed_perc': failed_perc, 'idle': idle, 'idle_perc': idle_perc}
         result[c if c == 'UNASSIGNED' or c == 'FILLER' else c.name] = {'durations': durations}
 
@@ -93,7 +93,7 @@ def _get_average_efficiency(cycle: models.Cycle, start: datetime, stop: datetime
         d += step
 
     # Store the efficiency averaged over the entire cycle
-    result['efficiency'] = efficiency_per_day / i if efficiency_per_day > 0 else None
+    result['efficiency'] = round(efficiency_per_day / i, 2) if efficiency_per_day > 0 else None
     return result
 
 
@@ -117,7 +117,7 @@ def _get_completion_level(cycle: models.Cycle, start: datetime, stop: datetime)
             total += sub.observed_duration.total_seconds()
             total_succeeded += sub.observed_duration.total_seconds() if sup and sup.results_accepted else 0
     # Store durations
-    succeeded_perc = total_succeeded * 100.0 / total if total > 0 else None
+    succeeded_perc = round(total_succeeded * 100.0 / total, 2) if total > 0 else None
     result['total'], result['succeeded'], result['succeeded_perc'] = total, total_succeeded, succeeded_perc
 
     # Calculate prognosis
@@ -161,7 +161,7 @@ def _get_observation_hours_per_category(cycle: models.Cycle, start: datetime, st
                 result[f'total_duration_successful_{prio.name}'] += sub.observed_duration.total_seconds() if sup and sup.results_accepted else 0
                 result['total_duration_failed'] += sub.observed_duration.total_seconds() if sup and sup.results_accepted is False else 0
         # Calculate prio percentages
-        result[f'successful_{prio.name}_perc'] = result[f'total_duration_successful_{prio.name}'] * 100.0 / result['total_duration'] if result['total_duration'] > 0 else None
+        result[f'successful_{prio.name}_perc'] = round(result[f'total_duration_successful_{prio.name}'] * 100.0 / result['total_duration'], 2) if result['total_duration'] > 0 else None
         # Aggregate prio durations to general successful
         result['total_duration_successful'] += result[f'total_duration_successful_{prio.name}']
         # Subtract prio states from total to get partial idle
@@ -170,11 +170,11 @@ def _get_observation_hours_per_category(cycle: models.Cycle, start: datetime, st
     result['total_duration_idle'] -= result['total_duration_failed']
 
     # Calculate percentages
-    result['successful_perc'] = result['total_duration_successful'] * 100.0 / result['total_duration'] if result['total_duration'] > 0 else None
-    result['idle_perc'] = result['total_duration_idle'] * 100.0 / result['total_duration'] if result['total_duration'] > 0 else None
-    result['failed_perc'] = result['total_duration_failed'] * 100.0 / result['total_duration'] if result['total_duration'] > 0 else None
-    result['ddt_com_rep_perc'] = result['DDT Com Rep'] * 100.0 / result['total_duration'] if result['total_duration'] > 0 else None
-    result['system_unavailability_perc'] = result['System Unavailability'] * 100.0 / result['total_duration'] if result['System Unavailability'] and result['total_duration'] > 0 else None
+    result['successful_perc'] = round(result['total_duration_successful'] * 100.0 / result['total_duration'], 2) if result['total_duration'] > 0 else None
+    result['idle_perc'] = round(result['total_duration_idle'] * 100.0 / result['total_duration'], 2) if result['total_duration'] > 0 else None
+    result['failed_perc'] = round(result['total_duration_failed'] * 100.0 / result['total_duration'], 2) if result['total_duration'] > 0 else None
+    result['ddt_com_rep_perc'] = round(result['DDT Com Rep'] * 100.0 / result['total_duration'], 2) if result['total_duration'] > 0 else None
+    result['system_unavailability_perc'] = round(result['System Unavailability'] * 100.0 / result['total_duration'], 2) if result['System Unavailability'] and result['total_duration'] > 0 else None
 
     return result
 
@@ -201,7 +201,7 @@ def _get_weekly_efficiency(cycle: models.Cycle, start: datetime, stop: datetime)
                 sup = SchedulingUnitProcess.objects.filter(su=sub).first()
                 total_per_week += sub.observed_duration.total_seconds()
                 total_succeeded_per_week += sub.observed_duration.total_seconds() if sup and sup.results_accepted else 0
-        efficiency = total_succeeded_per_week * 100.0 / total_per_week if total_per_week > 0 else None
+        efficiency = round(total_succeeded_per_week * 100.0 / total_per_week, 2) if total_per_week > 0 else None
         result['weeks'].append({'week': d.date().isoformat(), 'efficiency': efficiency})
         d += step
 
@@ -316,7 +316,7 @@ def _get_failures(cycle: models.Cycle, start: datetime, stop: datetime) -> {}:
                 sup = SchedulingUnitProcess.objects.filter(su=sub).first()
                 total_per_month += sub.observed_duration.total_seconds()
                 total_failed_per_month += sub.observed_duration.total_seconds() if sup and sup.results_accepted is False else 0
-        failed_perc = total_failed_per_month * 100.0 / total_per_month if total_per_month > 0 else None
+        failed_perc = round(total_failed_per_month * 100.0 / total_per_month, 2) if total_per_month > 0 else None
         result['months'].append({'month': d.date().isoformat(), 'total': total_per_month, 'total_failed': total_failed_per_month, 'failed_perc': failed_perc})
         d += step
 
@@ -412,12 +412,12 @@ def _get_subs_and_durations_from_project(project_pk: int, start: datetime, stop:
     subs = {'successful': subs_succeeded, 'failed': subs_failed}
 
     # Calculate percentages
-    durations['not_cancelled_perc'] = durations['total_not_cancelled'] * 100.0 / durations['total'] if durations['total'] > 0 else None
-    durations['succeeded_perc'] = durations['total_succeeded'] * 100.0 / durations['total'] if durations['total'] > 0 else None
-    durations['failed_perc'] = durations['total_failed'] * 100.0 / durations['total'] if durations['total'] > 0 else None
-    durations['observed_perc'] = durations['total_observed'] * 100.0 / durations['total'] if durations['total'] > 0 else None
-    durations['observed_succeeded_perc'] = durations['total_observed_succeeded'] * 100.0 / durations['total'] if durations['total'] > 0 else None
-    durations['observed_failed_perc'] = durations['total_observed_failed'] * 100.0 / durations['total'] if durations['total'] > 0 else None
+    durations['not_cancelled_perc'] = round(durations['total_not_cancelled'] * 100.0 / durations['total'], 2) if durations['total'] > 0 else None
+    durations['succeeded_perc'] = round(durations['total_succeeded'] * 100.0 / durations['total'], 2) if durations['total'] > 0 else None
+    durations['failed_perc'] = round(durations['total_failed'] * 100.0 / durations['total'], 2) if durations['total'] > 0 else None
+    durations['observed_perc'] = round(durations['total_observed'] * 100.0 / durations['total'], 2) if durations['total'] > 0 else None
+    durations['observed_succeeded_perc'] = round(durations['total_observed_succeeded'] * 100.0 / durations['total'], 2) if durations['total'] > 0 else None
+    durations['observed_failed_perc'] = round(durations['total_observed_failed'] * 100.0 / durations['total'], 2) if durations['total'] > 0 else None
 
     return subs, durations
 

SAS/TMSS/backend/test/t_adapter.py

@@ -618,17 +618,35 @@ class ProjectReportTest(unittest.TestCase):
         # Assert durations are well calculated
         # The four SUBs (successful, failed, cancelled and not cancelled) have a duration/observed_duration of 600s each
         self.assertAlmostEqual(result['durations']['total'], 2400, places=4)
-        self.assertAlmostEqual(result['durations']['total_observed_succeeded'], 600, places=4)
         self.assertAlmostEqual(result['durations']['total_not_cancelled'], 1800, places=4)
+        self.assertAlmostEqual(result['durations']['total_succeeded'], 600, places=4)
+        self.assertAlmostEqual(result['durations']['total_succeeded_A'], 600, places=4)  # The succeeded SUB has prio A
+        self.assertAlmostEqual(result['durations']['total_succeeded_B'], 0, places=4)
+        self.assertAlmostEqual(result['durations']['total_failed'], 600, places=4)
+        self.assertAlmostEqual(result['durations']['total_observed'], 1200, places=4)
+        self.assertAlmostEqual(result['durations']['total_observed_succeeded'], 600, places=4)
+        self.assertAlmostEqual(result['durations']['total_observed_succeeded_A'], 600, places=4)
+        self.assertAlmostEqual(result['durations']['total_observed_succeeded_B'], 0, places=4)
         self.assertAlmostEqual(result['durations']['total_observed_failed'], 600, places=4)
+        # Assert percentages
+        self.assertAlmostEqual(result['durations']['not_cancelled_perc'], 75.0, places=2)
+        self.assertAlmostEqual(result['durations']['succeeded_perc'], 25.0, places=2)
+        self.assertAlmostEqual(result['durations']['failed_perc'], 25.0, places=2)
+        self.assertAlmostEqual(result['durations']['observed_perc'], 50.0, places=2)
+        self.assertAlmostEqual(result['durations']['observed_succeeded_perc'], 25.0, places=2)
+        self.assertAlmostEqual(result['durations']['observed_failed_perc'], 25.0, places=2)
 
         # There is only one successful SUB
         self.assertEqual(result['SUBs']['successful'][0]['id'], succeeded_sub.pk)
+        self.assertEqual(result['SUBs']['successful'][0]['status'], 'finished')
+        self.assertEqual(result['SUBs']['successful'][0]['ingested_data_size'], 246)
         # There is only one failed SUB
         self.assertEqual(result['SUBs']['failed'][0]['id'], failed_sub.pk)
+        self.assertEqual(result['SUBs']['failed'][0]['status'], 'finished')
+        self.assertIsNone(result['SUBs']['failed'][0]['ingested_data_size'])
 
-        # There are just two dataproducts
-        self.assertEqual(result['LTA dataproducts']['size__sum'], dataproduct1.size + dataproduct2.size)
+        # There are just two dataproducts, each has a size of 123
+        self.assertEqual(result['LTA dataproducts']['size__sum'], 246)
         # Just to check if the placeholder was added
         self.assertIsNotNone(result['SAPs exposure'])   # TODO: Implement test properly.