def test_login_queries(party_account_fixture, web_fixture):
""""""
context = ExecutionContext.get_context()
config = context.config
user_session = context.session
login_session = LoginSession.for_session(context.session)
system_account = party_account_fixture.system_account
web_fixture.request.scheme = 'https'
context.request.cookies[
config.web.secure_key_name] = user_session.secure_salt
assert config.web.idle_secure_lifetime < config.web.idle_lifetime
assert config.web.idle_lifetime < config.web.idle_lifetime_max
# Case: user logs in
user_session.last_activity = None
login_session.set_as_logged_in(system_account, False)
assert login_session.is_logged_in()
assert login_session.is_logged_in(secured=True)
# Case: user logs out
login_session.log_out()
assert not login_session.is_logged_in()
assert not login_session.is_logged_in(secured=True)
# Case: user activity is older than secure lifetime
assert (config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50
login_session.set_as_logged_in(system_account, False)
user_session.last_activity = datetime.now() - timedelta(
seconds=config.web.idle_secure_lifetime + 50)
assert login_session.is_logged_in()
assert not login_session.is_logged_in(secured=True)
# Case: user activity is older than all lifetimes
assert (config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50
login_session.set_as_logged_in(system_account, False)
user_session.last_activity = datetime.now() - timedelta(
seconds=config.web.idle_lifetime + 50)
assert not login_session.is_logged_in()
assert not login_session.is_logged_in(secured=True)
# Case: user activity is older than non-secure lifetime, but keep_me_logged_in is set
assert (config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50
assert (config.web.idle_lifetime_max - config.web.idle_lifetime) > 50
login_session.set_as_logged_in(system_account, True)
user_session.last_activity = datetime.now() - timedelta(
seconds=config.web.idle_lifetime + 50)
assert login_session.is_logged_in()
assert not login_session.is_logged_in(secured=True)
# Case: user activity is older than non-secure lifetime max, but keep_me_logged_in is set
assert (config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50
assert (config.web.idle_lifetime_max - config.web.idle_lifetime) > 50
login_session.set_as_logged_in(system_account, True)
Session.flush()
user_session.last_activity = datetime.now() - timedelta(
seconds=config.web.idle_lifetime_max + 50)
assert not login_session.is_logged_in()
assert not login_session.is_logged_in(secured=True)
def do_demo_setup(self):
Session.add(Address(name='John Doe', email_address='*****@*****.**'))
Session.add(Address(name='Jane Johnson', email_address='*****@*****.**'))
Session.add(Address(name='Jack Black', email_address='*****@*****.**'))
Session.flush()
Session.commit()
def test_cascade_removal_of_user_session(sql_alchemy_fixture,
session_scoped_fixture):
"""
If a user session is deleted, all session scoped objects are deleted as well.
"""
fixture = session_scoped_fixture
@session_scoped
class MySessionScoped(Base):
__tablename__ = 'my_session_scoped'
id = Column(Integer, primary_key=True)
with sql_alchemy_fixture.persistent_test_classes(MySessionScoped):
user_session = fixture.create_user_session()
assert Session.query(MySessionScoped).count() == 0
session_object = MySessionScoped.for_current_session()
assert Session.query(MySessionScoped).one() is session_object
assert session_object.user_session is user_session
if fixture.cascade:
Session.delete(user_session)
else:
Session.delete(session_object)
Session.flush()
assert Session.query(MySessionScoped).count() == 0
assert Session.query(
UserSession).count() == fixture.expected_user_session_after_delete
def new_task(self, title=None, queue=None):
title = title or 'A task'
queue = queue or self.queue
task = Task(title=title, queue=queue)
Session.add(task)
Session.flush()
return task
def test_deferred_action_times_out(sql_alchemy_fixture, deferred_action_fixture):
"""If all its Requirements are not fulfilled before its deadline has been reached, a DeferredAction executes its deadline action; then, it and its Requirements are deleted"""
fixture = deferred_action_fixture
with sql_alchemy_fixture.persistent_test_classes(fixture.MyDeferredAction, fixture.SomeObject):
requirements = [Requirement(), Requirement(), Requirement()]
deferred_action = fixture.MyDeferredAction(fixture.one_object, requirements=requirements, deadline=fixture.future_time)
Session.add(deferred_action)
Session.flush()
assert deferred_action.deadline == fixture.future_time
ReahlEgg.do_daily_maintenance_for_egg('reahl-domain')
assert not fixture.one_object.deadline_flag
assert not fixture.another_object.deadline_flag
assert Session.query(Requirement).count() == 3
assert Session.query(DeferredAction).count() == 1
deferred_action.deadline = fixture.past_time
ReahlEgg.do_daily_maintenance_for_egg('reahl-domain')
assert fixture.one_object.deadline_flag
assert not fixture.another_object.deadline_flag
assert Session.query(Requirement).count() == 0
assert Session.query(DeferredAction).count() == 0
def new_account_management_interface(self, system_account=None):
system_account = system_account or self.system_account
account_management_interface = AccountManagementInterface()
account_management_interface.password = system_account.password
account_management_interface.email = system_account.email
Session.add(account_management_interface)
Session.flush()
return account_management_interface
def do_demo_setup(self):
self.address_book
self.account
self.other_account
self.other_address_book
Session.flush()
Session.commit()
def edit_address_in_other_address_book(self):
address = Address(address_book=self.other_address_book,
email_address='*****@*****.**',
name='Friend')
address.save()
Session.flush()
self.url = '/edit_address/%s' % address.id
self.get = True
def do_demo_setup(self):
self.address_book
john = self.account
jane = self.new_account(email='*****@*****.**')
jane_book = self.new_address_book(owner=jane)
someone = self.new_account(email='*****@*****.**')
someone_book = self.new_address_book(owner=someone)
someone_else = self.new_account(email='*****@*****.**')
someone_else_book = self.new_address_book(owner=someone_else)
jane_book.allow(john, can_add_addresses=True, can_edit_addresses=True)
someone_book.allow(john,
can_add_addresses=False,
can_edit_addresses=True)
someone_else_book.allow(john,
can_add_addresses=False,
can_edit_addresses=False)
Address(address_book=jane_book,
email_address='*****@*****.**',
name='Friend1').save()
Address(address_book=jane_book,
email_address='*****@*****.**',
name='Friend2').save()
Address(address_book=jane_book,
email_address='*****@*****.**',
name='Friend3').save()
Address(address_book=jane_book,
email_address='*****@*****.**',
name='Friend4').save()
Address(address_book=someone_book,
email_address='*****@*****.**',
name='Friend11').save()
Address(address_book=someone_book,
email_address='*****@*****.**',
name='Friend12').save()
Address(address_book=someone_book,
email_address='*****@*****.**',
name='Friend13').save()
Address(address_book=someone_book,
email_address='*****@*****.**',
name='Friend14').save()
Address(address_book=someone_else_book,
email_address='*****@*****.**',
name='Friend21').save()
Address(address_book=someone_else_book,
email_address='*****@*****.**',
name='Friend22').save()
Address(address_book=someone_else_book,
email_address='*****@*****.**',
name='Friend23').save()
Address(address_book=someone_else_book,
email_address='*****@*****.**',
name='Friend24').save()
Session.flush()
Session.commit()
def do_demo_setup(self):
Address(email_address='*****@*****.**', name='Friend1').save()
Address(email_address='*****@*****.**', name='Friend2').save()
Address(email_address='*****@*****.**', name='Friend3').save()
Address(email_address='*****@*****.**', name='Friend4').save()
Session.flush()
Session.commit()
def test_daily_maintenance(reahl_system_fixture, jobs_fixture):
"""When daily maintenance is run, all addresses are set to be old."""
jobs_fixture.existing_address
Session.flush()
assert jobs_fixture.existing_address.added_today
reahl_system_fixture.context.system_control.do_daily_maintenance()
assert not jobs_fixture.existing_address.added_today
def daily_maintenance(fixture):
"""When daily maintenance is run, all addresses are set to be old."""
fixture.existing_address
Session.flush()
assert fixture.existing_address.added_today
fixture.context.system_control.do_daily_maintenance()
assert not fixture.existing_address.added_today
def test_deferred_action_completes_with_shared_requirements(
sql_alchemy_fixture, deferred_action_fixture):
"""A requirement could be linked to many DeferredActions, in which case it will notify all on success"""
fixture = deferred_action_fixture
with sql_alchemy_fixture.persistent_test_classes(fixture.MyDeferredAction,
fixture.SomeObject):
requirements1 = [Requirement()]
requirements2 = [Requirement(), Requirement()]
deferred_action1 = fixture.MyDeferredAction(
fixture.one_object,
requirements=requirements2,
deadline=fixture.future_time)
Session.add(deferred_action1)
deferred_action2 = fixture.MyDeferredAction(
fixture.another_object,
requirements=requirements1 + requirements2,
deadline=fixture.future_time)
Session.add(deferred_action2)
Session.flush()
# The requirements are linked back to the correct DeferredActions
for requirement in requirements2:
assert set(requirement.deferred_actions) == {
deferred_action1, deferred_action2
}
for requirement in requirements1:
assert set(requirement.deferred_actions) == {deferred_action2}
# If all of one DeferredAction's Requirements are fulfilled, ones also linked to another DeferrredAction
# are not deleted just yet
for requirement in requirements2:
requirement.set_fulfilled()
assert fixture.one_object.done_flag
assert not fixture.another_object.done_flag
for requirement in requirements1 + requirements2:
assert set(requirement.deferred_actions) == {deferred_action2}
assert Session.query(Requirement).count() == 3
assert Session.query(DeferredAction).count() == 1
# But as soon as all Requirements of the last DeferredAction are fulfilled, the last Requirements
# are deleted as usual
for requirement in requirements1:
requirement.set_fulfilled()
assert fixture.one_object.done_flag
assert fixture.another_object.done_flag
assert Session.query(Requirement).count() == 0
assert Session.query(DeferredAction).count() == 0
def deferred_action_completes(self, fixture):
"""A DeferredAction will execute its primary action once all its Requirements are fulfilled; then, it and its Requirements are deleted."""
with fixture.persistent_test_classes(fixture.MyDeferredAction, fixture.SomeObject):
requirements = [Requirement(), Requirement(), Requirement()]
deferred_action = fixture.MyDeferredAction(fixture.one_object, requirements=requirements, deadline=fixture.future_time)
Session.add(deferred_action)
Session.flush()
for requirement in requirements:
requirement.set_fulfilled()
vassert( fixture.one_object.done_flag )
vassert( not fixture.another_object.done_flag )
vassert( Session.query(Requirement).count() == 0 )
vassert( Session.query(DeferredAction).count() == 0 )
def new_system_account(self,
party=None,
email='*****@*****.**',
activated=True):
password = '******'
system_account = EmailAndPasswordSystemAccount(owner=party
or self.party,
email=email)
system_account.set_new_password(email, password)
system_account.password = password # The unencrypted version for use in tests
if activated:
system_account.activate()
Session.add(system_account)
Session.flush()
return system_account
def reserve(cls, email, password, party):
cls.assert_email_unique(email)
system_account = cls(owner=party, email=email)
Session.add(system_account)
system_account.set_new_password(email, password)
verification_request = VerifyEmailRequest(email=email,
subject_config='accounts.activation_subject',
email_config='accounts.activation_email')
Session.add(verification_request)
Session.flush()
deferred_activation = ActivateAccount(system_account=system_account,
requirements=[verification_request])
Session.add(deferred_activation)
system_account.send_activation_notification()
return system_account
def test_deferred_action_times_out_with_shared_requirements(
sql_alchemy_fixture, deferred_action_fixture):
"""If a DeferredAction times out, it will not nuke Requirements shared with another DeferredAction."""
fixture = deferred_action_fixture
with sql_alchemy_fixture.persistent_test_classes(fixture.MyDeferredAction,
fixture.SomeObject):
requirements1 = [Requirement()]
requirements2 = [Requirement(), Requirement()]
deferred_action1 = fixture.MyDeferredAction(
fixture.one_object,
requirements=requirements2,
deadline=fixture.future_time)
Session.add(deferred_action1)
deferred_action2 = fixture.MyDeferredAction(
fixture.another_object,
requirements=requirements1 + requirements2,
deadline=fixture.future_time)
Session.add(deferred_action2)
Session.flush()
# If one DeferredAction times out, the remaining one and its Requirements are left intact
deferred_action1.deadline = fixture.past_time
ReahlEgg.do_daily_maintenance_for_egg('reahl-domain')
assert fixture.one_object.deadline_flag
assert not fixture.another_object.deadline_flag
assert Session.query(Requirement).count() == 3
assert Session.query(DeferredAction).count() == 1
for requirement in requirements1 + requirements2:
assert set(requirement.deferred_actions) == {deferred_action2}
# When no more DeferredActions are held onto by Requirements, those Requirements are deleted
deferred_action2.deadline = fixture.past_time
ReahlEgg.do_daily_maintenance_for_egg('reahl-domain')
assert fixture.one_object.deadline_flag
assert fixture.another_object.deadline_flag
assert Session.query(Requirement).count() == 0
assert Session.query(DeferredAction).count() == 0
def test_session_keeps_living(web_fixture):
"""When SessionData is deleted, the associated UserSession is not affected."""
fixture = web_fixture
UserSession.initialise_web_session_on(fixture.context)
user_session = fixture.context.session
ui_name = 'user_interface'
channel_name = 'channel'
session_data = SessionData(web_session=user_session,
view_path='/',
ui_name=ui_name,
channel_name=channel_name)
Session.add(session_data)
Session.flush()
Session.delete(session_data)
assert Session.query(SessionData).filter_by(
id=session_data.id).count() == 0
assert Session.query(UserSession).filter_by(
id=user_session.id).one() is user_session
def test_session_data_disappears_when_session_does(web_fixture):
"""When a UserSession is deleted, all associated SessionData disappear as well."""
fixture = web_fixture
UserSession.initialise_web_session_on(fixture.context)
user_session = fixture.context.session
ui_name = 'user_interface'
channel_name = 'channel'
session_data = SessionData(web_session=user_session,
view_path='/',
ui_name=ui_name,
channel_name=channel_name)
Session.add(session_data)
Session.flush()
Session.delete(user_session)
assert Session.query(SessionData).filter_by(
id=session_data.id).count() == 0
assert Session.query(UserSession).filter_by(
id=user_session.id).count() == 0
def as_key(self):
Session.flush() # To make sure .id is populated
return '%s:%s' % (str(self.id), self.salt)
def viewing_other_address_book(self):
self.other_address_book
Session.flush()
self.url = '/address_book/%s' % self.other_address_book.id
self.get = True
def as_secret_key(self):
Session.flush()
return '%sk%s' % (self.id, self.salt)
def add_collaborator_to_other_address_book(self):
address_book = self.access_domain_fixture.other_address_book
Session.flush()
self.url = '/add_collaborator/%s' % address_book.id
self.get = True
def add_address_to_other_address_book(self):
address_book = self.access_domain_fixture.other_address_book
Session.flush()
self.url = '/add_address/%s' % address_book.id
self.get = False
def viewing_other_address_book(self):
address_book = self.access_domain_fixture.other_address_book
Session.flush()
self.url = '/address_book/%s' % address_book.id
self.get = True
def add_address_to_other_address_book(self):
self.other_address_book
Session.flush()
self.url = '/add_address/%s' % self.other_address_book.id
self.get = False
def add_collaborator_to_other_address_book(self):
self.other_address_book
Session.flush()
self.url = '/add_collaborator/%s' % self.other_address_book.id
self.get = True
def new_party(self):
party = Party()
Session.add(party)
Session.flush()
return party
def login_queries(self, fixture):
""""""
user_session = fixture.context.session
login_session = LoginSession.for_session(fixture.context.session)
system_account = fixture.system_account
config = fixture.context.config
context = fixture.context
fixture.request.scheme = 'https'
context.request.cookies[
context.config.web.secure_key_name] = user_session.secure_salt
vassert(config.web.idle_secure_lifetime < config.web.idle_lifetime)
vassert(config.web.idle_lifetime < config.web.idle_lifetime_max)
# Case: user logs in
user_session.last_activity = None
login_session.set_as_logged_in(system_account, False)
vassert(login_session.is_logged_in())
vassert(login_session.is_logged_in(secured=True))
# Case: user logs out
login_session.log_out()
vassert(not login_session.is_logged_in())
vassert(not login_session.is_logged_in(secured=True))
# Case: user activity is older than secure lifetime
vassert(
(config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50)
login_session.set_as_logged_in(system_account, False)
user_session.last_activity = datetime.now() - timedelta(
seconds=config.web.idle_secure_lifetime + 50)
vassert(login_session.is_logged_in())
vassert(not login_session.is_logged_in(secured=True))
# Case: user activity is older than all lifetimes
vassert(
(config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50)
login_session.set_as_logged_in(system_account, False)
user_session.last_activity = datetime.now() - timedelta(
seconds=config.web.idle_lifetime + 50)
vassert(not login_session.is_logged_in())
vassert(not login_session.is_logged_in(secured=True))
# Case: user activity is older than non-secure lifetime, but keep_me_logged_in is set
vassert(
(config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50)
vassert((config.web.idle_lifetime_max - config.web.idle_lifetime) > 50)
login_session.set_as_logged_in(system_account, True)
user_session.last_activity = datetime.now() - timedelta(
seconds=config.web.idle_lifetime + 50)
vassert(login_session.is_logged_in())
vassert(not login_session.is_logged_in(secured=True))
# Case: user activity is older than non-secure lifetime max, but keep_me_logged_in is set
vassert(
(config.web.idle_lifetime - config.web.idle_secure_lifetime) > 50)
vassert((config.web.idle_lifetime_max - config.web.idle_lifetime) > 50)
login_session.set_as_logged_in(system_account, True)
Session.flush()
user_session.last_activity = datetime.now() - timedelta(
seconds=config.web.idle_lifetime_max + 50)
vassert(not login_session.is_logged_in())
vassert(not login_session.is_logged_in(secured=True))
def new_session(self, system_account=None):
user_session = UserSession()
Session.add(user_session)
Session.flush()
return user_session
