def test_on_succeeded_login(user_id: UserId, zero_uuid: None) -> None:
now = datetime.now()
assert active_config.single_user_session is None
# Never logged in before
assert not userdb._load_session_infos(user_id)
assert userdb._load_failed_logins(user_id) == 0
session_id = userdb.on_succeeded_login(user_id, now)
assert session_id != ""
# Verify the session was initialized
session_infos = userdb._load_session_infos(user_id)
assert session_infos == {
session_id:
userdb.SessionInfo(
session_id=session_id,
started_at=int(now.timestamp()),
last_activity=int(now.timestamp()),
flashes=[],
csrf_token="00000000-0000-0000-0000-000000000000",
)
}
# Ensure the failed login count is 0
assert userdb._load_failed_logins(user_id) == 0
def test_cleanup_old_sessions_too_many(request_context: None) -> None:
sessions = {
f"keep_{num}": userdb.SessionInfo(
session_id=f"keep_{num}",
started_at=int(time.time()) - (86400 * 10),
last_activity=int(time.time()) - (86400 * 5) + num,
flashes=[],
)
for num in range(21)
}
assert (sorted([
"keep_1",
"keep_2",
"keep_3",
"keep_4",
"keep_5",
"keep_6",
"keep_7",
"keep_8",
"keep_9",
"keep_10",
"keep_11",
"keep_12",
"keep_13",
"keep_14",
"keep_15",
"keep_16",
"keep_17",
"keep_18",
"keep_19",
"keep_20",
]) == sorted(userdb._cleanup_old_sessions(sessions).keys()))
def test_cleanup_old_sessions_remove_outdated():
assert list(
userdb._cleanup_old_sessions({
"outdated":
userdb.SessionInfo(
session_id="outdated",
started_at=int(time.time()) - (86400 * 10),
last_activity=int(time.time()) - (86400 * 8),
),
"keep":
userdb.SessionInfo(
session_id="keep",
started_at=int(time.time()) - (86400 * 10),
last_activity=int(time.time()) - (86400 * 5),
),
}).keys()) == ["keep"]
def test_cleanup_old_sessions_remove_outdated(request_context: None) -> None:
assert (list(
userdb._cleanup_old_sessions({
"outdated":
userdb.SessionInfo(
session_id="outdated",
started_at=int(time.time()) - (86400 * 10),
last_activity=int(time.time()) - (86400 * 8),
flashes=[],
),
"keep":
userdb.SessionInfo(
session_id="keep",
started_at=int(time.time()) - (86400 * 10),
last_activity=int(time.time()) - (86400 * 5),
flashes=[],
),
}).keys()) == ["keep"])
def test_initialize_session_single_user_session(user_id):
session_id = userdb._initialize_session(user_id)
assert session_id != ""
session_infos = userdb._load_session_infos(user_id)
assert session_infos[session_id] == userdb.SessionInfo(
session_id=session_id,
started_at=int(time.time()),
last_activity=int(time.time()),
)
def test_cleanup_old_sessions_too_many():
sessions = {
f"keep_{num}": userdb.SessionInfo(
session_id=f"keep_{num}",
started_at=int(time.time()) - (86400 * 10),
last_activity=int(time.time()) - (86400 * 5) + num,
)
for num in range(20)
}
assert "keep_20" not in list(userdb._cleanup_old_sessions(sessions).keys())
def fixture_session_valid(monkeypatch, user_id, fix_time):
session_id = "sess2"
now = int(time.time()) - 5
userdb._save_session_infos(
user_id, {
session_id:
userdb.SessionInfo(
session_id,
started_at=now,
last_activity=now,
)
})
return session_id
def test_initialize_session_single_user_session(user_id: UserId,
zero_uuid: None) -> None:
now = datetime.now()
session_id = userdb._initialize_session(user_id, now)
assert session_id != ""
session_infos = userdb._load_session_infos(user_id)
assert session_infos[session_id] == userdb.SessionInfo(
session_id=session_id,
started_at=int(now.timestamp()),
last_activity=int(now.timestamp()),
flashes=[],
csrf_token="00000000-0000-0000-0000-000000000000",
)
def fixture_session_timed_out(monkeypatch, user_id, fix_time):
session_id = "sess1"
now = int(time.time()) - 20
userdb._save_session_infos(
user_id, {
session_id:
userdb.SessionInfo(
session_id,
started_at=now,
last_activity=now,
flashes=[],
)
})
return session_id
def test_refresh_session_success(user_id: UserId, session_valid: str) -> None:
session_infos = userdb._load_session_infos(user_id)
assert session_infos
old_session = userdb.SessionInfo(**asdict(session_infos[session_valid]))
with on_time("2019-09-05 00:00:30", "UTC"):
userdb._set_session(user_id, session_infos[session_valid])
userdb._refresh_session(user_id, session_infos[session_valid])
userdb.on_end_of_request(user_id)
new_session_infos = userdb._load_session_infos(user_id)
new_session = new_session_infos[session_valid]
assert old_session.session_id == new_session.session_id
assert new_session.last_activity > old_session.last_activity
def make_valid_session(user_id: UserId, now: datetime) -> SessionId:
session_id = "sess2"
timestamp = int(now.timestamp()) - 5
userdb._save_session_infos(
user_id,
{
session_id:
userdb.SessionInfo(
session_id,
started_at=timestamp,
last_activity=timestamp,
flashes=[],
)
},
)
return session_id
def fixture_session_valid(monkeypatch: MonkeyPatch, user_id: UserId,
fix_time: None) -> str:
session_id = "sess2"
now = int(time.time()) - 5
userdb._save_session_infos(
user_id,
{
session_id:
userdb.SessionInfo(
session_id,
started_at=now,
last_activity=now,
flashes=[],
)
},
)
return session_id
def test_cleanup_old_sessions_too_many():
sessions = {
f"keep_{num}": userdb.SessionInfo(
session_id=f"keep_{num}",
started_at=int(time.time()) - (86400 * 10),
last_activity=int(time.time()) - (86400 * 5) + num,
flashes=[],
)
for num in range(21)
}
assert sorted([
'keep_1', 'keep_2', 'keep_3', 'keep_4', 'keep_5', 'keep_6', 'keep_7',
'keep_8', 'keep_9', 'keep_10', 'keep_11', 'keep_12', 'keep_13',
'keep_14', 'keep_15', 'keep_16', 'keep_17', 'keep_18', 'keep_19',
'keep_20'
]) == sorted(userdb._cleanup_old_sessions(sessions).keys())
def test_refresh_session_success(user_id: UserId) -> None:
now = datetime.now()
session_valid = make_valid_session(user_id, now)
session_infos = userdb._load_session_infos(user_id)
assert session_infos
old_session = userdb.SessionInfo(**asdict(session_infos[session_valid]))
now += timedelta(minutes=30)
userdb._set_session(user_id, session_infos[session_valid])
userdb._refresh_session(session_infos[session_valid], now)
userdb.on_end_of_request(user_id, now)
new_session_infos = userdb._load_session_infos(user_id)
new_session = new_session_infos[session_valid]
assert old_session.session_id == new_session.session_id
assert new_session.last_activity > old_session.last_activity
def test_on_succeeded_login(user_id):
assert config.single_user_session is None
# Never logged in before
assert not userdb._load_session_infos(user_id)
assert userdb._load_failed_logins(user_id) == 0
session_id = userdb.on_succeeded_login(user_id)
assert session_id != ""
# Verify the session was initialized
session_infos = userdb._load_session_infos(user_id)
assert session_infos == {
session_id:
userdb.SessionInfo(
session_id=session_id,
started_at=int(time.time()),
last_activity=int(time.time()),
)
}
# Ensure the failed login count is 0
assert userdb._load_failed_logins(user_id) == 0
