tests

Author: R-Palazzo

sdgym/result_explorer/result_handler.py

@@ -46,6 +46,12 @@ def _load_yaml_file(self, folder_name, file_name):
         """Load a YAML file from the results folder."""
         pass
 
+    def _validate_folder_name(self, folder_name):
+        """Validate that the provided folder name exists in the results directory."""
+        all_folders = self.list()
+        if folder_name not in all_folders:
+            raise ValueError(f"Folder '{folder_name}' does not exist in the results directory.")
+
     def _compute_wins(self, result):
         synthesizers = result['Synthesizer'].unique()
         datasets = result['Dataset'].unique()
@@ -171,6 +177,7 @@ def load_results(self, results_folder_name):
             pd.DataFrame:
                 A DataFrame containing the results of the specified folder.
         """
+        self._validate_folder_name(results_folder_name)
         result_filenames = self._get_results_files(
             results_folder_name, prefix=RESULTS_FILE_PREFIX, suffix='.csv'
         )
@@ -191,6 +198,7 @@ def load_metainfo(self, results_folder_name):
             dict:
                 A dictionary containing the metainfo of the specified folder.
         """
+        self._validate_folder_name(results_folder_name)
         yaml_files = self._get_results_files(
             results_folder_name, prefix=metainfo_PREFIX, suffix='.yaml'
         )

tests/integration/result_explorer/test_result_explorer.py

@@ -21,6 +21,8 @@ def test_end_to_end_local(tmp_path):
     # Run
     result_explorer = ResultsExplorer(output_destination)
     runs = result_explorer.list()
+    results = result_explorer.load_results(runs[0])
+    metainfo = result_explorer.load_metainfo(runs[0])
     synthetic_data = result_explorer.load_synthetic_data(
         results_folder_name=runs[0],
         dataset_name='expedia_hotel_logs',
@@ -39,6 +41,16 @@ def test_end_to_end_local(tmp_path):
     new_synthetic_data = synthesizer.sample(num_rows=10)
 
     # Assert
+    expected_results = pd.read_csv(f'{output_destination}/SDGym_results_{today}/results.csv')
+    pd.testing.assert_frame_equal(results, expected_results)
+    assert metainfo[f'run_{today}_0']['jobs'] == [
+        ['expedia_hotel_logs', 'GaussianCopulaSynthesizer'],
+        ['expedia_hotel_logs', 'TVAESynthesizer'],
+        ['expedia_hotel_logs', 'UniformSynthesizer'],
+        ['fake_companies', 'GaussianCopulaSynthesizer'],
+        ['fake_companies', 'TVAESynthesizer'],
+        ['fake_companies', 'UniformSynthesizer'],
+    ]
     expected_run = f'SDGym_results_{today}'
     assert runs == [expected_run]
     assert isinstance(synthetic_data, pd.DataFrame)

tests/unit/result_explorer/test_result_explorer.py

@@ -236,3 +236,41 @@ def test_summarize(self, tmp_path):
         # Assert
         result_explorer._handler.summarize.assert_called_once_with('SDGym_results_07_07_2025')
         pd.testing.assert_frame_equal(summary, results)
+
+    def test_load_results(self, tmp_path):
+        """Test the `load_results` method."""
+        # Setup
+        output_destination = str(tmp_path / 'benchmark_output')
+        (tmp_path / 'benchmark_output' / 'SDGym_results_07_07_2025').mkdir(parents=True)
+        result_explorer = ResultsExplorer(output_destination)
+        result_explorer._handler = Mock()
+        results = pd.DataFrame({
+            'Dataset': ['A', 'B'],
+            'Synthesizer': ['Synth1', 'Synth2'],
+            'Metric1': [0.9, 0.8],
+        })
+        result_explorer._handler.load_results = Mock(return_value=results)
+
+        # Run
+        loaded_results = result_explorer.load_results('SDGym_results_07_07_2025')
+
+        # Assert
+        result_explorer._handler.load_results.assert_called_once_with('SDGym_results_07_07_2025')
+        pd.testing.assert_frame_equal(loaded_results, results)
+
+    def test_load_metainfo(self, tmp_path):
+        """Test the `load_metainfo` method."""
+        # Setup
+        output_destination = str(tmp_path / 'benchmark_output')
+        (tmp_path / 'benchmark_output' / 'SDGym_results_07_07_2025').mkdir(parents=True)
+        result_explorer = ResultsExplorer(output_destination)
+        result_explorer._handler = Mock()
+        metainfo = {'synthesizer_versions': {'Synth1': '1.0.0', 'Synth2': '2.0.0'}}
+        result_explorer._handler.load_metainfo = Mock(return_value=metainfo)
+
+        # Run
+        loaded_metainfo = result_explorer.load_metainfo('SDGym_results_07_07_2025')
+
+        # Assert
+        result_explorer._handler.load_metainfo.assert_called_once_with('SDGym_results_07_07_2025')
+        assert loaded_metainfo == metainfo

tests/unit/result_explorer/test_result_handler.py

@@ -18,6 +18,18 @@
 class TestResultsHandler:
     """Unit tests for the ResultsHandler class."""
 
+    def test__validate_folder_name(self):
+        """Test the `_validate_folder_name` method."""
+        # Setup
+        handler = Mock()
+        handler.list = Mock(return_value=['run1', 'run2'])
+        expected_error = re.escape("Folder 'run3' does not exist in the results directory.")
+
+        # Run and Assert
+        ResultsHandler._validate_folder_name(handler, 'run1')
+        with pytest.raises(ValueError, match=expected_error):
+            ResultsHandler._validate_folder_name(handler, 'run3')
+
     def test__compute_wins(self):
         """Test the `_compute_wins` method."""
         # Setup
@@ -184,6 +196,64 @@ def test_summarize(self):
             assert folder == folder_name
             pd.testing.assert_frame_equal(agg_result, aggregated_results)
 
+    def test_load_results(self):
+        """Test the `load_results` method."""
+        # Setup
+        folder_name = 'SDGym_results_07_15_2025'
+        handler = Mock()
+        handler._validate_folder_name = Mock()
+        handler._get_results_files = Mock(return_value=['results.csv', 'results(1).csv'])
+        result_1 = pd.DataFrame({
+            'Dataset': ['A', 'B'],
+            'Synthesizer': ['Synth1'] * 2,
+            'Quality_Score': [0.5, 0.6],
+        })
+        result_2 = pd.DataFrame({
+            'Dataset': ['A', 'B'],
+            'Synthesizer': ['Synth2'] * 2,
+            'Quality_Score': [0.7, 0.8],
+        })
+        result_list = [result_1, result_2]
+        handler._get_results = Mock(return_value=result_list)
+
+        # Run
+        results = ResultsHandler.load_results(handler, folder_name)
+
+        # Assert
+        handler._validate_folder_name.assert_called_once_with(folder_name)
+        expected_results = pd.concat(result_list, ignore_index=True)
+        pd.testing.assert_frame_equal(results, expected_results)
+        handler._get_results_files.assert_called_once_with(
+            folder_name, prefix='results', suffix='.csv'
+        )
+        handler._get_results.assert_called_once_with(folder_name, ['results.csv', 'results(1).csv'])
+
+    def test_load_metainfo(self):
+        """Test the `load_metainfo` method."""
+        # Setup
+        folder_name = 'SDGym_results_07_15_2025'
+        handler = Mock()
+        handler._validate_folder_name = Mock()
+        handler._get_results_files = Mock(return_value=['metainfo.yaml', 'metainfo(1).yaml'])
+        yaml_content_1 = {'run_id': 'run_1', 'sdgym_version': '0.9.0'}
+        yaml_content_2 = {'run_id': 'run_2', 'sdgym_version': '0.9.1'}
+        handler._load_yaml_file = Mock(side_effect=[yaml_content_1, yaml_content_2])
+
+        # Run
+        metainfo = ResultsHandler.load_metainfo(handler, folder_name)
+
+        # Assert
+        handler._validate_folder_name.assert_called_once_with(folder_name)
+        expected_metainfo = {
+            'run_1': {'sdgym_version': '0.9.0'},
+            'run_2': {'sdgym_version': '0.9.1'},
+        }
+        assert metainfo == expected_metainfo
+        handler._get_results_files.assert_called_once_with(
+            folder_name, prefix='metainfo', suffix='.yaml'
+        )
+        assert handler._load_yaml_file.call_count == 2
+
 
 class TestLocalResultsHandler:
     """Unit tests for the LocalResultsHandler class."""