import unittest import numpy as np import tempfile import os import pickle import shutil from unittest.mock import Mock, patch from sklearn.decomposition import PCA from sklearn.cluster import AgglomerativeClustering # Import the implementations to test # Assuming canonical implementation is in 'canonical.py' and generated in 'generated.py' try: from presto.canonical import Atom as CanonicalAtom from presto.atom import Atom as GeneratedAtom # Import Presto class for reference from presto.presto import Presto except ImportError: # Fallback if modules are named differently print("Warning: Could not import canonical/generated modules. Adjust import paths as needed.") CanonicalAtom = None GeneratedAtom = None Presto = None class TestAtomFunctionalEquivalence(unittest.TestCase): """ Test suite to verify functional equivalence between canonical and generated Atom implementations. This suite tests all public methods of the Atom class by comparing outputs from both implementations when given identical inputs. Tests use small, representative datasets for efficiency. """ def setUp(self): """Set up test fixtures with small sample data.""" # Create small representative embeddings for testing np.random.seed(42) # For reproducible test data # Small 2D embeddings (10 points each, 2 dimensions) self.embedding1 = np.random.rand(10, 2).astype(np.float32) self.embedding2 = np.random.rand(10, 2).astype(np.float32) + 1.0 self.embedding3 = np.random.rand(10, 2).astype(np.float32) + 2.0 # Test data list self.test_embeddings = [self.embedding1, self.embedding2, self.embedding3] # Common parameters for testing self.test_seed = 42 self.test_epsilon = 0.5 self.test_linkage = 'complete' # Create temporary directory for file operations self.temp_dir = tempfile.mkdtemp() # Pre-computed small MMS matrix for testing (3x3 symmetric matrix) self.test_mms = np.array([ [0.0, 0.8, 1.2], [0.8, 0.0, 0.6], [1.2, 0.6, 0.0] ]) def tearDown(self): """Clean up temporary files.""" shutil.rmtree(self.temp_dir, ignore_errors=True) def test_atom_initialization_with_list(self): """Test Atom initialization with list of embeddings.""" canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed) generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed) # Compare basic attributes self.assertEqual(canonical_atom.multiverse_size, generated_atom.multiverse_size, "Multiverse size mismatch") self.assertEqual(canonical_atom.seed, generated_atom.seed, "Seed mismatch") self.assertEqual(len(canonical_atom.data), len(generated_atom.data), "Data length mismatch") # Compare data arrays for i, (canonical_emb, generated_emb) in enumerate(zip(canonical_atom.data, generated_atom.data)): np.testing.assert_array_equal(canonical_emb, generated_emb, f"Embedding {i} data mismatch") def test_atom_initialization_with_folder(self): """Test Atom initialization with folder path.""" # Create test pickle files for i, embedding in enumerate(self.test_embeddings): file_path = os.path.join(self.temp_dir, f"embedding_{i}.pkl") with open(file_path, 'wb') as f: pickle.dump(embedding, f) canonical_atom = CanonicalAtom(data=self.temp_dir, seed=self.test_seed) generated_atom = GeneratedAtom(data=self.temp_dir, seed=self.test_seed) # Compare attributes self.assertEqual(canonical_atom.multiverse_size, generated_atom.multiverse_size, "Multiverse size mismatch when loading from folder") self.assertEqual(len(canonical_atom.data), len(generated_atom.data), "Data length mismatch when loading from folder") # Compare loaded data for i, (canonical_emb, generated_emb) in enumerate(zip(canonical_atom.data, generated_atom.data)): np.testing.assert_array_equal(canonical_emb, generated_emb, f"Loaded embedding {i} data mismatch") @patch('presto.Presto') # Mock the Presto class from presto.py def test_compute_mms_functional_equivalence(self, mock_presto): """Test compute_mms method functional equivalence.""" # Mock Presto class to return deterministic distances mock_distances = [0.8, 1.2, 0.6] # Distances for 3 embeddings (3 choose 2 = 3 pairs) def mock_presto_factory(): mock_instance = Mock() mock_instance.fit_transform.side_effect = mock_distances return mock_instance mock_presto.return_value = mock_presto_factory() # Initialize atoms canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed) generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed) # Test parameters test_params = { 'projector': PCA, 'n_projections': 1, 'score_type': 'aggregate', 'n_components': 2, 'normalize': False, 'max_homology_dim': 1, 'resolution': 50, 'normalization_approx_iterations': 100, 'parallelize': False # Use False for deterministic testing } # Compute MMS on both implementations canonical_atom.compute_mms(**test_params) generated_atom.compute_mms(**test_params) # Compare MMS matrices self.assertIsInstance(canonical_atom.MMS, type(generated_atom.MMS), "MMS matrix type mismatch") if canonical_atom.MMS is not None and generated_atom.MMS is not None: np.testing.assert_array_almost_equal( canonical_atom.MMS, generated_atom.MMS, decimal=10, err_msg="MMS matrices do not match" ) # Verify matrix properties self.assertEqual(canonical_atom.MMS.shape, generated_atom.MMS.shape, "MMS matrix shape mismatch") self.assertTrue(np.allclose(canonical_atom.MMS, canonical_atom.MMS.T), "Canonical MMS matrix not symmetric") self.assertTrue(np.allclose(generated_atom.MMS, generated_atom.MMS.T), "Generated MMS matrix not symmetric") def test_save_and_load_mms_functional_equivalence(self): """Test save_mms and load_mms methods functional equivalence.""" # Initialize atoms and set a test MMS canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed) generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed) canonical_atom.MMS = self.test_mms.copy() generated_atom.MMS = self.test_mms.copy() # Test save_mms canonical_path = os.path.join(self.temp_dir, "canonical_mms.pkl") generated_path = os.path.join(self.temp_dir, "generated_mms.pkl") canonical_atom.save_mms(canonical_path) generated_atom.save_mms(generated_path) # Verify files were created self.assertTrue(os.path.exists(canonical_path), "Canonical MMS file not saved") self.assertTrue(os.path.exists(generated_path), "Generated MMS file not saved") # Load and compare saved data with open(canonical_path, 'rb') as f: canonical_saved = pickle.load(f) with open(generated_path, 'rb') as f: generated_saved = pickle.load(f) np.testing.assert_array_equal(canonical_saved, generated_saved, "Saved MMS matrices do not match") # Test load_mms by setting MMS from file path new_canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed) new_generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed) new_canonical_atom.MMS = canonical_path new_generated_atom.MMS = generated_path np.testing.assert_array_equal(new_canonical_atom.MMS, new_generated_atom.MMS, "Loaded MMS matrices do not match") def test_cluster_functional_equivalence(self): """Test cluster method functional equivalence.""" canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed) generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed) # Set identical MMS matrices canonical_atom.MMS = self.test_mms.copy() generated_atom.MMS = self.test_mms.copy() # Perform clustering with identical parameters canonical_clustering = canonical_atom.cluster(epsilon=self.test_epsilon, linkage=self.test_linkage) generated_clustering = generated_atom.cluster(epsilon=self.test_epsilon, linkage=self.test_linkage) # Compare clustering results self.assertIsInstance(canonical_clustering, AgglomerativeClustering, "Canonical clustering should return AgglomerativeClustering") self.assertIsInstance(generated_clustering, AgglomerativeClustering, "Generated clustering should return AgglomerativeClustering") # Compare cluster labels (main output) np.testing.assert_array_equal(canonical_clustering.labels_, generated_clustering.labels_, "Cluster labels do not match") # Compare number of clusters canonical_n_clusters = len(np.unique(canonical_clustering.labels_)) generated_n_clusters = len(np.unique(generated_clustering.labels_)) self.assertEqual(canonical_n_clusters, generated_n_clusters, "Number of clusters mismatch") # Compare stored parameters self.assertEqual(canonical_atom.epsilon, generated_atom.epsilon, "Stored epsilon parameter mismatch") self.assertEqual(canonical_atom.linkage, generated_atom.linkage, "Stored linkage parameter mismatch") def test_compute_set_cover_functional_equivalence(self): """Test compute_set_cover method functional equivalence.""" canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed) generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed) # Set identical MMS matrices canonical_atom.MMS = self.test_mms.copy() generated_atom.MMS = self.test_mms.copy() # Compute set cover with identical parameters canonical_set_cover = canonical_atom.compute_set_cover(epsilon=self.test_epsilon) generated_set_cover = generated_atom.compute_set_cover(epsilon=self.test_epsilon) # Compare set cover results self.assertIsInstance(canonical_set_cover, dict, "Canonical set cover should return dict") self.assertIsInstance(generated_set_cover, dict, "Generated set cover should return dict") # Compare keys (representative indices) self.assertEqual(set(canonical_set_cover.keys()), set(generated_set_cover.keys()), "Set cover representative keys do not match") # Compare values (covered indices for each representative) for key in canonical_set_cover.keys(): canonical_covered = sorted(canonical_set_cover[key]) generated_covered = sorted(generated_set_cover[key]) self.assertEqual(canonical_covered, generated_covered, f"Covered indices for representative {key} do not match") # Verify coverage completeness for both implementations canonical_all_covered = set() generated_all_covered = set() for covered_list in canonical_set_cover.values(): canonical_all_covered.update(covered_list) for covered_list in generated_set_cover.values(): generated_all_covered.update(covered_list) expected_all_indices = set(range(len(self.test_embeddings))) self.assertEqual(canonical_all_covered, expected_all_indices, "Canonical set cover doesn't cover all embeddings") self.assertEqual(generated_all_covered, expected_all_indices, "Generated set cover doesn't cover all embeddings") self.assertEqual(canonical_all_covered, generated_all_covered, "Overall coverage sets do not match") def test_static_methods_functional_equivalence(self): """Test static utility methods functional equivalence.""" # Test validate_distance_matrix valid_matrix = self.test_mms.copy() shape = (3, 3) canonical_validated = CanonicalAtom.validate_distance_matrix(valid_matrix, shape) generated_validated = GeneratedAtom.validate_distance_matrix(valid_matrix, shape) np.testing.assert_array_equal(canonical_validated, generated_validated, "Validated matrices do not match") # Test file_id_sorter test_filenames = ["file_10.pkl", "file_2.pkl", "file_100.pkl", "no_number.pkl"] canonical_sorted = sorted(test_filenames, key=CanonicalAtom.file_id_sorter) generated_sorted = sorted(test_filenames, key=GeneratedAtom.file_id_sorter) self.assertEqual(canonical_sorted, generated_sorted, "File sorting results do not match") # Test _load_data with pickle file test_data = self.test_mms.copy() test_file = os.path.join(self.temp_dir, "test_data.pkl") with open(test_file, 'wb') as f: pickle.dump(test_data, f) canonical_loaded = CanonicalAtom._load_data(test_file) generated_loaded = GeneratedAtom._load_data(test_file) np.testing.assert_array_equal(canonical_loaded, generated_loaded, "Loaded data does not match") def test_edge_cases_functional_equivalence(self): """Test edge cases and error handling functional equivalence.""" # Test with single embedding single_embedding = [self.embedding1] canonical_atom = CanonicalAtom(data=single_embedding, seed=self.test_seed) generated_atom = GeneratedAtom(data=single_embedding, seed=self.test_seed) self.assertEqual(canonical_atom.multiverse_size, generated_atom.multiverse_size, "Single embedding multiverse size mismatch") # Test invalid data type with self.assertRaises(TypeError): CanonicalAtom(data=123, seed=self.test_seed) with self.assertRaises(TypeError): GeneratedAtom(data=123, seed=self.test_seed) # Test invalid MMS type - both implementations should raise FileNotFoundError # when trying to load a non-existent file path canonical_atom = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed) generated_atom = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed) with self.assertRaises(FileNotFoundError): canonical_atom.MMS = "invalid_type" with self.assertRaises(FileNotFoundError): generated_atom.MMS = "invalid_type" class TestAtomWithRandomness(unittest.TestCase): """ Test suite for functions with randomness, focusing on structural properties rather than exact value comparisons. """ def setUp(self): """Set up test fixtures.""" np.random.seed(42) self.test_embeddings = [ np.random.rand(8, 2).astype(np.float32), np.random.rand(8, 2).astype(np.float32) + 1, np.random.rand(8, 2).astype(np.float32) + 2 ] self.test_seed = 42 @patch('presto.Presto') def test_mms_computation_with_fixed_seed(self, mock_presto): """Test MMS computation reproducibility with fixed seed.""" canonical_atom1 = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed) canonical_atom2 = CanonicalAtom(data=self.test_embeddings, seed=self.test_seed) generated_atom1 = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed) generated_atom2 = GeneratedAtom(data=self.test_embeddings, seed=self.test_seed) # Set up identical mock behavior mock_distances = [0.5, 0.7, 0.3] def create_mock_presto(): mock_instance = Mock() mock_instance.fit_transform.side_effect = mock_distances return mock_instance mock_presto.return_value = create_mock_presto() # Compute MMS with identical parameters params = {'parallelize': False, 'n_projections': 1} canonical_atom1.compute_mms(**params) canonical_atom2.compute_mms(**params) generated_atom1.compute_mms(**params) generated_atom2.compute_mms(**params) # Verify reproducibility within each implementation np.testing.assert_array_equal(canonical_atom1.MMS, canonical_atom2.MMS, "Canonical implementation not reproducible") np.testing.assert_array_equal(generated_atom1.MMS, generated_atom2.MMS, "Generated implementation not reproducible") # Verify equivalence between implementations np.testing.assert_array_equal(canonical_atom1.MMS, generated_atom1.MMS, "MMS matrices differ between implementations") if __name__ == '__main__': # Create a test suite combining all test cases test_suite = unittest.TestLoader().loadTestsFromTestCase(TestAtomFunctionalEquivalence) test_suite.addTests(unittest.TestLoader().loadTestsFromTestCase(TestAtomWithRandomness)) # Run the tests with detailed output runner = unittest.TextTestRunner(verbosity=2, buffer=True) result = runner.run(test_suite) # Print summary print(f"\n{'='*60}") print(f"TEST SUMMARY") print(f"{'='*60}") print(f"Tests run: {result.testsRun}") print(f"Failures: {len(result.failures)}") print(f"Errors: {len(result.errors)}") print(f"Success rate: {((result.testsRun - len(result.failures) - len(result.errors)) / result.testsRun * 100):.1f}%") if result.failures: print(f"\nFAILURES:") for test, traceback in result.failures: error_msg = traceback.split('AssertionError: ')[-1].split('\n')[0] print(f"- {test}: {error_msg}") if result.errors: print(f"\nERRORS:") for test, traceback in result.errors: error_msg = traceback.split('\n')[-2] print(f"- {test}: {error_msg}")