def test_unknown_input_data_allowed(self):
one = copy.deepcopy(_one_dict)
one['foo'] = 'bar'
addr = ToUEvent(data=one, raise_on_unknown=False)
out = addr.to_dict()
self.assertIn('foo', out)
self.assertEqual(out['foo'], one['foo'])
def perform_step(self, action):
if not request.get_json().get('accept', ''):
raise self.ActionError('tou.must-accept')
if action.old_format:
userid = action.user_id
central_user = current_app.central_userdb.get_user_by_id(userid)
else:
eppn = action.eppn
central_user = current_app.central_userdb.get_user_by_eppn(eppn)
version = action.params['version']
user = ToUUser.from_user(central_user, current_app.tou_db)
current_app.logger.debug('Loaded ToUUser {} from db'.format(user))
current_app.logger.info('ToU version {} accepted by user {}'.format(version, user))
event_id = ObjectId()
user.tou.add(ToUEvent(
version = version,
application = 'eduid_tou_plugin',
created_ts = datetime.utcnow(),
event_id = event_id
))
current_app.tou_db.save(user, check_sync=False)
current_app.logger.debug("Asking for sync of {} by Attribute Manager".format(user))
rtask = self._update_attributes.delay('tou', str(user.user_id))
try:
result = rtask.get(timeout=10)
current_app.logger.debug("Attribute Manager sync result: {!r}".format(result))
current_app.actions_db.remove_action_by_id(action.action_id)
current_app.logger.info('Removed completed action {}'.format(action))
return {}
except Exception as e:
current_app.logger.error("Failed Attribute Manager sync request: " + str(e))
user.tou.remove(event_id)
current_app.tou_db.save(user)
raise self.ActionError('tou.sync-problem')
def perform_action(self, action, request):
_ = self.get_ugettext(request)
if not request.POST.get('accept', ''):
msg = _(u'You must accept the new terms of use to continue logging in')
raise self.ActionError(msg)
userid = action.user_id
version = action.params['version']
user = request.tou_db.get_user_by_id(userid, raise_on_missing=False)
logger.debug('Loaded ToUUser {!s} from db'.format(user))
if not user:
user = ToUUser(userid=userid, tou=[])
user.tou.add(ToUEvent(
version = version,
application = 'eduid_tou_plugin',
created_ts = datetime.utcnow(),
event_id = ObjectId()
))
request.tou_db.save(user)
logger.debug("Asking for sync of {!s} by Attribute Manager".format(user))
rtask = update_attributes_keep_result.delay('tou', str(user.user_id))
try:
result = rtask.get(timeout=10)
logger.debug("Attribute Manager sync result: {!r}".format(result))
except Exception, e:
logger.exception("Failed Attribute Manager sync request: " + str(e))
message = _('There were problems with your submission. '
'You may want to try again later, '
'or contact the site administrators.')
request.session.flash(message)
raise HTTPInternalServerError()
def tou_accepted(self, version):
event_id = ObjectId()
self.user.tou.add(
ToUEvent(version=version,
application='eduid_tou_plugin',
created_ts=datetime.utcnow(),
event_id=event_id))
self.app.central_userdb.save(self.user, check_sync=False)
def test_no_actions_touevent_from_dict(self):
# Register user acceptance for the ToU version in use
tou = ToUEvent.from_dict(
dict(
version=self.config.tou_version,
created_by='unit test',
created_ts=datetime.utcnow(),
event_id=bson.ObjectId(),
))
self._test_no_actions(tou)
def test_created_ts_is_required(self):
"""
Test bad 'version'.
"""
with self.assertRaises(eduid_userdb.exceptions.BadEvent):
ToUEvent(
application='unit test',
created_ts=True,
version=False,
event_id=bson.ObjectId(),
)
def test_created_ts_is_required(self):
"""
Test that ToUEvent require created_ts, although Event does not.
"""
with self.assertRaises(eduid_userdb.exceptions.BadEvent):
ToUEvent(
application='unit test',
created_ts=None,
version='foo',
event_id=bson.ObjectId(),
)
def tou_accepted(self, user, version, created_ts=None, modified_ts=None):
event_id = ObjectId()
if created_ts is None:
created_ts = datetime.utcnow()
user.tou.add(
ToUEvent.from_dict(
dict(
version=version,
created_by='eduid_tou_plugin',
created_ts=created_ts,
modified_ts=modified_ts,
event_id=event_id,
)))
self.app.central_userdb.save(user, check_sync=False)
def event_from_dict(data, raise_on_unknown=True):
"""
Create an Event instance (probably really a subclass of Event) from a dict.
:param data: Password parameters from database
:param raise_on_unknown: Raise EventHasUnknownData if unrecognized data is encountered
:type data: dict
:type raise_on_unknown: bool
:rtype: Event
"""
if not 'event_type' in data:
raise UserDBValueError('No event type specified')
if data['event_type'] == 'tou_event':
from eduid_userdb.tou import ToUEvent # avoid cyclic dependency by importing this here
return ToUEvent(data=data, raise_on_unknown=raise_on_unknown)
raise BadEvent('Unknown event_type in data: {!s}'.format(
data['event_type']))
def test_add_tou_action_already_accepted_other_version(self):
event_id = bson.ObjectId()
self.test_user.tou.add(
ToUEvent.from_dict(
dict(
version='mock-version-2',
created_by='test_tou_plugin',
created_ts=datetime.utcnow(),
event_id=event_id,
)))
self.actions.remove_action_by_id(self.test_action.action_id)
from eduid_idp.tou_action import add_actions
mock_ticket = make_login_ticket(req_class_ref=SWAMID_AL2,
context=self.idp_app.context,
key='mock-session')
add_actions(self.idp_app.context, self.test_user, mock_ticket)
self.assertEqual(
len(self.actions.get_actions(self.test_user.eppn, 'mock-session')),
1)
def record_tou(user, source):
"""
Record user acceptance of terms of use.
:param user: the user that has accepted the ToU
:type user: eduid_userdb.signup.SignupUser
:param source: An identificator for the proccess during which
the user has accepted the ToU (e.g., "signup")
:type source: str
:return: None
"""
event_id = ObjectId()
created_ts = datetime.datetime.utcnow()
tou_version = current_app.config['TOU_VERSION']
current_app.logger.info('Recording ToU acceptance {!r} (version {})'
' for user {} (source: {})'.format(
event_id, tou_version, user, source))
user.tou.add(
ToUEvent(version=tou_version,
application=source,
created_ts=created_ts,
event_id=event_id))
def test_unknown_input_data(self):
one = copy.deepcopy(_one_dict)
one['foo'] = 'bar'
with self.assertRaises(eduid_userdb.exceptions.EventHasUnknownData):
ToUEvent(data=one)
def test_unknown_data_dont_raise(self):
one = copy.deepcopy(_one_dict)
tou = ToUEvent(data=one, raise_on_unknown=False)
data = dict(_id=USERID, tou=[tou], foo='bar')
user = ToUUser(data=data, raise_on_unknown=False)
self.assertEquals(user.to_dict()['foo'], 'bar')
def test_unknown_data(self):
one = copy.deepcopy(_one_dict)
tou = ToUEvent(data=one, raise_on_unknown=False)
data = dict(_id=USERID, tou=[tou], foo='bar')
with self.assertRaises(UserHasUnknownData):
user = ToUUser(data=data)
def test_missing_userid(self):
one = copy.deepcopy(_one_dict)
tou = ToUEvent(data=one, raise_on_unknown=False)
with self.assertRaises(UserMissingData):
user = ToUUser(tou=[tou])
def test_proper_user(self):
one = copy.deepcopy(_one_dict)
tou = ToUEvent(data=one, raise_on_unknown=False)
user = ToUUser(userid=USERID, tou=[tou])
self.assertEquals(user.tou.to_list_of_dicts()[0]['version'], '1')
def test_no_actions_touevent_init(self):
# Register user acceptance for the ToU version in use
tou = ToUEvent(version=self.config.tou_version,
created_by='unit test',
event_id=bson.ObjectId())
self._test_no_actions(tou)
