aixtools 0.1.10__py3-none-any.whl → 0.1.11__py3-none-any.whl

tests/unit/agents/test_prompt.py

@@ -1,363 +0,0 @@
-"""Unit tests for aixtools.agents.prompt module."""
-
-import tempfile
-import unittest
-from pathlib import Path
-from unittest.mock import Mock, patch, mock_open
-
-from pydantic_ai import BinaryContent
-
-from aixtools.agents.prompt import (
-    CLAUDE_IMAGE_MAX_FILE_SIZE_IN_CONTEXT,
-    CLAUDE_MAX_FILE_SIZE_IN_CONTEXT,
-    build_user_input,
-    file_to_binary_content,
-    should_be_included_into_context,
-)
-
-
-class TestShouldBeIncludedIntoContext(unittest.TestCase):
-    """Test cases for should_be_included_into_context function."""
-
-    def test_non_binary_content_returns_false(self):
-        """Test that non-BinaryContent returns False."""
-        result = should_be_included_into_context("text content", 100)
-        self.assertFalse(result)
-        
-        result = should_be_included_into_context(None, 100)
-        self.assertFalse(result)
-
-    def test_text_media_type_returns_false(self):
-        """Test that text media types return False."""
-        binary_content = BinaryContent(data=b"test", media_type="text/plain")
-        result = should_be_included_into_context(binary_content, 100)
-        self.assertFalse(result)
-        
-        binary_content = BinaryContent(data=b"test", media_type="text/html")
-        result = should_be_included_into_context(binary_content, 100)
-        self.assertFalse(result)
-
-    def test_archive_types_return_false(self):
-        """Test that archive media types return False."""
-        archive_types = [
-            "application/zip",
-            "application/x-tar",
-            "application/gzip",
-            "application/x-gzip",
-            "application/x-rar-compressed",
-            "application/x-7z-compressed",
-        ]
-        
-        for media_type in archive_types:
-            binary_content = BinaryContent(data=b"test", media_type=media_type)
-            result = should_be_included_into_context(binary_content, 100)
-            self.assertFalse(result, f"Archive type {media_type} should return False")
-
-    def test_image_within_size_limit_returns_true(self):
-        """Test that images within size limit return True."""
-        with patch.object(BinaryContent, 'is_image', new_callable=lambda: True):
-            binary_content = BinaryContent(data=b"image_data", media_type="image/png")
-            
-            # Test with size under limit
-            result = should_be_included_into_context(binary_content, 1024)
-            self.assertTrue(result)
-
-    def test_image_over_size_limit_returns_false(self):
-        """Test that images over size limit return False."""
-        with patch.object(BinaryContent, 'is_image', new_callable=lambda: True):
-            binary_content = BinaryContent(data=b"image_data", media_type="image/png")
-            
-            # Test with size over limit
-            result = should_be_included_into_context(binary_content, CLAUDE_IMAGE_MAX_FILE_SIZE_IN_CONTEXT + 1)
-            self.assertFalse(result)
-
-    def test_non_image_within_size_limit_returns_true(self):
-        """Test that non-images within size limit return True."""
-        with patch.object(BinaryContent, 'is_image', new_callable=lambda: False):
-            binary_content = BinaryContent(data=b"pdf_data", media_type="application/pdf")
-            
-            # Test with size under limit
-            result = should_be_included_into_context(binary_content, 1024)
-            self.assertTrue(result)
-
-    def test_non_image_over_size_limit_returns_false(self):
-        """Test that non-images over size limit return False."""
-        with patch.object(BinaryContent, 'is_image', new_callable=lambda: False):
-            binary_content = BinaryContent(data=b"pdf_data", media_type="application/pdf")
-            
-            # Test with size over limit
-            result = should_be_included_into_context(binary_content, CLAUDE_MAX_FILE_SIZE_IN_CONTEXT + 1)
-            self.assertFalse(result)
-
-    def test_custom_size_limits(self):
-        """Test with custom size limits."""
-        # Test non-image content with custom limits (since image detection is complex)
-        pdf_content = BinaryContent(data=b"pdf_data", media_type="application/pdf")
-        
-        # Test non-image over custom file limit
-        result = should_be_included_into_context(
-            pdf_content, 5000, max_img_size_bytes=1024, max_file_size_bytes=4096
-        )
-        self.assertFalse(result)
-        
-        # Test non-image under custom file limit
-        result = should_be_included_into_context(
-            pdf_content, 2000, max_img_size_bytes=1024, max_file_size_bytes=4096
-        )
-        self.assertTrue(result)
-        
-        # Test with very small custom limits
-        result = should_be_included_into_context(
-            pdf_content, 100, max_img_size_bytes=50, max_file_size_bytes=80
-        )
-        self.assertFalse(result)
-        
-        # Test with very large custom limits
-        result = should_be_included_into_context(
-            pdf_content, 100, max_img_size_bytes=200, max_file_size_bytes=200
-        )
-        self.assertTrue(result)
-
-
-class TestFileToBinaryContent(unittest.TestCase):
-    """Test cases for file_to_binary_content function."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.temp_dir = tempfile.mkdtemp()
-        self.temp_path = Path(self.temp_dir)
-
-    def tearDown(self):
-        """Clean up test fixtures."""
-        import shutil
-        shutil.rmtree(self.temp_dir)
-
-    @patch('aixtools.agents.prompt.is_text_content')
-    @patch('mimetypes.guess_type')
-    def test_text_file_returns_string(self, mock_guess_type, mock_is_text):
-        """Test that text files return decoded strings."""
-        mock_guess_type.return_value = ("text/plain", None)
-        mock_is_text.return_value = True
-        
-        test_file = self.temp_path / "test.txt"
-        test_content = "Hello, world!"
-        test_file.write_text(test_content, encoding="utf-8")
-        
-        result = file_to_binary_content(test_file)
-        
-        self.assertEqual(result, test_content)
-        mock_is_text.assert_called_once()
-
-    @patch('aixtools.agents.prompt.is_text_content')
-    @patch('mimetypes.guess_type')
-    def test_binary_file_returns_binary_content(self, mock_guess_type, mock_is_text):
-        """Test that binary files return BinaryContent."""
-        mock_guess_type.return_value = ("image/png", None)
-        mock_is_text.return_value = False
-        
-        test_file = self.temp_path / "test.png"
-        test_data = b'\x89PNG\r\n\x1a\n'
-        test_file.write_bytes(test_data)
-        
-        result = file_to_binary_content(test_file)
-        
-        self.assertIsInstance(result, BinaryContent)
-        if isinstance(result, BinaryContent):
-            self.assertEqual(result.data, test_data)
-            self.assertEqual(result.media_type, "image/png")
-
-    @patch('aixtools.agents.prompt.is_text_content')
-    @patch('mimetypes.guess_type')
-    def test_unknown_mime_type_defaults_to_octet_stream(self, mock_guess_type, mock_is_text):
-        """Test that unknown mime types default to application/octet-stream."""
-        mock_guess_type.return_value = (None, None)
-        mock_is_text.return_value = False
-        
-        test_file = self.temp_path / "test.unknown"
-        test_data = b'unknown data'
-        test_file.write_bytes(test_data)
-        
-        result = file_to_binary_content(test_file)
-        
-        self.assertIsInstance(result, BinaryContent)
-        if isinstance(result, BinaryContent):
-            self.assertEqual(result.media_type, "application/octet-stream")
-
-    @patch('aixtools.agents.prompt.is_text_content')
-    def test_explicit_mime_type(self, mock_is_text):
-        """Test with explicitly provided mime type."""
-        mock_is_text.return_value = False
-        
-        test_file = self.temp_path / "test.data"
-        test_data = b'test data'
-        test_file.write_bytes(test_data)
-        
-        result = file_to_binary_content(test_file, "application/custom")
-        
-        self.assertIsInstance(result, BinaryContent)
-        if isinstance(result, BinaryContent):
-            self.assertEqual(result.media_type, "application/custom")
-
-
-class TestBuildUserInput(unittest.TestCase):
-    """Test cases for build_user_input function."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.session_tuple = ("user123", "session456")
-        self.user_text = "Please analyze these files"
-
-    def test_no_file_paths_returns_text_only(self):
-        """Test that no file paths returns just the user text."""
-        result = build_user_input(self.session_tuple, self.user_text, [])
-        
-        self.assertEqual(result, self.user_text)
-
-    @patch('aixtools.agents.prompt.should_be_included_into_context')
-    @patch('aixtools.agents.prompt.file_to_binary_content')
-    @patch('aixtools.agents.prompt.container_to_host_path')
-    @patch('mimetypes.guess_type')
-    def test_single_file_not_included_in_context(
-        self, mock_guess_type, mock_container_to_host,
-        mock_file_to_binary, mock_should_include
-    ):
-        """Test with single file that should not be included in context."""
-        # Setup mocks
-        mock_guess_type.return_value = ("text/plain", None)
-        mock_should_include.return_value = False
-        
-        mock_host_path = Mock()
-        mock_host_path.stat.return_value.st_size = 1024
-        mock_container_to_host.return_value = mock_host_path
-        
-        mock_file_to_binary.return_value = "file content"
-        
-        file_paths = [Path("/workspace/test.txt")]
-        
-        result = build_user_input(self.session_tuple, self.user_text, file_paths)
-        
-        self.assertIsInstance(result, list)
-        self.assertEqual(len(result), 1)  # Only the prompt, no binary attachments
-        self.assertIsInstance(result[0], str)
-        prompt_text = str(result[0])
-        self.assertIn("Please analyze these files", prompt_text)
-        self.assertIn("Attachments:", prompt_text)
-        self.assertIn("test.txt", prompt_text)
-        self.assertIn("file_size=1024 bytes", prompt_text)
-
-    @patch('aixtools.agents.prompt.should_be_included_into_context')
-    @patch('aixtools.agents.prompt.file_to_binary_content')
-    @patch('aixtools.agents.prompt.container_to_host_path')
-    @patch('mimetypes.guess_type')
-    def test_single_file_included_in_context(
-        self, mock_guess_type, mock_container_to_host,
-        mock_file_to_binary, mock_should_include
-    ):
-        """Test with single file that should be included in context."""
-        # Setup mocks
-        mock_guess_type.return_value = ("image/png", None)
-        mock_should_include.return_value = True
-        
-        mock_host_path = Mock()
-        mock_host_path.stat.return_value.st_size = 2048
-        mock_container_to_host.return_value = mock_host_path
-        
-        mock_binary_content = BinaryContent(data=b"image data", media_type="image/png")
-        mock_file_to_binary.return_value = mock_binary_content
-        
-        file_paths = [Path("/workspace/image.png")]
-        
-        result = build_user_input(self.session_tuple, self.user_text, file_paths)
-        
-        self.assertIsInstance(result, list)
-        self.assertEqual(len(result), 2)  # Prompt + 1 binary attachment
-        self.assertIsInstance(result[0], str)
-        prompt_text = str(result[0])
-        self.assertIn("Please analyze these files", prompt_text)
-        self.assertIn("Attachments:", prompt_text)
-        self.assertIn("image.png", prompt_text)
-        self.assertIn("file_size=2048 bytes", prompt_text)
-        self.assertIn("provided to model context at index 0", prompt_text)
-        self.assertEqual(result[1], mock_binary_content)
-
-    @patch('aixtools.agents.prompt.should_be_included_into_context')
-    @patch('aixtools.agents.prompt.file_to_binary_content')
-    @patch('aixtools.agents.prompt.container_to_host_path')
-    @patch('mimetypes.guess_type')
-    def test_multiple_files_mixed_inclusion(
-        self, mock_guess_type, mock_container_to_host,
-        mock_file_to_binary, mock_should_include
-    ):
-        """Test with multiple files, some included in context, some not."""
-        # Setup mocks
-        mock_guess_type.side_effect = [("text/plain", None), ("image/png", None)]
-        mock_should_include.side_effect = [False, True]  # First file not included, second included
-        
-        mock_host_path1 = Mock()
-        mock_host_path1.stat.return_value.st_size = 1024
-        mock_host_path2 = Mock()
-        mock_host_path2.stat.return_value.st_size = 2048
-        mock_container_to_host.side_effect = [mock_host_path1, mock_host_path2]
-        
-        mock_text_content = "text content"
-        mock_binary_content = BinaryContent(data=b"image data", media_type="image/png")
-        mock_file_to_binary.side_effect = [mock_text_content, mock_binary_content]
-        
-        file_paths = [Path("/workspace/text.txt"), Path("/workspace/image.png")]
-        
-        result = build_user_input(self.session_tuple, self.user_text, file_paths)
-        
-        self.assertIsInstance(result, list)
-        self.assertEqual(len(result), 2)  # Prompt + 1 binary attachment
-        self.assertIsInstance(result[0], str)
-        prompt_text = str(result[0])
-        self.assertIn("Please analyze these files", prompt_text)
-        self.assertIn("Attachments:", prompt_text)
-        self.assertIn("text.txt", prompt_text)
-        self.assertIn("image.png", prompt_text)
-        self.assertIn("file_size=1024 bytes", prompt_text)
-        self.assertIn("file_size=2048 bytes", prompt_text)
-        self.assertIn("provided to model context at index 0", prompt_text)
-        self.assertEqual(result[1], mock_binary_content)
-
-    def test_non_workspace_path_raises_error(self):
-        """Test that non-workspace paths raise ValueError."""
-        file_paths = [Path("/invalid/path.txt")]
-        
-        with self.assertRaises(ValueError) as context:
-            build_user_input(self.session_tuple, self.user_text, file_paths)
-        
-        self.assertIn(
-            "Container path must be a subdir of '/workspace', got '/invalid/path.txt' instead",
-            str(context.exception),
-        )
-
-    @patch('aixtools.agents.prompt.should_be_included_into_context')
-    @patch('aixtools.agents.prompt.file_to_binary_content')
-    @patch('aixtools.agents.prompt.container_to_host_path')
-    @patch('mimetypes.guess_type')
-    def test_unknown_mime_type_defaults(
-        self, mock_guess_type, mock_container_to_host,
-        mock_file_to_binary, mock_should_include
-    ):
-        """Test that unknown mime types default to application/octet-stream."""
-        # Setup mocks
-        mock_guess_type.return_value = (None, None)  # Unknown mime type
-        mock_should_include.return_value = False
-        
-        mock_host_path = Mock()
-        mock_host_path.stat.return_value.st_size = 1024
-        mock_container_to_host.return_value = mock_host_path
-        
-        mock_file_to_binary.return_value = "file content"
-        
-        file_paths = [Path("/workspace/unknown.dat")]
-        
-        build_user_input(self.session_tuple, self.user_text, file_paths)
-        
-        # Verify that file_to_binary_content was called with the default mime type
-        mock_file_to_binary.assert_called_once_with(mock_host_path, "application/octet-stream")
-
-
-if __name__ == '__main__':
-    unittest.main()

tests/unit/compliance/test_private_data.py

@@ -1,329 +0,0 @@
-import json
-import unittest
-from pathlib import Path
-
-from aixtools.compliance.private_data import PrivateData, PRIVATE_DATA_FILE
-from aixtools.server.path import get_workspace_path
-
-
-class TestPrivateData(unittest.TestCase):
-    """Test cases for PrivateData class without mocking or patching."""
-
-    def setUp(self):
-        """Set up test environment with temporary directory."""        
-        # Create a test user and session context
-        self.workspace_path = Path(get_workspace_path())
-        self.workspace_path.mkdir(parents=True, exist_ok=True)
-        self.private_data_file = self.workspace_path / PRIVATE_DATA_FILE
-
-    def tearDown(self):
-        """Clean up test environment."""
-        self.private_data_file.unlink(missing_ok=True)
-
-    def test_init_no_existing_file(self):
-        """Test initialization when no private data file exists."""
-        private_data = PrivateData()
-        self.assertFalse(private_data.has_private_data)
-        self.assertEqual(private_data.get_private_datasets(), [])
-        self.assertEqual(private_data.get_idap_datasets(), [])
-
-    def test_init_with_existing_file(self):
-        """Test initialization when private data file exists."""
-        # Create a test file
-        private_data_path = self.workspace_path / PRIVATE_DATA_FILE
-        test_data = {
-            "_has_private_data": True,
-            "_private_datasets": ["dataset1", "dataset2"],
-            "_idap_datasets": ["dataset1"],
-            "ctx": None
-        }
-        with open(private_data_path, "w") as f:
-            json.dump(test_data, f)
-        
-        private_data = PrivateData()
-        
-        self.assertTrue(private_data.has_private_data)
-        self.assertEqual(set(private_data.get_private_datasets()), {"dataset1", "dataset2"})
-        self.assertEqual(private_data.get_idap_datasets(), ["dataset1"])
-
-    def test_add_private_dataset_new(self):
-        """Test adding a new private dataset."""
-        private_data = PrivateData()
-        
-        private_data.add_private_dataset("test_dataset")
-        
-        self.assertTrue(private_data.has_private_data)
-        self.assertIn("test_dataset", private_data.get_private_datasets())
-        
-        # Verify data is saved to file
-        private_data_path = self.workspace_path / PRIVATE_DATA_FILE
-        self.assertTrue(private_data_path.exists())
-        
-        with open(private_data_path, "r") as f:
-            saved_data = json.load(f)
-        
-        self.assertTrue(saved_data["_has_private_data"])
-        self.assertIn("test_dataset", saved_data["_private_datasets"])
-
-    def test_add_private_dataset_duplicate(self):
-        """Test adding a duplicate private dataset."""
-        private_data = PrivateData()
-        
-        private_data.add_private_dataset("test_dataset")
-        initial_count = len(private_data.get_private_datasets())
-        
-        private_data.add_private_dataset("test_dataset")
-        final_count = len(private_data.get_private_datasets())
-        
-        self.assertEqual(initial_count, final_count)
-        self.assertEqual(private_data.get_private_datasets().count("test_dataset"), 1)
-
-    def test_add_idap_dataset_new(self):
-        """Test adding a new IDAP dataset."""
-        private_data = PrivateData()
-        
-        private_data.add_idap_dataset("idap_dataset")
-        
-        self.assertTrue(private_data.has_private_data)
-        self.assertIn("idap_dataset", private_data.get_idap_datasets())
-        self.assertIn("idap_dataset", private_data.get_private_datasets())
-        
-        # Verify data is saved to file
-        private_data_path = self.workspace_path / PRIVATE_DATA_FILE
-        self.assertTrue(private_data_path.exists())
-        
-        with open(private_data_path, "r") as f:
-            saved_data = json.load(f)
-        
-        self.assertTrue(saved_data["_has_private_data"])
-        self.assertIn("idap_dataset", saved_data["_idap_datasets"])
-        self.assertIn("idap_dataset", saved_data["_private_datasets"])
-
-    def test_add_idap_dataset_existing_private(self):
-        """Test adding IDAP dataset when it already exists as private dataset."""
-        private_data = PrivateData()
-        
-        private_data.add_private_dataset("existing_dataset")
-        private_data.add_idap_dataset("existing_dataset")
-        
-        self.assertTrue(private_data.has_private_data)
-        self.assertIn("existing_dataset", private_data.get_idap_datasets())
-        self.assertIn("existing_dataset", private_data.get_private_datasets())
-        self.assertEqual(private_data.get_private_datasets().count("existing_dataset"), 1)
-
-    def test_add_idap_dataset_duplicate(self):
-        """Test adding a duplicate IDAP dataset."""
-        private_data = PrivateData()
-        
-        private_data.add_idap_dataset("idap_dataset")
-        initial_idap_count = len(private_data.get_idap_datasets())
-        initial_private_count = len(private_data.get_private_datasets())
-        
-        private_data.add_idap_dataset("idap_dataset")
-        final_idap_count = len(private_data.get_idap_datasets())
-        final_private_count = len(private_data.get_private_datasets())
-        
-        self.assertEqual(initial_idap_count, final_idap_count)
-        self.assertEqual(initial_private_count, final_private_count)
-
-    def test_has_private_dataset(self):
-        """Test checking if a private dataset exists."""
-        private_data = PrivateData()
-        
-        self.assertFalse(private_data.has_private_dataset("nonexistent"))
-        
-        private_data.add_private_dataset("test_dataset")
-        
-        self.assertTrue(private_data.has_private_dataset("test_dataset"))
-        self.assertFalse(private_data.has_private_dataset("nonexistent"))
-
-    def test_has_idap_dataset(self):
-        """Test checking if an IDAP dataset exists."""
-        private_data = PrivateData()
-        
-        self.assertFalse(private_data.has_idap_dataset("nonexistent"))
-        
-        private_data.add_idap_dataset("idap_dataset")
-        
-        self.assertTrue(private_data.has_idap_dataset("idap_dataset"))
-        self.assertFalse(private_data.has_idap_dataset("nonexistent"))
-
-    def test_get_datasets_returns_copies(self):
-        """Test that get methods return copies to prevent external modification."""
-        private_data = PrivateData()
-        private_data.add_private_dataset("private_dataset")
-        private_data.add_idap_dataset("idap_dataset")
-        
-        private_datasets = private_data.get_private_datasets()
-        idap_datasets = private_data.get_idap_datasets()
-        
-        # Modify the returned lists
-        private_datasets.append("external_modification")
-        idap_datasets.append("external_modification")
-        
-        # Verify original data is unchanged
-        self.assertNotIn("external_modification", private_data.get_private_datasets())
-        self.assertNotIn("external_modification", private_data.get_idap_datasets())
-
-    def test_has_private_data_setter_true(self):
-        """Test setting has_private_data to True."""
-        private_data = PrivateData()
-        
-        private_data.has_private_data = True
-        
-        self.assertTrue(private_data.has_private_data)
-        
-        # Verify data is saved to file
-        private_data_path = self.workspace_path / PRIVATE_DATA_FILE
-        self.assertTrue(private_data_path.exists())
-
-    def test_has_private_data_setter_false(self):
-        """Test setting has_private_data to False clears all data."""
-        private_data = PrivateData()
-        private_data.add_private_dataset("dataset1")
-        private_data.add_idap_dataset("dataset2")
-        
-        private_data.has_private_data = False
-        
-        self.assertFalse(private_data.has_private_data)
-        self.assertEqual(private_data.get_private_datasets(), [])
-        self.assertEqual(private_data.get_idap_datasets(), [])
-        
-        # Verify file is deleted
-        private_data_path = self.workspace_path / PRIVATE_DATA_FILE
-        self.assertFalse(private_data_path.exists())
-
-    def test_save_with_no_private_data(self):
-        """Test saving when has_private_data is False deletes the file."""
-        private_data = PrivateData()
-        private_data.add_private_dataset("test_dataset")
-        
-        # Verify file exists
-        private_data_path = self.workspace_path / PRIVATE_DATA_FILE
-        self.assertTrue(private_data_path.exists())
-        
-        private_data.has_private_data = False
-        
-        # Verify file is deleted
-        self.assertFalse(private_data_path.exists())
-
-    def test_save_with_private_data(self):
-        """Test saving when has_private_data is True creates/updates the file."""
-        private_data = PrivateData()
-        private_data.add_private_dataset("dataset1")
-        private_data.add_idap_dataset("dataset2")
-        
-        private_data_path = self.workspace_path / PRIVATE_DATA_FILE
-        self.assertTrue(private_data_path.exists())
-        
-        with open(private_data_path, "r") as f:
-            saved_data = json.load(f)
-        
-        self.assertTrue(saved_data["_has_private_data"])
-        self.assertIn("dataset1", saved_data["_private_datasets"])
-        self.assertIn("dataset2", saved_data["_private_datasets"])
-        self.assertIn("dataset2", saved_data["_idap_datasets"])
-        self.assertIsNone(saved_data["ctx"])
-
-    def test_load_from_corrupted_file(self):
-        """Test loading from a corrupted JSON file."""
-        private_data_path = self.workspace_path / PRIVATE_DATA_FILE
-        with open(private_data_path, "w") as f:
-            f.write("invalid json content")
-        
-        with self.assertRaises(json.JSONDecodeError):
-            PrivateData()
-
-    def test_load_from_file_with_missing_fields(self):
-        """Test loading from a file with missing fields uses defaults."""
-        private_data_path = self.workspace_path / PRIVATE_DATA_FILE
-        test_data = {"_has_private_data": True}  # Missing other fields
-        with open(private_data_path, "w") as f:
-            json.dump(test_data, f)
-        
-        private_data = PrivateData()
-        
-        self.assertTrue(private_data.has_private_data)
-        self.assertEqual(private_data.get_private_datasets(), [])
-        self.assertEqual(private_data.get_idap_datasets(), [])
-
-    def test_multiple_operations_persistence(self):
-        """Test that multiple operations are properly persisted."""
-        # Create first instance and add data
-        private_data1 = PrivateData()
-        private_data1.add_private_dataset("dataset1")
-        private_data1.add_idap_dataset("dataset2")
-        
-        # Create second instance and verify data is loaded
-        private_data2 = PrivateData()
-        self.assertTrue(private_data2.has_private_data)
-        self.assertIn("dataset1", private_data2.get_private_datasets())
-        self.assertIn("dataset2", private_data2.get_private_datasets())
-        self.assertIn("dataset2", private_data2.get_idap_datasets())
-        
-        # Add more data with second instance
-        private_data2.add_private_dataset("dataset3")
-        
-        # Create third instance and verify all data is present
-        private_data3 = PrivateData()
-        expected_private = {"dataset1", "dataset2", "dataset3"}
-        expected_idap = {"dataset2"}
-        
-        self.assertEqual(set(private_data3.get_private_datasets()), expected_private)
-        self.assertEqual(set(private_data3.get_idap_datasets()), expected_idap)
-
-    def test_str_and_repr(self):
-        """Test string representation methods."""
-        private_data = PrivateData()
-        private_data.add_private_dataset("dataset1")
-        private_data.add_idap_dataset("dataset2")
-        
-        str_repr = str(private_data)
-        repr_repr = repr(private_data)
-        
-        self.assertEqual(str_repr, repr_repr)
-        self.assertIn("has_private_data=True", str_repr)
-        self.assertIn("dataset1", str_repr)
-        self.assertIn("dataset2", str_repr)
-        self.assertIn(str(self.workspace_path / PRIVATE_DATA_FILE), str_repr)
-
-    def test_file_operations_create_directories(self):
-        """Test that file operations create necessary directories."""
-        # Remove the workspace directory
-        import shutil
-        shutil.rmtree(self.workspace_path)
-        self.assertFalse(self.workspace_path.exists())
-        
-        # Create PrivateData instance and add data
-        private_data = PrivateData()
-        private_data.add_private_dataset("test_dataset")
-        
-        # Verify directory and file were created
-        self.assertTrue(self.workspace_path.exists())
-        private_data_path = self.workspace_path / PRIVATE_DATA_FILE
-        self.assertTrue(private_data_path.exists())
-
-    def test_concurrent_modifications_simulation(self):
-        """Test simulation of concurrent modifications (without actual threading)."""
-        # Create two instances with same context
-        private_data1 = PrivateData()
-        private_data2 = PrivateData()
-        
-        # Add data with first instance
-        private_data1.add_private_dataset("dataset1")
-        
-        # Second instance should see the changes when reloaded
-        private_data2.load()
-        self.assertIn("dataset1", private_data2.get_private_datasets())
-        
-        # Add data with second instance
-        private_data2.add_idap_dataset("dataset2")
-        
-        # First instance should see the changes when reloaded
-        private_data1.load()
-        self.assertIn("dataset2", private_data1.get_idap_datasets())
-        self.assertIn("dataset2", private_data1.get_private_datasets())
-
-
-if __name__ == "__main__":
-    unittest.main()