def test_add_new_user(self):
worker = BridgeWorker()
person = get_person('affiemp')
uw_acc = set_uw_account('affiemp')
worker.add_new_user(uw_acc, person, get_worker(person))
self.assertEqual(worker.get_new_user_count(), 1)
person = get_person('javerage')
uw_acc = set_uw_account('javerage')
worker.add_new_user(uw_acc, person, get_worker(person))
self.assertTrue(worker.has_err())
def test_get_supervisor_bridge_id(self):
set_db_records()
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(get_supervisor_bridge_id(hrp_wkr), 196)
# hrp_wkr is None
self.assertEqual(get_supervisor_bridge_id(None), 0)
# manager employee_id is None
hrp_wkr = Worker(netid="x", regid="111", employee_id="1")
self.assertEqual(get_supervisor_bridge_id(hrp_wkr), 0)
# manager employee_id is the same as the employee's
hrp_wkr = Worker(netid="x",
regid="111",
employee_id="1",
primary_manager_id="1")
self.assertEqual(get_supervisor_bridge_id(hrp_wkr), 0)
# manager employee_id not in local DB
hrp_wkr = Worker(netid="javerage",
regid="111111111111111111111111111111",
employee_id="1",
primary_manager_id="11")
self.assertEqual(get_supervisor_bridge_id(hrp_wkr), 0)
# manager's uw account is the same the user's
hrp_wkr = Worker(netid="javerage",
regid="111111111111111111111111111111",
employee_id="1",
primary_manager_id="123456789")
self.assertEqual(get_supervisor_bridge_id(hrp_wkr), 0)
def test_get_pos_job_class(self):
func_name = GET_POS_ATT_FUNCS[1]
self.assertIsNone(func_name(None, 0))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0), "Undergraduate Student")
self.assertEqual(func_name(hrp_wkr, 1), "Undergraduate Student")
def test_get_attr_list_withhrp(self):
set_db_records()
person = get_person('faculty')
worker = get_worker(person)
user_attr_list = get_attr_list(person, worker)
self.assertEqual(len(user_attr_list), 25)
self.assertEqual(user_attr_list[0], "*****@*****.**")
self.assertEqual(user_attr_list[1], "*****@*****.**")
self.assertEqual(user_attr_list[2], "William E Faculty")
self.assertEqual(user_attr_list[3], "William E")
self.assertEqual(user_attr_list[4], "Faculty")
self.assertEqual(user_attr_list[5], "10000000000000000000000000000005")
self.assertEqual(user_attr_list[6], "000000005")
self.assertEqual(user_attr_list[7], "0000005")
self.assertEqual(user_attr_list[8], "Clinical Associate Professor")
self.assertEqual(user_attr_list[9], 196)
self.assertEqual(user_attr_list[10], "Family Medicine")
self.assertEqual(user_attr_list[11], "3040111000")
self.assertEqual(user_attr_list[12], "Academic Personnel")
self.assertEqual(user_attr_list[13], "21184")
self.assertEqual(user_attr_list[14], "Seattle Campus")
self.assertEqual(user_attr_list[15], "SOM:")
self.assertEqual(user_attr_list[16],
"Family Medicine: Volunteer JM Academic")
self.assertEqual(user_attr_list[17], "00753")
self.assertIsNone(user_attr_list[18])
self.assertIsNone(user_attr_list[19])
self.assertIsNone(user_attr_list[20])
self.assertIsNone(user_attr_list[21])
self.assertIsNone(user_attr_list[22])
self.assertIsNone(user_attr_list[23])
self.assertIsNone(user_attr_list[24])
def test_update_user_wo_uid_change(self):
worker = BridgeWorker()
uw_acc = set_uw_account('staff')
uw_acc.set_bridge_id(196)
person = get_person('staff')
bri_acc = worker.restore_user(uw_acc)
worker.update_user(bri_acc, uw_acc, person, get_worker(person))
self.assertEqual(worker.get_netid_changed_count(), 0)
self.assertEqual(worker.get_updated_count(), 1)
worker = BridgeWorker()
bridge_account = worker.bridge.get_user_by_uwnetid('retiree')
person = get_person('retiree')
worker.update_user(bridge_account, set_uw_account('retiree'), person,
get_worker(person))
self.assertEqual(worker.get_updated_count(), 0)
self.assertTrue(worker.has_err())
def test_get_pos_job_code(self):
func_name = GET_POS_ATT_FUNCS[2]
person = get_person('javerage')
self.assertIsNone(func_name(None, 0))
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0), "10875")
hrp_wkr.primary_position.job_profile = None
self.assertIsNone(func_name(hrp_wkr, 0))
self.assertEqual(func_name(hrp_wkr, 1), "10886")
def test_account_not_changed(self):
with self.settings(BRIDGE_USER_WORK_POSITIONS=2):
set_db_records()
loader = GwsBridgeLoader(BridgeWorker())
person = get_person('javerage')
hrp_wkr = get_worker(person)
bridge_account = loader.get_bridge().get_user_by_uwnetid(
'javerage')
self.assertTrue(
loader.account_not_changed(bridge_account, person, hrp_wkr))
def test_get_pos_location(self):
func_name = GET_POS_ATT_FUNCS[3]
self.assertIsNone(func_name(None, 0))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0), "Seattle Campus")
hrp_wkr.primary_position = None
self.assertIsNone(func_name(hrp_wkr, 0))
self.assertEqual(func_name(hrp_wkr, 1), "Seattle Campus")
hrp_wkr.other_active_positions = []
self.assertIsNone(func_name(hrp_wkr, 1))
def test_get_pos_unit_code(self):
func_name = GET_POS_ATT_FUNCS[6]
self.assertIsNone(func_name(None, 0))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0), "00090")
hrp_wkr.primary_position = None
self.assertIsNone(func_name(hrp_wkr, 0))
self.assertEqual(func_name(hrp_wkr, 1), "00652")
hrp_wkr.other_active_positions = []
self.assertIsNone(func_name(hrp_wkr, 1))
def test_update_user_with_uid_change(self):
worker = BridgeWorker()
uw_acc = set_uw_account('faculty')
uw_acc.prev_netid = 'tyler'
uw_acc.set_bridge_id(198)
self.assertTrue(uw_acc.netid_changed())
person = get_person('faculty')
bri_acc = worker.bridge.get_user_by_uwnetid('tyler')
worker.update_user(bri_acc, uw_acc, person, get_worker(person))
self.assertEqual(worker.get_netid_changed_count(), 1)
self.assertEqual(worker.get_updated_count(), 1)
uw_acc = set_uw_account('retiree')
uw_acc.prev_netid = 'ellen'
uw_acc.set_bridge_id(194)
self.assertTrue(uw_acc.netid_changed())
person = get_person('retiree')
bri_acc = worker.bridge.get_user_by_uwnetid('ellen')
worker.update_user(bri_acc, uw_acc, person, get_worker(person))
self.assertEqual(worker.get_netid_changed_count(), 2)
self.assertEqual(worker.get_updated_count(), 2)
def test_get_pos_budget_code(self):
func_name = GET_POS_ATT_FUNCS[0]
self.assertIsNone(func_name(None, 0))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0), "2070001000")
hrp_wkr.primary_position.supervisory_org = None
self.assertIsNone(func_name(hrp_wkr, 0))
self.assertIsNone(func_name(hrp_wkr, 1))
hrp_wkr.other_active_positions[0].supervisory_org = \
SupervisoryOrganization(budget_code="1")
self.assertEqual(func_name(hrp_wkr, 1), "1")
def test_get_pos_org_name(self):
func_name = GET_POS_ATT_FUNCS[5]
self.assertIsNone(func_name(None, 0))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(func_name(hrp_wkr, 0),
"GMMN: Public Services JM Student")
hrp_wkr.primary_position.supervisory_org = None
self.assertIsNone(func_name(hrp_wkr, 0))
self.assertIsNone(func_name(hrp_wkr, 1))
hrp_wkr.other_active_positions[0].supervisory_org = \
SupervisoryOrganization(org_name="A")
self.assertEqual(func_name(hrp_wkr, 1), "A")
def test_field_not_changed(self):
with self.settings(BRIDGE_USER_WORK_POSITIONS=2):
loader = GwsBridgeLoader(BridgeWorker())
person = get_person('javerage')
hrp_wkr = get_worker(person)
bridge_account = loader.get_bridge().get_user_by_uwnetid(
'javerage')
self.assertTrue(loader.regid_not_changed(bridge_account, person))
self.assertTrue(loader.eid_not_changed(bridge_account, person))
self.assertTrue(loader.sid_not_changed(bridge_account, person))
self.assertTrue(
loader.pos_data_not_changed(bridge_account, hrp_wkr))
person = get_person('faculty')
hrp_wkr = get_worker(person)
bridge_account = loader.get_bridge().get_user_by_uwnetid('tyler')
self.assertFalse(loader.regid_not_changed(bridge_account, person))
self.assertFalse(loader.eid_not_changed(bridge_account, person))
self.assertFalse(loader.sid_not_changed(bridge_account, person))
self.assertFalse(
loader.pos_data_not_changed(bridge_account, hrp_wkr))
def make_import_user_csv_files(uw_accounts, filepath):
"""
:param uw_accounts: a list of UwAccount objects
Writes all csv files. Returns number of records wrote out.
"""
if not uw_accounts or len(uw_accounts) == 0:
return 0
file_size = get_csv_file_size()
total_users = len(uw_accounts)
f_index = 1
user_number = 0
csv_headers = get_aline_csv(get_headers())
f = open_file(get_user_file_name(filepath, f_index))
f.write(csv_headers)
for uw_account in uw_accounts:
if uw_account.disabled or uw_account.has_terminate_date():
continue
person = get_person(uw_account.netid)
if (person is None or person.is_test_entity
or not person.is_emp_state_current()):
continue
if person.uwnetid != uw_account.netid:
logger.error("OLD netid, Skip {0}".format(uw_account))
continue
aline = get_aline_csv(get_attr_list(person, get_worker(person)))
try:
f.write(aline)
except Exception:
log_exception(logger,
"{0:d}th file: ({1}), Skip!".format(f_index, aline),
traceback.format_exc())
continue
user_number += 1
if user_number < total_users and (user_number % file_size) == 0:
f.close()
logger.info("Finish writing {0:d} entries.".format(user_number))
f_index += 1
f = open_file(get_user_file_name(filepath, f_index))
f.write(csv_headers)
f.close()
logger.info("Finish writing {0:d} entries.".format(user_number))
return user_number
def test_get_work_position(self):
self.assertIsNone(get_work_position(None, -1))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertIsNone(get_work_position(hrp_wkr, -1))
pos1 = get_work_position(hrp_wkr, 0)
self.assertTrue(pos1.is_primary)
self.assertEqual(pos1.title, "Student Reference Specialist - GMM")
hrp_wkr.primary_position = None
self.assertIsNone(get_work_position(hrp_wkr, 0))
pos2 = get_work_position(hrp_wkr, 1)
self.assertFalse(pos2.is_primary)
self.assertEqual(pos2.title, "Reader/Grader")
self.assertIsNone(get_work_position(hrp_wkr, 3))
hrp_wkr.other_active_positions = []
self.assertIsNone(get_work_position(hrp_wkr, 1))
def test_get_worker(self):
for netid in ['staff', 'faculty']:
person = get_person(netid)
worker = get_worker(person)
self.assertEqual(worker.netid, netid)
person = get_person('javerage')
worker = get_worker(person)
self.assertIsNotNone(worker.primary_position)
self.assertEqual(len(worker.other_active_positions), 1)
person = get_person('affiemp')
self.assertIsNone(get_worker(person))
person = get_person('alumni')
self.assertIsNone(get_worker(person))
person = get_person('bill')
self.assertIsNone(get_worker(person))
person = get_person('error500')
self.assertIsNone(get_worker(person))
def get_hrp_worker(self, person):
return get_worker(person)
def test_set_bridge_user_to_update(self):
set_db_records()
person = get_person('faculty')
worker = BridgeWorker()
user = worker.bridge.get_user_by_uwnetid('tyler')
worker.set_bridge_user_to_update(person, get_worker(person), user)
# self.maxDiff = None
self.assertEqual(
user.to_json_patch(), {
'user': {
'id':
198,
'uid':
'*****@*****.**',
'full_name':
'William E Faculty',
'email':
'*****@*****.**',
'first_name':
'William E',
'last_name':
'Faculty',
'sortable_name':
'Faculty, William E',
'job_title':
'Clinical Associate Professor',
'manager_id':
196,
'custom_field_values': [{
'custom_field_id': '5',
'value': '10000000000000000000000000000005',
'id': '1'
}, {
'custom_field_id': '7',
'id': '3',
'value': '0000005'
}, {
'custom_field_id': '11',
'value': '3040111000',
'id': '4'
}, {
'custom_field_id': '13',
'value': 'Academic Personnel',
'id': '5'
}, {
'custom_field_id': '12',
'value': '21184',
'id': '6'
}, {
'custom_field_id': '17',
'value': 'Seattle Campus',
'id': '7'
}, {
'custom_field_id': '14',
'value': 'SOM:',
'id': '8'
}, {
'custom_field_id': '15',
'value': 'Family Medicine: Volunteer JM Academic',
'id': '9'
}, {
'custom_field_id': '16',
'value': '00753',
'id': '10'
}, {
'custom_field_id': '21',
'value': None,
'id': '24'
}, {
'custom_field_id': '23',
'value': None,
'id': '25'
}, {
'custom_field_id': '22',
'value': None,
'id': '26'
}, {
'custom_field_id': '27',
'value': None,
'id': '27'
}, {
'custom_field_id': '24',
'value': None,
'id': '28'
}, {
'custom_field_id': '25',
'value': None,
'id': '29'
}, {
'custom_field_id': '26',
'value': None,
'id': '30'
}, {
'custom_field_id': '6',
'value': '000000005'
}]
}
})
worker = BridgeWorker()
user = worker.bridge.get_user_by_uwnetid('ellen')
person = get_person('retiree')
worker.set_bridge_user_to_update(person, get_worker(person), user)
# self.maxDiff = None
self.assertEqual(
user.to_json_patch(), {
'user': {
'uid':
'*****@*****.**',
'full_name':
'Ellen Louise Retiree',
'email':
'*****@*****.**',
'id':
194,
'first_name':
'Ellen L',
'last_name':
'Retiree',
'sortable_name':
'Retiree, Ellen L',
'manager_id':
None,
'custom_field_values': [{
'custom_field_id': '5',
'value': '10000000000000000000000000000006',
'id': '1'
}, {
'custom_field_id': '6',
'value': '000000006',
'id': '2'
}, {
'custom_field_id': '7',
'value': '0000006',
'id': '3'
}, {
'custom_field_id': '11',
'value': None,
'id': '4'
}, {
'custom_field_id': '13',
'value': None,
'id': '5'
}, {
'custom_field_id': '12',
'value': None,
'id': '6'
}, {
'custom_field_id': '17',
'value': None,
'id': '7'
}, {
'custom_field_id': '14',
'value': None,
'id': '8'
}, {
'custom_field_id': '15',
'value': None,
'id': '9'
}, {
'custom_field_id': '16',
'value': None,
'id': '10'
}, {
'custom_field_id': '21',
'value': None,
'id': '24'
}, {
'custom_field_id': '23',
'value': None,
'id': '25'
}, {
'custom_field_id': '22',
'value': None,
'id': '26'
}, {
'custom_field_id': '27',
'value': None,
'id': '27'
}, {
'custom_field_id': '24',
'value': None,
'id': '28'
}, {
'custom_field_id': '25',
'value': None,
'id': '29'
}, {
'custom_field_id': '26',
'value': None,
'id': '30'
}]
}
})
def test_get_bridge_user_to_add(self):
set_db_records()
# self.maxDiff = None
worker = BridgeWorker()
person = get_person('faculty')
user = worker.get_bridge_user_to_add(person, get_worker(person))
self.assertEqual(
user.to_json_post(), {
'users': [{
'uid':
'*****@*****.**',
'full_name':
'William E Faculty',
'email':
'*****@*****.**',
'custom_field_values':
[{
'custom_field_id': '5',
'value': '10000000000000000000000000000005'
}, {
'custom_field_id': '6',
'value': '000000005'
}, {
'custom_field_id': '7',
'value': '0000005'
}, {
'custom_field_id': '11',
'value': '3040111000'
}, {
'custom_field_id': '13',
'value': 'Academic Personnel'
}, {
'custom_field_id': '12',
'value': '21184'
}, {
'custom_field_id': '17',
'value': 'Seattle Campus'
}, {
'custom_field_id': '14',
'value': 'SOM:'
}, {
'custom_field_id': '15',
'value': 'Family Medicine: Volunteer JM Academic'
}, {
'custom_field_id': '16',
'value': '00753'
}, {
'custom_field_id': '21',
'value': None
}, {
'custom_field_id': '23',
'value': None
}, {
'custom_field_id': '22',
'value': None
}, {
'custom_field_id': '27',
'value': None
}, {
'custom_field_id': '24',
'value': None
}, {
'custom_field_id': '25',
'value': None
}, {
'custom_field_id': '26',
'value': None
}],
'first_name':
'William E',
'last_name':
'Faculty',
'sortable_name':
'Faculty, William E',
'manager_id':
196,
'job_title':
'Clinical Associate Professor'
}]
})
def test_get_job_title(self):
self.assertIsNone(get_job_title(None))
person = get_person('javerage')
hrp_wkr = get_worker(person)
self.assertEqual(get_job_title(hrp_wkr),
"Student Reference Specialist - GMM")