def get_user_by_username(self, username):
users = self.get_users({'eduPersonPrincipalName': username})
if users.count() == 0:
raise self.exceptions.UserDoesNotExist()
if users.count() > 1:
raise self.exceptions.MultipleUsersReturned()
return User(users[0])
def get_user_by_nin(self, nin):
users = self.get_users({
'norEduPersonNIN.norEduPersonNIN': nin,
'norEduPersonNIN.verified': True,
'norEduPersonNIN.active': True,
})
if users.count() == 0:
raise self.exceptions.UserDoesNotExist()
if users.count() > 1:
raise self.exceptions.MultipleUsersReturned()
return User(users[0])
def get_user_by_attr(self, attr, value):
"""
Locate a user in the userdb using any attribute and value.
:param attr: The attribute to match on
:param value: The value to match on
:return: eduid_am.user.User
:raise self.UserDoesNotExist: No user match the search criteria
:raise self.MultipleUsersReturned: More than one user matches the search criteria
"""
logger.debug("Looking in {!r} for user with {!r} = {!r}".format(
self._db, attr, value))
try:
doc = self._db.get_user_by_field(attr, value, raise_on_missing=True)
logger.debug("Found user {!r}".format(doc))
return User(doc)
except self.exceptions.UserDoesNotExist:
logger.debug("UserDoesNotExist, {!r} = {!r}".format(attr, value))
raise self.exceptions.UserDoesNotExist()
except self.exceptions.MultipleUsersReturned:
logger.error("MultipleUsersReturned, {!r} = {!r}".format(attr, value))
raise self.exceptions.MultipleUsersReturned()
def get_user_by_filter(self, filter, fields=None):
"""
Locate a user in the userdb using a custom search filter.
:param filter: the search filter
:type filter: dict
:param fields: the fields to return in the search result
:type fields: dict
:return: eduid_am.user.User
:raise self.UserDoesNotExist: No user matching the search criteria
:raise self.MultipleUsersReturned: More than one user matched the search criteria
"""
logger.debug("Looking in {!r} using filter {!r}, returning fields {!r}".format(
self._db, filter, fields))
users = self.get_users(filter, fields)
if users.count() == 0:
raise self.exceptions.UserDoesNotExist()
elif users.count() > 1:
raise self.exceptions.MultipleUsersReturned()
logger.debug("Found user {!r}".format(users[0]))
return User(users[0])
class MongoTestCase(unittest.TestCase):
"""TestCase with an embedded MongoDB temporary instance.
Each test runs on a temporary instance of MongoDB. The instance will
be listen in a random port between 40000 and 5000.
A test can access the connection using the attribute `conn`.
A test can access the port using the attribute `port`
"""
fixtures = []
MockedUserDB = MockedUserDB
user = User(MOCKED_USER_STANDARD)
users = []
def setUp(self):
super(MongoTestCase, self).setUp()
self.tmp_db = MongoTemporaryInstance.get_instance()
self.conn = self.tmp_db.conn
self.port = self.tmp_db.port
self.am_settings = {
'BROKER_TRANSPORT': 'memory',
'BROKER_URL': 'memory://',
'CELERY_EAGER_PROPAGATES_EXCEPTIONS': True,
'CELERY_ALWAYS_EAGER': True,
'CELERY_RESULT_BACKEND': "cache",
'CELERY_CACHE_BACKEND': 'memory',
'MONGO_URI': 'mongodb://localhost:%d/' % self.port,
'MONGO_DBNAME': 'am',
}
celery.conf.update(self.am_settings)
self.am = get_attribute_manager(celery)
for db_name in self.conn.database_names():
self.conn.drop_database(db_name)
mongo_settings = {
'mongo_replicaset': None,
'mongo_uri_am': self.am_settings['MONGO_URI'] + 'am',
}
if getattr(self, 'settings', None) is None:
self.settings = mongo_settings
else:
self.settings.update(mongo_settings)
mongo_replicaset = self.settings.get('mongo_replicaset', None)
self.amdb = self.am.conn.get_database('am')
self.userdb = self.MockedUserDB(self.users)
self.initial_verifications = (getattr(self, 'initial_verifications',
None) or INITIAL_VERIFICATIONS)
self.amdb.attributes.drop()
userdocs = []
for userdoc in self.userdb.all_userdocs():
userdocs.append(deepcopy(userdoc))
self.amdb.attributes.insert(userdocs)
def tearDown(self):
super(MongoTestCase, self).tearDown()
self.amdb.attributes.drop()
def all_users(self):
for user in self.test_users.values():
yield User(deepcopy(user))
def get_user(self, userid):
if userid not in self.test_users:
raise self.UserDoesNotExist
return User(deepcopy(self.test_users.get(userid)))
def get_user_by_email(self, email):
doc = self._db.get_user_by_mail(email, raise_on_missing=True)
return User(doc)
