cognee 0.5.1.dev0__py3-none-any.whl → 0.5.2__py3-none-any.whl

cognee/tests/unit/modules/users/test_tutorial_notebook_creation.py

@@ -1,19 +1,29 @@
-import json
 import pytest
 from unittest.mock import AsyncMock, patch, MagicMock
-import hashlib
-import time
-from uuid import uuid4
-from sqlalchemy.ext.asyncio import AsyncSession
+from uuid import uuid4, uuid5, NAMESPACE_OID
 from pathlib import Path
-import zipfile
-from cognee.shared.cache import get_tutorial_data_dir
-
-from cognee.modules.notebooks.methods.create_notebook import _create_tutorial_notebook
-from cognee.modules.notebooks.models.Notebook import Notebook
-import cognee
+from sqlalchemy.ext.asyncio import AsyncSession
+import tempfile
+import shutil
+import importlib
+
+from cognee.modules.notebooks.methods.create_tutorial_notebooks import (
+    create_tutorial_notebooks,
+    _parse_cell_index,
+    _get_cell_type,
+    _extract_markdown_heading,
+    _get_cell_name,
+    _format_tutorial_name,
+    _load_tutorial_cells,
+)
+
+from cognee.modules.notebooks.models.Notebook import Notebook, NotebookCell
 from cognee.shared.logging_utils import get_logger
 
+create_tutorial_notebooks_module = importlib.import_module(
+    "cognee.modules.notebooks.methods.create_tutorial_notebooks"
+)
+
 logger = get_logger()
 
 
@@ -28,372 +38,576 @@ def mock_session():
 
 
 @pytest.fixture
-def sample_jupyter_notebook():
-    """Sample Jupyter notebook content for testing."""
-    return {
-        "cells": [
-            {
-                "cell_type": "markdown",
-                "metadata": {},
-                "source": ["# Tutorial Introduction\n", "\n", "This is a tutorial notebook."],
-            },
-            {
-                "cell_type": "code",
-                "execution_count": None,
-                "metadata": {},
-                "outputs": [],
-                "source": ["import cognee\n", "print('Hello, Cognee!')"],
-            },
-            {
-                "cell_type": "markdown",
-                "metadata": {},
-                "source": ["## Step 1: Data Ingestion\n", "\n", "Let's add some data."],
-            },
-            {
-                "cell_type": "code",
-                "execution_count": None,
-                "metadata": {},
-                "outputs": [],
-                "source": ["# Add your data here\n", "# await cognee.add('data.txt')"],
-            },
-            {
-                "cell_type": "raw",
-                "metadata": {},
-                "source": ["This is a raw cell that should be skipped"],
-            },
-        ],
-        "metadata": {
-            "kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"}
-        },
-        "nbformat": 4,
-        "nbformat_minor": 4,
-    }
+def temp_tutorials_dir():
+    """Create a temporary tutorials directory for testing."""
+    temp_dir = Path(tempfile.mkdtemp())
+    tutorials_dir = temp_dir / "tutorials"
+    tutorials_dir.mkdir(parents=True)
+    yield tutorials_dir
+    shutil.rmtree(temp_dir)
+
+
+class TestTutorialNotebookHelperFunctions:
+    """Test cases for helper functions used in tutorial notebook creation."""
+
+    def test_parse_cell_index_valid(self):
+        """Test parsing valid cell index from filename."""
+        assert _parse_cell_index("cell-0.md") == 0
+        assert _parse_cell_index("cell-1.py") == 1
+        assert _parse_cell_index("cell-123.md") == 123
+        assert _parse_cell_index("cell-999.py") == 999
+
+    def test_parse_cell_index_invalid(self):
+        """Test parsing invalid cell index returns -1."""
+        assert _parse_cell_index("not-a-cell.md") == -1
+        assert _parse_cell_index("cell.md") == -1
+        assert _parse_cell_index("cell-.md") == -1
+        assert _parse_cell_index("") == -1
+
+    def test_get_cell_type_markdown(self):
+        """Test cell type detection for markdown files."""
+        assert _get_cell_type(Path("cell-1.md")) == "markdown"
+        assert _get_cell_type(Path("test.MD")) == "markdown"
+
+    def test_get_cell_type_code(self):
+        """Test cell type detection for Python files."""
+        assert _get_cell_type(Path("cell-1.py")) == "code"
+        assert _get_cell_type(Path("test.PY")) == "code"
+
+    def test_get_cell_type_unsupported(self):
+        """Test error handling for unsupported file types."""
+        with pytest.raises(ValueError, match="Unsupported cell file type"):
+            _get_cell_type(Path("cell-1.txt"))
+
+    def test_extract_markdown_heading_single_hash(self):
+        """Test extracting heading from markdown with single #."""
+        content = "# My Heading\nSome content here"
+        assert _extract_markdown_heading(content) == "My Heading"
+
+    def test_extract_markdown_heading_multiple_hash(self):
+        """Test extracting heading from markdown with multiple #."""
+        content = "## Subheading\nSome content"
+        assert _extract_markdown_heading(content) == "Subheading"
+
+    def test_extract_markdown_heading_with_whitespace(self):
+        """Test extracting heading with leading/trailing whitespace."""
+        content = "  #   Heading with spaces  \nContent"
+        assert _extract_markdown_heading(content) == "Heading with spaces"
+
+    def test_extract_markdown_heading_no_heading(self):
+        """Test extracting heading when no heading exists."""
+        content = "Just some regular text\nNo heading here"
+        assert _extract_markdown_heading(content) is None
+
+    def test_extract_markdown_heading_empty(self):
+        """Test extracting heading from empty content."""
+        assert _extract_markdown_heading("") is None
+
+    def test_get_cell_name_code_cell(self):
+        """Test cell name generation for code cells."""
+        cell_file = Path("cell-1.py")
+        content = "print('Hello, World!')"
+        assert _get_cell_name(cell_file, "code", content) == "Code Cell"
+
+    def test_get_cell_name_markdown_with_heading(self):
+        """Test cell name generation for markdown cells with heading."""
+        cell_file = Path("cell-1.md")
+        content = "# My Tutorial Title\nSome content"
+        assert _get_cell_name(cell_file, "markdown", content) == "My Tutorial Title"
+
+    def test_get_cell_name_markdown_no_heading(self):
+        """Test cell name generation for markdown cells without heading."""
+        cell_file = Path("cell-1.md")
+        content = "Just some text without heading"
+        assert _get_cell_name(cell_file, "markdown", content) == "cell-1"
+
+    def test_format_tutorial_name_simple(self):
+        """Test formatting simple tutorial directory name."""
+        assert _format_tutorial_name("cognee-basics") == "Cognee basics - tutorial 🧠"
+
+    def test_format_tutorial_name_with_underscores(self):
+        """Test formatting tutorial name with underscores."""
+        assert _format_tutorial_name("python_development") == "Python development - tutorial 🧠"
+
+    def test_format_tutorial_name_mixed(self):
+        """Test formatting tutorial name with mixed separators."""
+        assert _format_tutorial_name("my-tutorial_name") == "My tutorial name - tutorial 🧠"
+
+
+class TestLoadTutorialCells:
+    """Test cases for loading cells from tutorial directories."""
 
+    def test_load_tutorial_cells_sorted_order(self, temp_tutorials_dir):
+        """Test that cells are loaded in sorted order by index."""
+        # Create cells out of order
+        (temp_tutorials_dir / "cell-3.md").write_text("# Third")
+        (temp_tutorials_dir / "cell-1.md").write_text("# First")
+        (temp_tutorials_dir / "cell-2.py").write_text("print('second')")
 
-class TestTutorialNotebookCreation:
-    """Test cases for tutorial notebook creation functionality."""
+        cells = _load_tutorial_cells(temp_tutorials_dir)
+
+        assert len(cells) == 3
+        assert cells[0].name == "First"
+        assert cells[1].name == "Code Cell"
+        assert cells[2].name == "Third"
+
+    def test_load_tutorial_cells_skips_non_cell_files(self, temp_tutorials_dir):
+        """Test that non-cell files are skipped."""
+        (temp_tutorials_dir / "cell-1.md").write_text("# First")
+        (temp_tutorials_dir / "config.json").write_text('{"name": "test"}')
+        (temp_tutorials_dir / "README.md").write_text("# Readme")
+        (temp_tutorials_dir / "data").mkdir()
+        (temp_tutorials_dir / "data" / "file.txt").write_text("data")
+
+        cells = _load_tutorial_cells(temp_tutorials_dir)
+
+        assert len(cells) == 1
+        assert cells[0].name == "First"
+
+    def test_load_tutorial_cells_skips_unsupported_extensions(self, temp_tutorials_dir):
+        """Test that unsupported file extensions are skipped."""
+        (temp_tutorials_dir / "cell-1.md").write_text("# First")
+        (temp_tutorials_dir / "cell-2.txt").write_text("Text file")
+        (temp_tutorials_dir / "cell-3.py").write_text("print('code')")
+
+        cells = _load_tutorial_cells(temp_tutorials_dir)
+
+        assert len(cells) == 2
+        assert cells[0].name == "First"
+        assert cells[1].name == "Code Cell"
+
+    def test_load_tutorial_cells_empty_directory(self, temp_tutorials_dir):
+        """Test loading cells from empty directory."""
+        cells = _load_tutorial_cells(temp_tutorials_dir)
+        assert len(cells) == 0
+
+    def test_load_tutorial_cells_preserves_content(self, temp_tutorials_dir):
+        """Test that cell content is preserved correctly."""
+        markdown_content = "# My Heading\n\nSome content here."
+        code_content = "import cognee\nprint('Hello')"
+
+        (temp_tutorials_dir / "cell-1.md").write_text(markdown_content)
+        (temp_tutorials_dir / "cell-2.py").write_text(code_content)
+
+        cells = _load_tutorial_cells(temp_tutorials_dir)
+
+        assert len(cells) == 2
+        assert cells[0].content == markdown_content
+        assert cells[0].type == "markdown"
+        assert cells[1].content == code_content
+        assert cells[1].type == "code"
+
+
+class TestCreateTutorialNotebooks:
+    """Test cases for the main create_tutorial_notebooks function."""
 
     @pytest.mark.asyncio
-    async def test_notebook_from_ipynb_string_success(self, sample_jupyter_notebook):
-        """Test successful creation of notebook from JSON string."""
-        notebook_json = json.dumps(sample_jupyter_notebook)
+    async def test_create_tutorial_notebooks_success_with_config(
+        self, mock_session, temp_tutorials_dir
+    ):
+        """Test successful creation of tutorial notebooks with config.json."""
+        import json
+
         user_id = uuid4()
 
-        notebook = Notebook.from_ipynb_string(
-            notebook_content=notebook_json, owner_id=user_id, name="String Test Notebook"
+        # Create a tutorial directory with cells and config.json
+        tutorial_dir = temp_tutorials_dir / "test-tutorial"
+        tutorial_dir.mkdir()
+        (tutorial_dir / "cell-1.md").write_text("# Introduction\nWelcome to the tutorial")
+        (tutorial_dir / "cell-2.py").write_text("print('Hello')")
+        (tutorial_dir / "config.json").write_text(
+            json.dumps({"name": "Custom Tutorial Name", "deletable": False})
         )
 
-        assert notebook.owner_id == user_id
-        assert notebook.name == "String Test Notebook"
-        assert len(notebook.cells) == 4  # Should skip the raw cell
-        assert notebook.cells[0].type == "markdown"
-        assert notebook.cells[1].type == "code"
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = temp_tutorials_dir
+
+            await create_tutorial_notebooks(user_id, mock_session)
+
+        # Verify notebook was added to session
+        assert mock_session.add.call_count == 1
+        added_notebook = mock_session.add.call_args[0][0]
+
+        assert isinstance(added_notebook, Notebook)
+        assert added_notebook.owner_id == user_id
+        assert added_notebook.name == "Custom Tutorial Name"
+        assert len(added_notebook.cells) == 2
+        assert added_notebook.deletable is False
+
+        # Verify deterministic ID generation based on config name
+        expected_id = uuid5(NAMESPACE_OID, name="Custom Tutorial Name")
+        assert added_notebook.id == expected_id
+
+        # Verify commit was called
+        mock_session.commit.assert_called_once()
 
     @pytest.mark.asyncio
-    async def test_notebook_cell_name_generation(self, sample_jupyter_notebook):
-        """Test that cell names are generated correctly from markdown headers."""
+    async def test_create_tutorial_notebooks_success_without_config(
+        self, mock_session, temp_tutorials_dir
+    ):
+        """Test successful creation of tutorial notebooks without config.json (fallback)."""
         user_id = uuid4()
-        notebook_json = json.dumps(sample_jupyter_notebook)
 
-        notebook = Notebook.from_ipynb_string(notebook_content=notebook_json, owner_id=user_id)
+        # Create a tutorial directory with cells but no config.json
+        tutorial_dir = temp_tutorials_dir / "test-tutorial"
+        tutorial_dir.mkdir()
+        (tutorial_dir / "cell-1.md").write_text("# Introduction\nWelcome to the tutorial")
+        (tutorial_dir / "cell-2.py").write_text("print('Hello')")
+
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = temp_tutorials_dir
+
+            await create_tutorial_notebooks(user_id, mock_session)
+
+        # Verify notebook was added to session
+        assert mock_session.add.call_count == 1
+        added_notebook = mock_session.add.call_args[0][0]
 
-        # Check markdown header extraction
-        assert notebook.cells[0].name == "Tutorial Introduction"
-        assert notebook.cells[2].name == "Step 1: Data Ingestion"
+        assert isinstance(added_notebook, Notebook)
+        assert added_notebook.owner_id == user_id
+        assert added_notebook.name == "Test tutorial - tutorial 🧠"
+        assert len(added_notebook.cells) == 2
+        assert added_notebook.deletable is False  # Default for tutorials
 
-        # Check code cell naming
-        assert notebook.cells[1].name == "Code Cell"
-        assert notebook.cells[3].name == "Code Cell"
+        # Verify deterministic ID generation
+        expected_id = uuid5(NAMESPACE_OID, name="Test tutorial - tutorial 🧠")
+        assert added_notebook.id == expected_id
+
+        # Verify commit was called
+        mock_session.commit.assert_called_once()
 
     @pytest.mark.asyncio
-    async def test_notebook_from_ipynb_string_with_default_name(self, sample_jupyter_notebook):
-        """Test notebook creation uses kernelspec display_name when no name provided."""
+    async def test_create_tutorial_notebooks_multiple_tutorials(
+        self, mock_session, temp_tutorials_dir
+    ):
+        """Test creation of multiple tutorial notebooks."""
         user_id = uuid4()
-        notebook_json = json.dumps(sample_jupyter_notebook)
 
-        notebook = Notebook.from_ipynb_string(notebook_content=notebook_json, owner_id=user_id)
+        # Create two tutorial directories
+        tutorial1 = temp_tutorials_dir / "tutorial-one"
+        tutorial1.mkdir()
+        (tutorial1 / "cell-1.md").write_text("# Tutorial One")
+
+        tutorial2 = temp_tutorials_dir / "tutorial-two"
+        tutorial2.mkdir()
+        (tutorial2 / "cell-1.md").write_text("# Tutorial Two")
+
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = temp_tutorials_dir
 
-        assert notebook.name == "Python 3"  # From kernelspec.display_name
+            await create_tutorial_notebooks(user_id, mock_session)
+
+        # Verify both notebooks were added
+        assert mock_session.add.call_count == 2
+        mock_session.commit.assert_called_once()
 
     @pytest.mark.asyncio
-    async def test_notebook_from_ipynb_string_fallback_name(self):
-        """Test fallback naming when kernelspec is missing."""
-        minimal_notebook = {
-            "cells": [{"cell_type": "markdown", "metadata": {}, "source": ["# Test"]}],
-            "metadata": {},  # No kernelspec
-            "nbformat": 4,
-            "nbformat_minor": 4,
-        }
+    async def test_create_tutorial_notebooks_skips_empty_tutorials(
+        self, mock_session, temp_tutorials_dir
+    ):
+        """Test that tutorials with no cells are skipped."""
+        user_id = uuid4()
+
+        # Create tutorial directory without cells
+        tutorial_dir = temp_tutorials_dir / "empty-tutorial"
+        tutorial_dir.mkdir()
+
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = temp_tutorials_dir
+
+            await create_tutorial_notebooks(user_id, mock_session)
+
+        # Verify no notebooks were added
+        mock_session.add.assert_not_called()
+        mock_session.commit.assert_not_called()
 
+    @pytest.mark.asyncio
+    async def test_create_tutorial_notebooks_skips_hidden_directories(
+        self, mock_session, temp_tutorials_dir
+    ):
+        """Test that hidden directories (starting with .) are skipped."""
         user_id = uuid4()
-        notebook_json = json.dumps(minimal_notebook)
 
-        notebook = Notebook.from_ipynb_string(notebook_content=notebook_json, owner_id=user_id)
+        # Create hidden tutorial directory
+        hidden_tutorial = temp_tutorials_dir / ".hidden-tutorial"
+        hidden_tutorial.mkdir()
+        (hidden_tutorial / "cell-1.md").write_text("# Hidden")
+
+        # Create visible tutorial directory
+        visible_tutorial = temp_tutorials_dir / "visible-tutorial"
+        visible_tutorial.mkdir()
+        (visible_tutorial / "cell-1.md").write_text("# Visible")
+
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = temp_tutorials_dir
+
+            await create_tutorial_notebooks(user_id, mock_session)
 
-        assert notebook.name == "Imported Notebook"  # Fallback name
+        # Verify only visible tutorial was added
+        assert mock_session.add.call_count == 1
+        added_notebook = mock_session.add.call_args[0][0]
+        assert added_notebook.name == "Visible tutorial - tutorial 🧠"
 
     @pytest.mark.asyncio
-    async def test_notebook_from_ipynb_string_invalid_json(self):
-        """Test error handling for invalid JSON."""
+    async def test_create_tutorial_notebooks_missing_directory(self, mock_session):
+        """Test handling when tutorials directory doesn't exist."""
         user_id = uuid4()
-        invalid_json = "{ invalid json content"
 
-        from nbformat.reader import NotJSONError
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = Path("/nonexistent/tutorials/dir")
 
-        with pytest.raises(NotJSONError):
-            Notebook.from_ipynb_string(notebook_content=invalid_json, owner_id=user_id)
+            await create_tutorial_notebooks(user_id, mock_session)
+
+        # Verify no notebooks were added and no commit
+        mock_session.add.assert_not_called()
+        mock_session.commit.assert_not_called()
 
     @pytest.mark.asyncio
-    @patch.object(Notebook, "from_ipynb_zip_url")
-    async def test_create_tutorial_notebook_error_propagated(self, mock_from_zip_url, mock_session):
-        """Test that errors are propagated when zip fetch fails."""
+    async def test_create_tutorial_notebooks_empty_directory(
+        self, mock_session, temp_tutorials_dir
+    ):
+        """Test handling when tutorials directory is empty."""
         user_id = uuid4()
-        mock_from_zip_url.side_effect = Exception("Network error")
 
-        # Should raise the exception (not catch it)
-        with pytest.raises(Exception, match="Network error"):
-            await _create_tutorial_notebook(user_id, mock_session)
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = temp_tutorials_dir
+
+            await create_tutorial_notebooks(user_id, mock_session)
 
-        # Verify error handling path was taken
-        mock_from_zip_url.assert_called_once()
+        # Verify no notebooks were added
         mock_session.add.assert_not_called()
         mock_session.commit.assert_not_called()
 
-    def test_generate_cell_name_code_cell(self):
-        """Test cell name generation for code cells."""
-        from nbformat.notebooknode import NotebookNode
+    @pytest.mark.asyncio
+    async def test_create_tutorial_notebooks_handles_cell_loading_error(
+        self, mock_session, temp_tutorials_dir
+    ):
+        """Test that errors loading individual cells don't stop notebook creation."""
+        user_id = uuid4()
 
-        mock_cell = NotebookNode(
-            {"cell_type": "code", "source": 'import pandas as pd\nprint("Hello world")'}
-        )
+        tutorial_dir = temp_tutorials_dir / "test-tutorial"
+        tutorial_dir.mkdir()
+        (tutorial_dir / "cell-1.md").write_text("# Valid Cell")
+        # Create a file that will cause an error (invalid extension that passes filter)
+        invalid_file = tutorial_dir / "cell-2.invalid"
+        invalid_file.write_text("Invalid content")
+
+        with patch.object(create_tutorial_notebooks_module, "_load_tutorial_cells") as mock_load:
+            # Simulate error loading one cell but others succeed
+            mock_load.return_value = [
+                NotebookCell(id=uuid4(), type="markdown", name="Valid Cell", content="# Valid Cell")
+            ]
 
-        result = Notebook._generate_cell_name(mock_cell)
-        assert result == "Code Cell"
+            with patch.object(
+                create_tutorial_notebooks_module, "_get_tutorials_directory"
+            ) as mock_get_dir:
+                mock_get_dir.return_value = temp_tutorials_dir
 
+                await create_tutorial_notebooks(user_id, mock_session)
 
-class TestTutorialNotebookZipFunctionality:
-    """Test cases for zip-based tutorial functionality."""
+        # Verify notebook was still created with valid cells
+        assert mock_session.add.call_count == 1
+        mock_session.commit.assert_called_once()
 
     @pytest.mark.asyncio
-    async def test_notebook_from_ipynb_zip_url_missing_notebook(
-        self,
+    async def test_create_tutorial_notebooks_handles_tutorial_error_gracefully(
+        self, mock_session, temp_tutorials_dir
     ):
-        """Test error handling when notebook file is missing from zip."""
+        """Test that errors in one tutorial don't prevent others from being created."""
         user_id = uuid4()
 
-        with pytest.raises(
-            FileNotFoundError,
-            match="Notebook file 'super_random_tutorial_name.ipynb' not found in zip",
-        ):
-            await Notebook.from_ipynb_zip_url(
-                zip_url="https://github.com/topoteretes/cognee/raw/notebook_tutorial/notebooks/starter_tutorial.zip",
-                owner_id=user_id,
-                notebook_filename="super_random_tutorial_name.ipynb",
-            )
+        # Create two tutorials - one will fail, one will succeed
+        tutorial1 = temp_tutorials_dir / "working-tutorial"
+        tutorial1.mkdir()
+        (tutorial1 / "cell-1.md").write_text("# Working")
+
+        tutorial2 = temp_tutorials_dir / "broken-tutorial"
+        tutorial2.mkdir()
+        # Create a file that will cause an error when trying to determine cell type
+        (tutorial2 / "cell-1.txt").write_text("Invalid")
+
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = temp_tutorials_dir
+
+            await create_tutorial_notebooks(user_id, mock_session)
+
+        # Verify working tutorial was created
+        assert mock_session.add.call_count == 1
+        added_notebook = mock_session.add.call_args[0][0]
+        assert added_notebook.name == "Working tutorial - tutorial 🧠"
+        mock_session.commit.assert_called_once()
 
     @pytest.mark.asyncio
-    async def test_notebook_from_ipynb_zip_url_download_failure(self):
-        """Test error handling when zip download fails."""
+    async def test_create_tutorial_notebooks_deterministic_ids(
+        self, mock_session, temp_tutorials_dir
+    ):
+        """Test that tutorial notebooks have deterministic IDs based on name."""
         user_id = uuid4()
-        with pytest.raises(RuntimeError, match="Failed to download tutorial zip"):
-            await Notebook.from_ipynb_zip_url(
-                zip_url="https://github.com/topoteretes/cognee/raw/notebook_tutorial/notebooks/nonexistent_tutorial_name.zip",
-                owner_id=user_id,
-            )
 
-    @pytest.mark.asyncio
-    async def test_create_tutorial_notebook_zip_success(self, mock_session):
-        """Test successful tutorial notebook creation with zip."""
-        await cognee.prune.prune_data()
-        await cognee.prune.prune_system(metadata=True)
+        tutorial_dir = temp_tutorials_dir / "test-tutorial"
+        tutorial_dir.mkdir()
+        (tutorial_dir / "cell-1.md").write_text("# Test")
 
-        user_id = uuid4()
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = temp_tutorials_dir
 
-        # Check that tutorial data directory is empty using storage-aware method
-        tutorial_data_dir_path = await get_tutorial_data_dir()
-        tutorial_data_dir = Path(tutorial_data_dir_path)
-        if tutorial_data_dir.exists():
-            assert not any(tutorial_data_dir.iterdir()), "Tutorial data directory should be empty"
+            # Create notebooks twice
+            await create_tutorial_notebooks(user_id, mock_session)
+            first_notebook = mock_session.add.call_args[0][0]
+            first_id = first_notebook.id
 
-        await _create_tutorial_notebook(user_id, mock_session)
+            # Reset mocks
+            mock_session.add.reset_mock()
+            mock_session.commit.reset_mock()
 
-        items = list(tutorial_data_dir.iterdir())
-        assert len(items) == 1, "Tutorial data directory should contain exactly one item"
-        assert items[0].is_dir(), "Tutorial data directory item should be a directory"
+            await create_tutorial_notebooks(user_id, mock_session)
+            second_notebook = mock_session.add.call_args[0][0]
+            second_id = second_notebook.id
 
-        # Verify the structure inside the tutorial directory
-        tutorial_dir = items[0]
+            # IDs should be the same (deterministic)
+            assert first_id == second_id
+            assert first_id == uuid5(NAMESPACE_OID, name="Test tutorial - tutorial 🧠")
 
-        # Check for tutorial.ipynb file
-        notebook_file = tutorial_dir / "tutorial.ipynb"
-        assert notebook_file.exists(), f"tutorial.ipynb should exist in {tutorial_dir}"
-        assert notebook_file.is_file(), "tutorial.ipynb should be a file"
+    @pytest.mark.asyncio
+    async def test_create_tutorial_notebooks_with_config_deletable(
+        self, mock_session, temp_tutorials_dir
+    ):
+        """Test that deletable flag from config.json is respected."""
+        import json
 
-        # Check for data subfolder with contents
-        data_folder = tutorial_dir / "data"
-        assert data_folder.exists(), f"data subfolder should exist in {tutorial_dir}"
-        assert data_folder.is_dir(), "data should be a directory"
+        user_id = uuid4()
 
-        data_items = list(data_folder.iterdir())
-        assert len(data_items) > 0, (
-            f"data folder should contain files, but found {len(data_items)} items"
+        tutorial_dir = temp_tutorials_dir / "test-tutorial"
+        tutorial_dir.mkdir()
+        (tutorial_dir / "cell-1.md").write_text("# Test")
+        (tutorial_dir / "config.json").write_text(
+            json.dumps({"name": "Test Tutorial", "deletable": True})
         )
 
-    @pytest.mark.asyncio
-    async def test_create_tutorial_notebook_with_force_refresh(self, mock_session):
-        """Test tutorial notebook creation with force refresh."""
-        await cognee.prune.prune_data()
-        await cognee.prune.prune_system(metadata=True)
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = temp_tutorials_dir
 
-        user_id = uuid4()
+            await create_tutorial_notebooks(user_id, mock_session)
 
-        # Check that tutorial data directory is empty using storage-aware method
-        tutorial_data_dir_path = await get_tutorial_data_dir()
-        tutorial_data_dir = Path(tutorial_data_dir_path)
-        if tutorial_data_dir.exists():
-            assert not any(tutorial_data_dir.iterdir()), "Tutorial data directory should be empty"
+        added_notebook = mock_session.add.call_args[0][0]
+        assert added_notebook.deletable is True
 
-        # First creation (without force refresh)
-        await _create_tutorial_notebook(user_id, mock_session, force_refresh=False)
+    @pytest.mark.asyncio
+    async def test_create_tutorial_notebooks_config_missing_name(
+        self, mock_session, temp_tutorials_dir
+    ):
+        """Test that missing name in config.json falls back to formatted directory name."""
+        import json
 
-        items_first = list(tutorial_data_dir.iterdir())
-        assert len(items_first) == 1, (
-            "Tutorial data directory should contain exactly one item after first creation"
-        )
-        first_dir = items_first[0]
-        assert first_dir.is_dir(), "Tutorial data directory item should be a directory"
+        user_id = uuid4()
 
-        # Verify the structure inside the tutorial directory (first creation)
-        notebook_file = first_dir / "tutorial.ipynb"
-        assert notebook_file.exists(), f"tutorial.ipynb should exist in {first_dir}"
-        assert notebook_file.is_file(), "tutorial.ipynb should be a file"
+        tutorial_dir = temp_tutorials_dir / "test-tutorial"
+        tutorial_dir.mkdir()
+        (tutorial_dir / "cell-1.md").write_text("# Test")
+        (tutorial_dir / "config.json").write_text(json.dumps({"deletable": False}))
 
-        data_folder = first_dir / "data"
-        assert data_folder.exists(), f"data subfolder should exist in {first_dir}"
-        assert data_folder.is_dir(), "data should be a directory"
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = temp_tutorials_dir
 
-        data_items = list(data_folder.iterdir())
-        assert len(data_items) > 0, (
-            f"data folder should contain files, but found {len(data_items)} items"
-        )
+            await create_tutorial_notebooks(user_id, mock_session)
 
-        # Capture metadata from first creation
+        added_notebook = mock_session.add.call_args[0][0]
+        assert added_notebook.name == "Test tutorial - tutorial 🧠"
 
-        first_creation_metadata = {}
+    @pytest.mark.asyncio
+    async def test_create_tutorial_notebooks_invalid_config_json(
+        self, mock_session, temp_tutorials_dir
+    ):
+        """Test that invalid config.json is handled gracefully."""
+        user_id = uuid4()
 
-        for file_path in first_dir.rglob("*"):
-            if file_path.is_file():
-                relative_path = file_path.relative_to(first_dir)
-                stat = file_path.stat()
+        tutorial_dir = temp_tutorials_dir / "test-tutorial"
+        tutorial_dir.mkdir()
+        (tutorial_dir / "cell-1.md").write_text("# Test")
+        (tutorial_dir / "config.json").write_text("{ invalid json }")
 
-                # Store multiple metadata points
-                with open(file_path, "rb") as f:
-                    content = f.read()
+        with patch.object(
+            create_tutorial_notebooks_module, "_get_tutorials_directory"
+        ) as mock_get_dir:
+            mock_get_dir.return_value = temp_tutorials_dir
 
-                first_creation_metadata[str(relative_path)] = {
-                    "mtime": stat.st_mtime,
-                    "size": stat.st_size,
-                    "hash": hashlib.md5(content).hexdigest(),
-                    "first_bytes": content[:100]
-                    if content
-                    else b"",  # First 100 bytes as fingerprint
-                }
+            # Should not raise, should fall back to formatted name
+            await create_tutorial_notebooks(user_id, mock_session)
 
-        # Wait a moment to ensure different timestamps
-        time.sleep(0.1)
+        added_notebook = mock_session.add.call_args[0][0]
+        assert added_notebook.name == "Test tutorial - tutorial 🧠"
 
-        # Force refresh - should create new files with different metadata
-        await _create_tutorial_notebook(user_id, mock_session, force_refresh=True)
 
-        items_second = list(tutorial_data_dir.iterdir())
-        assert len(items_second) == 1, (
-            "Tutorial data directory should contain exactly one item after force refresh"
-        )
-        second_dir = items_second[0]
+class TestNotebookFromIpynbString:
+    """Test cases for Notebook.from_ipynb_string (legacy method, still used)."""
 
-        # Verify the structure is maintained after force refresh
-        notebook_file_second = second_dir / "tutorial.ipynb"
-        assert notebook_file_second.exists(), (
-            f"tutorial.ipynb should exist in {second_dir} after force refresh"
-        )
-        assert notebook_file_second.is_file(), "tutorial.ipynb should be a file after force refresh"
+    def test_notebook_from_ipynb_string_success(self):
+        """Test successful creation of notebook from JSON string."""
+        import json
+
+        sample_notebook = {
+            "cells": [
+                {
+                    "cell_type": "markdown",
+                    "metadata": {},
+                    "source": ["# Tutorial Introduction\n", "\n", "This is a tutorial notebook."],
+                },
+                {
+                    "cell_type": "code",
+                    "execution_count": None,
+                    "metadata": {},
+                    "outputs": [],
+                    "source": ["import cognee\n", "print('Hello, Cognee!')"],
+                },
+            ],
+            "metadata": {
+                "kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"}
+            },
+            "nbformat": 4,
+            "nbformat_minor": 4,
+        }
 
-        data_folder_second = second_dir / "data"
-        assert data_folder_second.exists(), (
-            f"data subfolder should exist in {second_dir} after force refresh"
-        )
-        assert data_folder_second.is_dir(), "data should be a directory after force refresh"
+        notebook_json = json.dumps(sample_notebook)
+        user_id = uuid4()
 
-        data_items_second = list(data_folder_second.iterdir())
-        assert len(data_items_second) > 0, (
-            f"data folder should still contain files after force refresh, but found {len(data_items_second)} items"
+        notebook = Notebook.from_ipynb_string(
+            notebook_content=notebook_json, owner_id=user_id, name="String Test Notebook"
         )
 
-        # Compare metadata to ensure files are actually different
-        files_with_changed_metadata = 0
-
-        for file_path in second_dir.rglob("*"):
-            if file_path.is_file():
-                relative_path = file_path.relative_to(second_dir)
-                relative_path_str = str(relative_path)
-
-                # File should exist from first creation
-                assert relative_path_str in first_creation_metadata, (
-                    f"File {relative_path_str} missing from first creation"
-                )
-
-                old_metadata = first_creation_metadata[relative_path_str]
-
-                # Get new metadata
-                stat = file_path.stat()
-                with open(file_path, "rb") as f:
-                    new_content = f.read()
-
-                new_metadata = {
-                    "mtime": stat.st_mtime,
-                    "size": stat.st_size,
-                    "hash": hashlib.md5(new_content).hexdigest(),
-                    "first_bytes": new_content[:100] if new_content else b"",
-                }
-
-                # Check if any metadata changed (indicating file was refreshed)
-                metadata_changed = (
-                    new_metadata["mtime"] > old_metadata["mtime"]  # Newer modification time
-                    or new_metadata["hash"] != old_metadata["hash"]  # Different content hash
-                    or new_metadata["size"] != old_metadata["size"]  # Different file size
-                    or new_metadata["first_bytes"]
-                    != old_metadata["first_bytes"]  # Different content
-                )
-
-                if metadata_changed:
-                    files_with_changed_metadata += 1
-
-        # Assert that force refresh actually updated files
-        assert files_with_changed_metadata > 0, (
-            f"Force refresh should have updated at least some files, but all {len(first_creation_metadata)} "
-            f"files appear to have identical metadata. This suggests force refresh didn't work."
-        )
+        assert notebook.owner_id == user_id
+        assert notebook.name == "String Test Notebook"
+        assert len(notebook.cells) == 2
+        assert notebook.cells[0].type == "markdown"
+        assert notebook.cells[1].type == "code"
 
-        mock_session.commit.assert_called()
+    def test_notebook_from_ipynb_string_invalid_json(self):
+        """Test error handling for invalid JSON."""
+        user_id = uuid4()
+        invalid_json = "{ invalid json content"
 
-    @pytest.mark.asyncio
-    async def test_tutorial_zip_url_accessibility(self):
-        """Test that the actual tutorial zip URL is accessible (integration test)."""
-        try:
-            import requests
-
-            response = requests.get(
-                "https://github.com/topoteretes/cognee/raw/notebook_tutorial/notebooks/starter_tutorial.zip",
-                timeout=10,
-            )
-            response.raise_for_status()
-
-            # Verify it's a valid zip file by checking headers
-            assert response.headers.get("content-type") in [
-                "application/zip",
-                "application/octet-stream",
-                "application/x-zip-compressed",
-            ] or response.content.startswith(b"PK")  # Zip file signature
-
-        except Exception:
-            pytest.skip("Network request failed or zip not available - skipping integration test")
+        from nbformat.reader import NotJSONError
+
+        with pytest.raises(NotJSONError):
+            Notebook.from_ipynb_string(notebook_content=invalid_json, owner_id=user_id)