askrobots / dbbasic-sessions
Public
Sessions with no server storage: HMAC-signed cookies for Python web apps.
test_unit.py · 6.0 KB · 186 lines
| 1 | """ |
| 2 | Unit tests for dbbasic-sessions |
| 3 | |
| 4 | Tests the core functionality of create_session, get_session, and destroy_session. |
| 5 | """ |
| 6 | |
| 7 | import time |
| 8 | import os |
| 9 | import pytest |
| 10 | from dbbasic_sessions import create_session, get_session, destroy_session |
| 11 | |
| 12 | |
| 13 | class TestCreateSession: |
| 14 | """Test create_session function""" |
| 15 | |
| 16 | def test_create_session_returns_token(self): |
| 17 | """Should return a valid token string""" |
| 18 | token = create_session('42') |
| 19 | assert isinstance(token, str) |
| 20 | assert len(token) > 50 # Base64 + signature |
| 21 | assert '.' in token # payload.signature format |
| 22 | |
| 23 | def test_create_session_with_string_user_id(self): |
| 24 | """Should accept string user_id""" |
| 25 | token = create_session('alice') |
| 26 | assert token is not None |
| 27 | user_id = get_session(token) |
| 28 | assert user_id == 'alice' |
| 29 | |
| 30 | def test_create_session_with_int_user_id(self): |
| 31 | """Should accept integer user_id and convert to string""" |
| 32 | token = create_session(42) |
| 33 | assert token is not None |
| 34 | user_id = get_session(token) |
| 35 | assert user_id == '42' |
| 36 | |
| 37 | def test_create_session_with_custom_ttl(self): |
| 38 | """Should respect custom TTL""" |
| 39 | token = create_session('42', ttl=1) |
| 40 | user_id = get_session(token) |
| 41 | assert user_id == '42' |
| 42 | |
| 43 | # Wait for expiration |
| 44 | time.sleep(1.1) |
| 45 | user_id = get_session(token) |
| 46 | assert user_id is None |
| 47 | |
| 48 | def test_create_session_default_ttl(self): |
| 49 | """Should create token with default 30-day TTL""" |
| 50 | token = create_session('42') |
| 51 | user_id = get_session(token) |
| 52 | assert user_id == '42' |
| 53 | |
| 54 | def test_different_users_get_different_tokens(self): |
| 55 | """Should generate different tokens for different users""" |
| 56 | token1 = create_session('alice') |
| 57 | token2 = create_session('bob') |
| 58 | assert token1 != token2 |
| 59 | |
| 60 | |
| 61 | class TestGetSession: |
| 62 | """Test get_session function""" |
| 63 | |
| 64 | def test_get_session_valid_token(self): |
| 65 | """Should return user_id for valid token""" |
| 66 | token = create_session('42') |
| 67 | user_id = get_session(token) |
| 68 | assert user_id == '42' |
| 69 | |
| 70 | def test_get_session_expired_token(self): |
| 71 | """Should return None for expired token""" |
| 72 | token = create_session('42', ttl=-1) # Already expired |
| 73 | time.sleep(0.1) |
| 74 | user_id = get_session(token) |
| 75 | assert user_id is None |
| 76 | |
| 77 | def test_get_session_invalid_signature(self): |
| 78 | """Should return None for tampered token""" |
| 79 | token = create_session('42') |
| 80 | payload, sig = token.split('.') |
| 81 | |
| 82 | # Tamper with signature |
| 83 | tampered = f"{payload}.{'0' * 64}" |
| 84 | user_id = get_session(tampered) |
| 85 | assert user_id is None |
| 86 | |
| 87 | def test_get_session_invalid_token_format(self): |
| 88 | """Should return None for malformed token""" |
| 89 | user_id = get_session('not-a-valid-token') |
| 90 | assert user_id is None |
| 91 | |
| 92 | def test_get_session_empty_token(self): |
| 93 | """Should return None for empty token""" |
| 94 | user_id = get_session('') |
| 95 | assert user_id is None |
| 96 | |
| 97 | def test_get_session_none_token(self): |
| 98 | """Should return None for None token""" |
| 99 | user_id = get_session(None) |
| 100 | assert user_id is None |
| 101 | |
| 102 | def test_get_session_token_with_no_dot(self): |
| 103 | """Should return None for token without dot separator""" |
| 104 | user_id = get_session('invaliddddddddddddddddddddddddddddddddddddddddtoken') |
| 105 | assert user_id is None |
| 106 | |
| 107 | def test_get_session_token_with_invalid_base64(self): |
| 108 | """Should return None for token with invalid base64 payload""" |
| 109 | user_id = get_session('!!!invalid!!!.a3f8d9e2b1c4567890abcdef') |
| 110 | assert user_id is None |
| 111 | |
| 112 | |
| 113 | class TestDestroySession: |
| 114 | """Test destroy_session function""" |
| 115 | |
| 116 | def test_destroy_session_is_noop(self): |
| 117 | """Should be a no-op (returns None)""" |
| 118 | token = create_session('42') |
| 119 | result = destroy_session(token) |
| 120 | assert result is None |
| 121 | |
| 122 | def test_token_still_valid_after_destroy(self): |
| 123 | """Token should still be valid after destroy (client must delete cookie)""" |
| 124 | token = create_session('42') |
| 125 | destroy_session(token) |
| 126 | |
| 127 | # Token still verifies (server-side is stateless) |
| 128 | user_id = get_session(token) |
| 129 | assert user_id == '42' |
| 130 | |
| 131 | |
| 132 | class TestConcurrentSessions: |
| 133 | """Test handling multiple concurrent sessions""" |
| 134 | |
| 135 | def test_multiple_sessions_independent(self): |
| 136 | """Should handle multiple sessions independently""" |
| 137 | tokens = [create_session(str(i)) for i in range(100)] |
| 138 | |
| 139 | # All should verify correctly |
| 140 | for i, token in enumerate(tokens): |
| 141 | user_id = get_session(token) |
| 142 | assert user_id == str(i) |
| 143 | |
| 144 | def test_session_isolation(self): |
| 145 | """Sessions should not interfere with each other""" |
| 146 | token1 = create_session('alice') |
| 147 | token2 = create_session('bob') |
| 148 | |
| 149 | assert get_session(token1) == 'alice' |
| 150 | assert get_session(token2) == 'bob' |
| 151 | |
| 152 | # Destroying one doesn't affect the other |
| 153 | destroy_session(token1) |
| 154 | assert get_session(token2) == 'bob' |
| 155 | |
| 156 | |
| 157 | class TestEdgeCases: |
| 158 | """Test edge cases and error conditions""" |
| 159 | |
| 160 | def test_session_with_zero_ttl(self): |
| 161 | """Should handle zero TTL (expires immediately)""" |
| 162 | token = create_session('42', ttl=0) |
| 163 | time.sleep(0.01) |
| 164 | user_id = get_session(token) |
| 165 | assert user_id is None |
| 166 | |
| 167 | def test_session_with_very_long_ttl(self): |
| 168 | """Should handle very long TTL""" |
| 169 | token = create_session('42', ttl=31536000) # 1 year |
| 170 | user_id = get_session(token) |
| 171 | assert user_id == '42' |
| 172 | |
| 173 | def test_session_with_special_characters(self): |
| 174 | """Should handle user_id with special characters""" |
| 175 | special_ids = ['user@example.com', 'user-123', 'user_456', 'user.789'] |
| 176 | |
| 177 | for user_id in special_ids: |
| 178 | token = create_session(user_id) |
| 179 | retrieved_id = get_session(token) |
| 180 | assert retrieved_id == user_id |
| 181 | |
| 182 | def test_session_with_unicode_user_id(self): |
| 183 | """Should handle unicode user_id""" |
| 184 | token = create_session('用户42') |
| 185 | user_id = get_session(token) |
| 186 | assert user_id == '用户42' |