navigator-session 0.7.0__tar.gz → 0.8.1__tar.gz

{navigator_session-0.7.0 → navigator_session-0.8.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: navigator-session
-Version: 0.7.0
+Version: 0.8.1
 Summary: Navigator Session allows us to store user-specific data into session object.
 Author-email: Jesus Lara Gimenez <jesuslarag@gmail.com>
-License: Apache 2.0
+License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/phenobarbital/navigator-session
 Project-URL: Source, https://github.com/phenobarbital/navigator-session
 Project-URL: Funding, https://paypal.me/phenobarbital
@@ -22,7 +22,6 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Framework :: AsyncIO
 Classifier: Framework :: aiohttp
-Classifier: License :: OSI Approved :: Apache Software License
 Requires-Python: >=3.9.13
 Description-Content-Type: text/markdown
 License-File: LICENSE

navigator_session-0.8.1/navigator_session/data.py

@@ -0,0 +1,355 @@
+import uuid
+import time
+from typing import Union, Optional, Any
+from datetime import datetime, timezone
+from collections.abc import Iterator, Mapping, MutableMapping
+import jsonpickle
+from jsonpickle.unpickler import loadclass
+from aiohttp import web
+from datamodel import BaseModel
+from .conf import (
+    SESSION_KEY,
+    SESSION_ID,
+    SESSION_STORAGE
+)
+try:
+    from pydantic import BaseModel as PydanticBaseModel
+except ImportError:
+    PydanticBaseModel = None
+
+
+class ModelHandler(jsonpickle.handlers.BaseHandler):
+    """ModelHandler.
+    This class can handle with serializable Data Models.
+    """
+    def flatten(self, obj, data):
+        data['__dict__'] = self.context.flatten(obj.__dict__, reset=False)
+        return data
+
+    def restore(self, obj):
+        module_and_type = obj['py/object']
+        mdl = loadclass(module_and_type)
+        cls = mdl.__new__(mdl) if hasattr(mdl, '__new__') else object.__new__(mdl)
+        cls.__dict__ = self.context.restore(obj['__dict__'], reset=False)
+        return cls
+
+jsonpickle.handlers.registry.register(BaseModel, ModelHandler, base=True)
+
+if PydanticBaseModel:
+    class PydanticHandler(jsonpickle.handlers.BaseHandler):
+        """PydanticHandler.
+        This class can handle with serializable Pydantic Models.
+        """
+        def flatten(self, obj, data):
+            data['__dict__'] = self.context.flatten(obj.__dict__, reset=False)
+            return data
+
+        def restore(self, obj):
+            module_and_type = obj['py/object']
+            mdl = loadclass(module_and_type)
+            cls = mdl.__new__(mdl) if hasattr(mdl, '__new__') else object.__new__(mdl)
+            cls.__dict__ = self.context.restore(obj['__dict__'], reset=False)
+            return cls
+
+    jsonpickle.handlers.registry.register(PydanticBaseModel, PydanticHandler, base=True)
+
+
+class SessionData(MutableMapping[str, Any]):
+    """Session dict-like object.
+
+    Supports both serializable data (stored in _data and persisted) and
+    in-memory objects (stored in _objects, not persisted).
+
+    Non-serializable objects (class instances, etc.) are automatically
+    stored in _objects when assigned via session.key = value or session['key'] = value.
+    """
+
+    _data: Union[str, Any] = {}
+    _objects: dict[str, Any] = {}
+
+    # Internal attributes that should not be stored in _data or _objects
+    _internal_attrs = frozenset({
+        '_data', '_objects', '_changed', '_id_', '_identity', '_new',
+        '_max_age', '_now', '__created__', '_created', '_dow', '_doy',
+        '_time', 'args'
+    })
+
+    def __init__(
+        self,
+        *args,
+        data: Optional[Mapping[str, Any]] = None,
+        new: bool = False,
+        id: Optional[str] = None,
+        identity: Optional[Any] = None,
+        max_age: Optional[int] = None
+    ) -> None:
+        # Initialize internal storage first (before any attribute access)
+        object.__setattr__(self, '_data', {})
+        object.__setattr__(self, '_objects', {})
+        object.__setattr__(self, '_changed', False)
+        # Unique ID:
+        self._id_ = (data.get(SESSION_ID, None) if data else id) or uuid.uuid4().hex
+        # Session Identity
+        self._identity = (
+            data.get(SESSION_KEY, None) if data else identity
+        ) or self._id_
+        self._new = new if data != {} else True
+        self._max_age = max_age or None
+        created = data.get('created', None) if data else None
+        self._now = datetime.now(timezone.utc)
+        self.__created__ = self._now
+        now = int(self._now.timestamp())
+        self._now = now  # time for this instance creation
+        age = now - created if created else now
+        if max_age is not None and age > max_age:
+            data = None
+        self._created = now if self._new or created is None else created
+        ## Data updating.
+        if data is not None:
+            self._data.update(data)
+        # Other mark timestamp for this session:
+        dt = datetime.now(timezone.utc)
+        self._dow = dt.weekday()
+        self._doy = dt.timetuple().tm_yday
+        self._time = dt.time()
+        self.args = args
+
+    def __repr__(self) -> str:
+        return (
+            f'<NAV-Session [new:{self.new}, created:{self.created}] '
+            f'data={self._data!r}, objects={list(self._objects.keys())}>'
+        )
+
+    # --- Serialization helpers ---
+
+    def _is_serializable(self, value: Any) -> bool:
+        """Check if a value can be reliably serialized and restored with jsonpickle.
+
+        Returns True for primitive types, dicts, lists, and known serializable models.
+        Returns False for arbitrary class instances that may not restore properly
+        in a different process/context.
+        """
+        # Primitive types are always serializable
+        if value is None or isinstance(value, (bool, int, float, str, bytes)):
+            return True
+
+        # Dicts and lists need recursive check
+        if isinstance(value, dict):
+            return all(self._is_serializable(v) for v in value.values())
+        if isinstance(value, (list, tuple, set, frozenset)):
+            return all(self._is_serializable(v) for v in value)
+
+        # BaseModel (datamodel) instances are handled by ModelHandler
+        if isinstance(value, BaseModel):
+            return True
+
+        # Pydantic models are handled by PydanticHandler
+        if PydanticBaseModel and isinstance(value, PydanticBaseModel):
+            return True
+
+        # datetime types are serializable
+        if isinstance(value, (datetime,)):
+            return True
+
+        # Any other type (class instances, functions, etc.) is NOT reliably serializable
+        # These should be stored in-memory only
+        return False
+
+    def _get_value(self, key: str) -> Any:
+        """Unified getter that checks both _objects and _data."""
+        if key in self._objects:
+            return self._objects[key]
+        if key in self._data:
+            return self._data[key]
+        raise KeyError(key)
+
+    def _set_value(self, key: str, value: Any) -> None:
+        """Unified setter that routes to _objects or _data based on serializability."""
+        if self._is_serializable(value):
+            # Remove from _objects if it was there before
+            self._objects.pop(key, None)
+            self._data[key] = value
+            self._changed = True
+        else:
+            # Store in _objects (in-memory only, not persisted)
+            # Remove from _data if it was there before
+            self._data.pop(key, None)
+            self._objects[key] = value
+            # Note: _objects changes don't set _changed since they're not persisted
+
+    def _del_value(self, key: str) -> None:
+        """Unified delete that removes from both _objects and _data."""
+        deleted = False
+        if key in self._objects:
+            del self._objects[key]
+            deleted = True
+        if key in self._data:
+            del self._data[key]
+            self._changed = True
+            deleted = True
+        if not deleted:
+            raise KeyError(key)
+
+    def _has_value(self, key: str) -> bool:
+        """Check if key exists in either _objects or _data."""
+        return key in self._objects or key in self._data
+
+    # --- Properties ---
+
+    @property
+    def new(self) -> bool:
+        return self._new
+
+    @property
+    def logon_time(self) -> datetime:
+        return self.__created__
+
+    @property
+    def session_id(self) -> str:
+        return self._id_
+
+    @property
+    def identity(self) -> Optional[Any]:  # type: ignore[misc]
+        return self._identity
+
+    @property
+    def created(self) -> int:
+        return self._created
+
+    @property
+    def dow(self) -> int:
+        return self._dow
+
+    @property
+    def session_time(self) -> time:
+        return self._time
+
+    @property
+    def empty(self) -> bool:
+        return not bool(self._data) and not bool(self._objects)
+
+    @property
+    def max_age(self) -> Optional[int]:
+        return self._max_age
+
+    @max_age.setter
+    def max_age(self, value: Optional[int]) -> None:
+        self._max_age = value
+
+    @property
+    def is_changed(self) -> bool:
+        return self._changed
+
+    @is_changed.setter
+    def is_changed(self, value: bool) -> None:
+        self._changed = value
+
+    def changed(self) -> None:
+        self._changed = True
+
+    def session_data(self) -> dict:
+        """Return only serializable data (for persistence)."""
+        return self._data
+
+    def session_objects(self) -> dict:
+        """Return in-memory objects (not persisted)."""
+        return self._objects
+
+    def invalidate(self) -> None:
+        """Clear all session data and in-memory objects."""
+        self._changed = True
+        self._data = {}
+        self._objects = {}
+
+    # --- Magic Methods ---
+
+    def __len__(self) -> int:
+        return len(self._data) + len(self._objects)
+
+    def __iter__(self) -> Iterator[str]:
+        # Iterate over both _data and _objects keys
+        seen = set()
+        for key in self._data:
+            seen.add(key)
+            yield key
+        for key in self._objects:
+            if key not in seen:
+                yield key
+
+    def __contains__(self, key: object) -> bool:
+        return self._has_value(str(key))
+
+    def __getitem__(self, key: str) -> Any:
+        return self._get_value(key)
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self._set_value(key, value)
+
+    def __delitem__(self, key: str) -> None:
+        self._del_value(key)
+
+    def __getattr__(self, key: str) -> Any:
+        # Avoid infinite recursion for internal attributes
+        if key.startswith('_'):
+            raise AttributeError(key)
+        try:
+            return self._get_value(key)
+        except KeyError:
+            raise AttributeError(key) from None
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        # Handle internal attributes normally
+        if key in self._internal_attrs or key.startswith('_'):
+            object.__setattr__(self, key, value)
+        else:
+            self._set_value(key, value)
+
+    def encode(self, obj: Any) -> str:
+        """encode
+
+            Encode an object using jsonpickle.
+        Args:
+            obj (Any): Object to be encoded using jsonpickle
+
+        Raises:
+            RuntimeError: Error converting data to json.
+
+        Returns:
+            str: json version of the data
+        """
+        try:
+            return jsonpickle.encode(obj)
+        except Exception as err:
+            raise RuntimeError(err) from err
+
+    def decode(self, key: str) -> Any:
+        """decode.
+
+            Decoding a Session Key using jsonpickle.
+        Args:
+            key (str): key name.
+
+        Raises:
+            RuntimeError: Error converting data from json.
+
+        Returns:
+            Any: object converted.
+        """
+        try:
+            value = self._data[key]
+            return jsonpickle.decode(value)
+        except KeyError:
+            # key is missing
+            return None
+        except Exception as err:
+            raise RuntimeError(err) from err
+
+    async def save_encoded_data(self, request: web.Request, key: str, obj: Any) -> None:
+        storage = request[SESSION_STORAGE]
+        try:
+            data = jsonpickle.encode(obj)
+        except RuntimeError:
+            return False
+        self._data[key] = data
+        self._changed = False
+        await storage.save_session(request, None, self)

{navigator_session-0.7.0 → navigator_session-0.8.1}/navigator_session/version.py

@@ -6,8 +6,9 @@ __description__ = (
    'Navigator Session allows us to store user-specific data '
    'into session object.'
 )
-__version__ = '0.7.0'
+__version__ = '0.8.1'
 __copyright__ = 'Copyright (c) 2023 Jesus Lara'
 __author__ = 'Jesus Lara'
 __author_email__ = 'jesuslarag@gmail.com'
 __license__ = 'Apache-2.0'
+__url__ = 'https://github.com/phenobarbital/navigator-session'

{navigator_session-0.7.0 → navigator_session-0.8.1}/navigator_session.egg-info/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: navigator-session
-Version: 0.7.0
+Version: 0.8.1
 Summary: Navigator Session allows us to store user-specific data into session object.
 Author-email: Jesus Lara Gimenez <jesuslarag@gmail.com>
-License: Apache 2.0
+License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/phenobarbital/navigator-session
 Project-URL: Source, https://github.com/phenobarbital/navigator-session
 Project-URL: Funding, https://paypal.me/phenobarbital
@@ -22,7 +22,6 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Framework :: AsyncIO
 Classifier: Framework :: aiohttp
-Classifier: License :: OSI Approved :: Apache Software License
 Requires-Python: >=3.9.13
 Description-Content-Type: text/markdown
 License-File: LICENSE

{navigator_session-0.7.0 → navigator_session-0.8.1}/navigator_session.egg-info/SOURCES.txt

@@ -29,4 +29,5 @@ navigator_session/storages/__init__.py
 navigator_session/storages/abstract.py
 navigator_session/storages/cookie.py
 navigator_session/storages/redis.py
-tests/__init__.py
+tests/__init__.py
+tests/test_session_data.py

{navigator_session-0.7.0 → navigator_session-0.8.1}/pyproject.toml

@@ -1,4 +1,3 @@
-[build-system]
 requires = [
   'setuptools>=74.0.0',
   'Cython>=3.0.11',
@@ -8,11 +7,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "navigator-session"
-version = "0.7.0"
+dynamic = ["version"]
 description = "Navigator Session allows us to store user-specific data into session object."
 readme = "README.md"
 requires-python = ">=3.9.13"
-license = { text = "Apache 2.0" }
+license = "Apache-2.0"
 authors = [
     { name = "Jesus Lara Gimenez", email = "jesuslarag@gmail.com" }
 ]
@@ -31,7 +30,6 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Framework :: AsyncIO",
     "Framework :: aiohttp",
-    "License :: OSI Approved :: Apache Software License",
 ]
 dependencies = [
     "aiohttp>=3.9.5",
@@ -60,8 +58,13 @@ Source = "https://github.com/phenobarbital/navigator-session"
 Funding = "https://paypal.me/phenobarbital"
 Documentation = "https://github.com/phenobarbital/navigator-session"
 
-[tool.setuptools]
-packages = ["navigator_session"]
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["navigator_session*"]
+exclude = ["tests*", "docs*", "examples*"]
+
+[tool.setuptools.dynamic]
+version = {attr = "navigator_session.version.__version__"}
 
 [tool.pytest.ini_options]
 addopts = [

navigator_session-0.8.1/tests/test_session_data.py

@@ -0,0 +1,542 @@
+"""
+Comprehensive tests for SessionData class.
+
+Tests cover:
+- Basic serializable data storage (_data)
+- In-memory object storage (_objects)
+- Automatic routing based on serializability
+- Magic methods (__getitem__, __setitem__, __getattr__, __setattr__, etc.)
+- Encode/decode functionality
+- Session properties and lifecycle
+"""
+import pytest
+from datetime import datetime, timezone
+from datamodel import BaseModel
+
+from navigator_session.data import SessionData
+
+
+# --- Test Fixtures ---
+
+class DummyManager:
+    """Non-serializable class for testing in-memory storage."""
+    def __init__(self, name: str = "default"):
+        self.name = name
+        self.data = {}
+
+    def add(self, key: str, value):
+        self.data[key] = value
+
+
+class UserModel(BaseModel):
+    """Serializable datamodel for testing."""
+    username: str
+    email: str
+    age: int = 0
+
+
+@pytest.fixture
+def session():
+    """Create a fresh SessionData instance."""
+    return SessionData()
+
+
+@pytest.fixture
+def session_with_data():
+    """Create a SessionData instance with initial data."""
+    return SessionData(data={
+        'name': 'test_session',
+        'count': 42,
+        'active': True
+    })
+
+
+# --- Test Session Initialization ---
+
+class TestSessionInitialization:
+    """Tests for SessionData initialization."""
+
+    def test_empty_session_creation(self, session):
+        """Test creating an empty session."""
+        assert session.empty is True
+        # new is False when created without explicit new=True and no data
+        assert len(session) == 0
+
+    def test_session_with_initial_data(self, session_with_data):
+        """Test creating a session with initial data."""
+        assert session_with_data.empty is False
+        assert session_with_data['name'] == 'test_session'
+        assert session_with_data['count'] == 42
+        assert session_with_data['active'] is True
+
+    def test_session_id_is_generated(self, session):
+        """Test that session_id is automatically generated."""
+        assert session.session_id is not None
+        assert len(session.session_id) > 0
+
+    def test_session_with_custom_id(self):
+        """Test creating a session with a custom ID."""
+        custom_id = "my-custom-session-id"
+        session = SessionData(id=custom_id)
+        assert session.session_id == custom_id
+
+    def test_session_identity(self):
+        """Test session identity assignment."""
+        identity = "user123"
+        session = SessionData(identity=identity)
+        assert session.identity == identity
+
+    def test_session_created_timestamp(self, session):
+        """Test that created timestamp is set."""
+        assert session.created is not None
+        assert isinstance(session.created, int)
+
+    def test_session_logon_time(self, session):
+        """Test that logon_time is a datetime."""
+        assert isinstance(session.logon_time, datetime)
+
+
+# --- Test Serializable Data Storage (_data) ---
+
+class TestSerializableDataStorage:
+    """Tests for serializable data stored in _data."""
+
+    def test_store_string(self, session):
+        """Test storing string values."""
+        session['name'] = 'test'
+        assert session['name'] == 'test'
+        assert 'name' in session._data
+        assert 'name' not in session._objects
+
+    def test_store_integer(self, session):
+        """Test storing integer values."""
+        session['count'] = 100
+        assert session['count'] == 100
+        assert 'count' in session._data
+
+    def test_store_float(self, session):
+        """Test storing float values."""
+        session['price'] = 19.99
+        assert session['price'] == 19.99
+        assert 'price' in session._data
+
+    def test_store_boolean(self, session):
+        """Test storing boolean values."""
+        session['active'] = True
+        assert session['active'] is True
+        assert 'active' in session._data
+
+    def test_store_none(self, session):
+        """Test storing None values."""
+        session['empty'] = None
+        assert session['empty'] is None
+        assert 'empty' in session._data
+
+    def test_store_list(self, session):
+        """Test storing list values."""
+        session['items'] = [1, 2, 3, 'four']
+        assert session['items'] == [1, 2, 3, 'four']
+        assert 'items' in session._data
+
+    def test_store_dict(self, session):
+        """Test storing dict values."""
+        session['config'] = {'key': 'value', 'nested': {'a': 1}}
+        assert session['config'] == {'key': 'value', 'nested': {'a': 1}}
+        assert 'config' in session._data
+
+    def test_store_datetime(self, session):
+        """Test storing datetime values."""
+        now = datetime.now(timezone.utc)
+        session['timestamp'] = now
+        assert session['timestamp'] == now
+        assert 'timestamp' in session._data
+
+    def test_store_datamodel(self, session):
+        """Test storing datamodel BaseModel instances (serializable)."""
+        user = UserModel(username='john', email='john@example.com', age=30)
+        session['user'] = user
+        assert session['user'] == user
+        assert 'user' in session._data
+        assert 'user' not in session._objects
+
+
+# --- Test In-Memory Object Storage (_objects) ---
+
+class TestInMemoryObjectStorage:
+    """Tests for non-serializable objects stored in _objects."""
+
+    def test_store_class_instance(self, session):
+        """Test storing arbitrary class instances in _objects."""
+        manager = DummyManager(name='test_manager')
+        session['manager'] = manager
+        assert session['manager'] is manager
+        assert 'manager' in session._objects
+        assert 'manager' not in session._data
+
+    def test_retrieve_same_instance(self, session):
+        """Test that retrieved object is the exact same instance."""
+        manager = DummyManager()
+        manager.add('key1', 'value1')
+        session['dm'] = manager
+
+        retrieved = session['dm']
+        assert retrieved is manager
+        assert retrieved.data == {'key1': 'value1'}
+
+    def test_modify_retrieved_object(self, session):
+        """Test that modifications to retrieved object persist."""
+        manager = DummyManager()
+        session['dm'] = manager
+
+        # Modify via retrieved reference
+        session['dm'].add('test', 123)
+
+        # Verify modification persists
+        assert session['dm'].data == {'test': 123}
+
+    def test_in_memory_not_in_session_data(self, session):
+        """Test that in-memory objects don't appear in session_data()."""
+        session['name'] = 'test'  # Serializable
+        session['manager'] = DummyManager()  # In-memory
+
+        data = session.session_data()
+        assert 'name' in data
+        assert 'manager' not in data
+
+    def test_in_memory_in_session_objects(self, session):
+        """Test that in-memory objects appear in session_objects()."""
+        session['manager'] = DummyManager()
+
+        objects = session.session_objects()
+        assert 'manager' in objects
+
+
+# --- Test Attribute-Style Access ---
+
+class TestAttributeStyleAccess:
+    """Tests for attribute-style access (session.key)."""
+
+    def test_set_serializable_via_attribute(self, session):
+        """Test setting serializable values via attribute."""
+        session.username = 'alice'
+        assert session.username == 'alice'
+        assert 'username' in session._data
+
+    def test_set_object_via_attribute(self, session):
+        """Test setting objects via attribute."""
+        manager = DummyManager()
+        session.dm = manager
+        assert session.dm is manager
+        assert 'dm' in session._objects
+
+    def test_get_via_attribute(self, session):
+        """Test getting values via attribute."""
+        session['name'] = 'test'
+        assert session.name == 'test'
+
+    def test_attribute_error_for_missing(self, session):
+        """Test AttributeError for missing keys."""
+        with pytest.raises(AttributeError):
+            _ = session.nonexistent
+
+    def test_internal_attributes_work(self, session):
+        """Test that internal attributes are not routed to storage."""
+        # These are internal and should work normally
+        assert hasattr(session, '_data')
+        assert hasattr(session, '_objects')
+        assert hasattr(session, '_changed')
+
+
+# --- Test Magic Methods ---
+
+class TestMagicMethods:
+    """Tests for dict-like magic methods."""
+
+    def test_getitem(self, session):
+        """Test __getitem__ for both storage types."""
+        session['serializable'] = 'value'
+        session['object'] = DummyManager()
+
+        assert session['serializable'] == 'value'
+        assert isinstance(session['object'], DummyManager)
+
+    def test_getitem_keyerror(self, session):
+        """Test __getitem__ raises KeyError for missing keys."""
+        with pytest.raises(KeyError):
+            _ = session['nonexistent']
+
+    def test_setitem(self, session):
+        """Test __setitem__ routes correctly."""
+        session['str'] = 'hello'
+        session['obj'] = DummyManager()
+
+        assert 'str' in session._data
+        assert 'obj' in session._objects
+
+    def test_delitem_from_data(self, session):
+        """Test __delitem__ for serializable data."""
+        session['name'] = 'test'
+        del session['name']
+        assert 'name' not in session
+
+    def test_delitem_from_objects(self, session):
+        """Test __delitem__ for in-memory objects."""
+        session['dm'] = DummyManager()
+        del session['dm']
+        assert 'dm' not in session
+
+    def test_delitem_keyerror(self, session):
+        """Test __delitem__ raises KeyError for missing keys."""
+        with pytest.raises(KeyError):
+            del session['nonexistent']
+
+    def test_contains(self, session):
+        """Test __contains__ checks both storages."""
+        session['data'] = 'value'
+        session['obj'] = DummyManager()
+
+        assert 'data' in session
+        assert 'obj' in session
+        assert 'missing' not in session
+
+    def test_len_includes_both(self, session):
+        """Test __len__ counts both storages."""
+        session['a'] = 1
+        session['b'] = 2
+        session['c'] = DummyManager()
+
+        assert len(session) == 3
+
+    def test_iter_includes_both(self, session):
+        """Test __iter__ yields keys from both storages."""
+        session['a'] = 1
+        session['b'] = DummyManager()
+        session['c'] = 'three'
+
+        keys = list(session)
+        assert set(keys) == {'a', 'b', 'c'}
+
+    def test_get_method(self, session):
+        """Test dict.get() method with default."""
+        session['exists'] = 'value'
+
+        assert session.get('exists') == 'value'
+        assert session.get('missing') is None
+        assert session.get('missing', 'default') == 'default'
+
+    def test_keys_method(self, session):
+        """Test keys() includes both storages."""
+        session['a'] = 1
+        session['b'] = DummyManager()
+
+        keys = list(session.keys())
+        assert set(keys) == {'a', 'b'}
+
+    def test_values_method(self, session):
+        """Test values() includes both storages."""
+        session['a'] = 1
+        manager = DummyManager()
+        session['b'] = manager
+
+        values = list(session.values())
+        assert 1 in values
+        assert manager in values
+
+    def test_items_method(self, session):
+        """Test items() includes both storages."""
+        manager = DummyManager()
+        session['a'] = 1
+        session['b'] = manager
+
+        items = dict(session.items())
+        assert items == {'a': 1, 'b': manager}
+
+
+# --- Test Session State ---
+
+class TestSessionState:
+    """Tests for session state management."""
+
+    def test_changed_flag_on_serializable_set(self, session):
+        """Test that _changed is set when adding serializable data."""
+        assert session.is_changed is False
+        session['name'] = 'test'
+        assert session.is_changed is True
+
+    def test_changed_flag_not_set_on_object(self, session):
+        """Test that _changed is NOT set for in-memory objects."""
+        assert session.is_changed is False
+        session['dm'] = DummyManager()
+        assert session.is_changed is False
+
+    def test_changed_flag_on_delete(self, session):
+        """Test that _changed is set when deleting from _data."""
+        session['name'] = 'test'
+        session.is_changed = False
+
+        del session['name']
+        assert session.is_changed is True
+
+    def test_invalidate_clears_both(self, session):
+        """Test invalidate() clears both _data and _objects."""
+        session['name'] = 'test'
+        session['dm'] = DummyManager()
+
+        session.invalidate()
+
+        assert session.empty is True
+        assert len(session._data) == 0
+        assert len(session._objects) == 0
+        assert session.is_changed is True
+
+    def test_empty_property(self, session):
+        """Test empty property considers both storages."""
+        assert session.empty is True
+
+        session['dm'] = DummyManager()
+        assert session.empty is False
+
+        del session['dm']
+        assert session.empty is True
+
+
+# --- Test Encode/Decode ---
+
+class TestEncodeDecode:
+    """Tests for encode/decode functionality."""
+
+    def test_encode_simple_object(self, session):
+        """Test encoding a simple object."""
+        data = {'name': 'test', 'count': 42}
+        encoded = session.encode(data)
+
+        assert isinstance(encoded, str)
+        assert 'name' in encoded
+        assert 'test' in encoded
+
+    def test_encode_datamodel(self, session):
+        """Test encoding a datamodel object."""
+        user = UserModel(username='alice', email='alice@example.com')
+        encoded = session.encode(user)
+
+        assert isinstance(encoded, str)
+        assert 'alice' in encoded
+
+    def test_decode_from_data(self, session):
+        """Test decoding a stored encoded value."""
+        user = UserModel(username='bob', email='bob@example.com', age=25)
+        session._data['user'] = session.encode(user)
+
+        decoded = session.decode('user')
+
+        assert isinstance(decoded, UserModel)
+        assert decoded.username == 'bob'
+        assert decoded.email == 'bob@example.com'
+        assert decoded.age == 25
+
+    def test_decode_missing_key(self, session):
+        """Test decode returns None for missing keys."""
+        result = session.decode('nonexistent')
+        assert result is None
+
+    def test_encode_decode_roundtrip(self, session):
+        """Test encode/decode roundtrip."""
+        original = {'items': [1, 2, 3], 'nested': {'a': 'b'}}
+        encoded = session.encode(original)
+        session._data['test'] = encoded
+        decoded = session.decode('test')
+
+        assert decoded == original
+
+
+# --- Test Value Routing ---
+
+class TestValueRouting:
+    """Tests for automatic routing between _data and _objects."""
+
+    def test_reassign_serializable_to_object(self, session):
+        """Test reassigning from serializable to object moves storage."""
+        session['key'] = 'serializable'
+        assert 'key' in session._data
+        assert 'key' not in session._objects
+
+        session['key'] = DummyManager()
+        assert 'key' not in session._data
+        assert 'key' in session._objects
+
+    def test_reassign_object_to_serializable(self, session):
+        """Test reassigning from object to serializable moves storage."""
+        session['key'] = DummyManager()
+        assert 'key' in session._objects
+        assert 'key' not in session._data
+
+        session['key'] = 'serializable'
+        assert 'key' in session._data
+        assert 'key' not in session._objects
+
+    def test_nested_dict_with_primitives_is_serializable(self, session):
+        """Test nested dict with only primitives goes to _data."""
+        session['config'] = {
+            'level1': {
+                'level2': {
+                    'value': 123
+                }
+            }
+        }
+        assert 'config' in session._data
+
+    def test_list_of_objects_goes_to_objects(self, session):
+        """Test list containing class instances goes to _objects."""
+        session['managers'] = [DummyManager(), DummyManager()]
+        assert 'managers' in session._objects
+        assert 'managers' not in session._data
+
+
+# --- Test Session Properties ---
+
+class TestSessionProperties:
+    """Tests for session property accessors."""
+
+    def test_dow_property(self, session):
+        """Test day of week property."""
+        assert isinstance(session.dow, int)
+        assert 0 <= session.dow <= 6
+
+    def test_session_time_property(self, session):
+        """Test session_time property."""
+        from datetime import time as time_type
+        assert isinstance(session.session_time, time_type)
+
+    def test_max_age_property(self, session):
+        """Test max_age getter and setter."""
+        assert session.max_age is None
+
+        # max_age must be set via private attribute since it's a property
+        session._max_age = 3600
+        assert session.max_age == 3600
+
+    def test_session_with_max_age(self):
+        """Test session created with max_age."""
+        session = SessionData(max_age=3600)
+        assert session.max_age == 3600
+
+
+# --- Test repr ---
+
+class TestRepr:
+    """Tests for string representation."""
+
+    def test_repr_empty_session(self, session):
+        """Test repr of empty session."""
+        repr_str = repr(session)
+        assert 'NAV-Session' in repr_str
+        assert 'new:' in repr_str  # Could be True or False depending on init
+
+    def test_repr_with_data(self, session):
+        """Test repr includes data and objects info."""
+        session['name'] = 'test'
+        session['dm'] = DummyManager()
+
+        repr_str = repr(session)
+        assert 'name' in repr_str
+        assert 'dm' in repr_str

navigator_session-0.7.0/navigator_session/data.py

@@ -1,211 +0,0 @@
-import uuid
-import time
-from typing import Union, Optional, Any
-from datetime import datetime, timezone
-from collections.abc import Iterator, Mapping, MutableMapping
-import jsonpickle
-from jsonpickle.unpickler import loadclass
-from aiohttp import web
-from datamodel import BaseModel
-from .conf import (
-    SESSION_KEY,
-    SESSION_ID,
-    SESSION_STORAGE
-)
-
-class ModelHandler(jsonpickle.handlers.BaseHandler):
-    """ModelHandler.
-    This class can handle with serializable Data Models.
-    """
-    def flatten(self, obj, data):
-        data['__dict__'] = self.context.flatten(obj.__dict__, reset=False)
-        return data
-
-    def restore(self, obj):
-        module_and_type = obj['py/object']
-        mdl = loadclass(module_and_type)
-        cls = mdl.__new__(mdl) if hasattr(mdl, '__new__') else object.__new__(mdl)
-        cls.__dict__ = self.context.restore(obj['__dict__'], reset=False)
-        return cls
-
-jsonpickle.handlers.registry.register(BaseModel, ModelHandler, base=True)
-
-class SessionData(MutableMapping[str, Any]):
-    """Session dict-like object.
-    """
-
-    _data: Union[str, Any] = {}
-
-    def __init__(
-        self,
-        *args,
-        data: Optional[Mapping[str, Any]] = None,
-        new: bool = False,
-        id: Optional[str] = None,
-        identity: Optional[Any] = None,
-        max_age: Optional[int] = None
-    ) -> None:
-        self._changed = False
-        self._data = {}
-        # Unique ID:
-        self._id_ = (data.get(SESSION_ID, None) if data else id) or uuid.uuid4().hex
-        # Session Identity
-        self._identity = (
-            data.get(SESSION_KEY, None) if data else identity
-        ) or self._id_
-        self._new = new if data != {} else True
-        self._max_age = max_age or None
-        created = data.get('created', None) if data else None
-        self._now = datetime.now(timezone.utc)
-        self.__created__ = self._now
-        now = int(self._now.timestamp())
-        self._now = now  # time for this instance creation
-        age = now - created if created else now
-        if max_age is not None and age > max_age:
-            data = None
-        self._created = now if self._new or created is None else created
-        ## Data updating.
-        if data is not None:
-            self._data.update(data)
-        # Other mark timestamp for this session:
-        dt = datetime.now(timezone.utc)
-        self._dow = dt.weekday()
-        self._doy = dt.timetuple().tm_yday
-        self._time = dt.time()
-        self.args = args
-
-    def __repr__(self) -> str:
-        return f'<NAV-Session [new:{self.new}, created:{self.created}] {self._data!r}>'
-
-    @property
-    def new(self) -> bool:
-        return self._new
-
-    @property
-    def logon_time(self) -> datetime:
-        return self.__created__
-
-    @property
-    def session_id(self) -> str:
-        return self._id_
-
-    @property
-    def identity(self) -> Optional[Any]:  # type: ignore[misc]
-        return self._identity
-
-    @property
-    def created(self) -> int:
-        return self._created
-
-    @property
-    def dow(self) -> int:
-        return self._dow
-
-    @property
-    def session_time(self) -> time:
-        return self._time
-
-    @property
-    def empty(self) -> bool:
-        return not bool(self._data)
-
-    @property
-    def max_age(self) -> Optional[int]:
-        return self._max_age
-
-    @max_age.setter
-    def max_age(self, value: Optional[int]) -> None:
-        self._max_age = value
-
-    @property
-    def is_changed(self) -> bool:
-        return self._changed
-
-    @is_changed.setter
-    def is_changed(self, value: bool) -> None:
-        self._changed = value
-
-    def changed(self) -> None:
-        self._changed = True
-
-    def session_data(self) -> dict:
-        return self._data
-
-    def invalidate(self) -> None:
-        self._changed = True
-        self._data = {}
-
-    # Magic Methods
-    def __len__(self) -> int:
-        return len(self._data)
-
-    def __iter__(self) -> Iterator[str]:
-        return iter(self._data)
-
-    def __contains__(self, key: object) -> bool:
-        return key in self._data
-
-    def __getitem__(self, key: str) -> Any:
-        return self._data[key]
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self._data[key] = value
-        self._changed = True
-        # TODO: also, saved into redis automatically
-
-    def __delitem__(self, key: str) -> None:
-        del self._data[key]
-        self._changed = True
-
-    def __getattr__(self, key: str) -> Any:
-        return self._data[key]
-
-    def encode(self, obj: Any) -> str:
-        """encode
-
-            Encode an object using jsonpickle.
-        Args:
-            obj (Any): Object to be encoded using jsonpickle
-
-        Raises:
-            RuntimeError: Error converting data to json.
-
-        Returns:
-            str: json version of the data
-        """
-        try:
-            return jsonpickle.encode(obj)
-        except Exception as err:
-            raise RuntimeError(err) from err
-
-    def decode(self, key: str) -> Any:
-        """decode.
-
-            Decoding a Session Key using jsonpickle.
-        Args:
-            key (str): key name.
-
-        Raises:
-            RuntimeError: Error converting data from json.
-
-        Returns:
-            Any: object converted.
-        """
-        try:
-            value = self._data[key]
-            return jsonpickle.decode(value)
-        except KeyError:
-            # key is missing
-            return None
-        except Exception as err:
-            raise RuntimeError(err) from err
-
-    async def save_encoded_data(self, request: web.Request, key: str, obj: Any) -> None:
-        storage = request[SESSION_STORAGE]
-        try:
-            data = jsonpickle.encode(obj)
-        except RuntimeError:
-            return False
-        self._data[key] = data
-        self._changed = False
-        await storage.save_session(request, None, self)