Sessions with no server storage: HMAC-signed cookies for Python web apps.

0 downloads

dbbasic-sessions/tests/test_unit.py
Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic-sessions.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic-sessions.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic-sessions.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

danq9 Update README with PyPI and GitHub links 75676a8 1 year, 1 month ago History
test_unit.py · 6.0 KB · 186 lines
1"""
2Unit tests for dbbasic-sessions
3
4Tests the core functionality of create_session, get_session, and destroy_session.
5"""
6
7import time
8import os
9import pytest
10from dbbasic_sessions import create_session, get_session, destroy_session
11
12
13class 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
61class 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
113class 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
132class 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
157class 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'