def test_extend_loan(
self, mock_xsrf_token, mock_loanextend, mock_confirm_user_action):
tomorrow = datetime.datetime.utcnow() + datetime.timedelta(days=1)
self.login_endpoints_user()
self.service.extend_loan(device_message.ExtendLoanRequest(
device=device_message.DeviceRequest(urlkey=self.device.key.urlsafe()),
extend_date=tomorrow))
mock_loanextend.assert_called_once_with(
user_email=loanertest.USER_EMAIL, extend_date_time=tomorrow)
mock_confirm_user_action.assert_called_once_with(
loanertest.USER_EMAIL, self.device)
mock_xsrf_token.assert_called_once()
mock_xsrf_token.reset_mock()
mock_loanextend.reset_mock()
self.service.extend_loan(device_message.ExtendLoanRequest(
device=device_message.DeviceRequest(
chrome_device_id=self.device.chrome_device_id),
extend_date=tomorrow))
mock_loanextend.assert_called_once_with(
user_email=loanertest.USER_EMAIL, extend_date_time=tomorrow)
mock_xsrf_token.assert_called_once()
mock_loanextend.side_effect = device_model.ExtendError
self.assertRaises(
device_api.endpoints.BadRequestException,
self.service.extend_loan,
device_message.ExtendLoanRequest(
device=device_message.DeviceRequest(
chrome_device_id=self.device.chrome_device_id),
extend_date=tomorrow))
def test_get_device_errors(self):
# No identifiers.
with self.assertRaises(endpoints.BadRequestException):
device_api._get_device(device_message.DeviceRequest())
# URL-safe key that is still URL-safe, but technically not a key.
with self.assertRaises(device_api.endpoints.BadRequestException):
device_api._get_device(
device_message.DeviceRequest(urlkey='bad-key'))
def test_get_device_errors(self):
# No identifiers.
self.assertRaisesRegexp(
device_api.endpoints.BadRequestException,
device_api._NO_IDENTIFIERS_MSG, device_api._get_device,
device_message.DeviceRequest())
# URL-safe key that is still URL-safe, but technically not a key.
self.assertRaisesRegexp(
device_api.endpoints.BadRequestException,
device_api._BAD_URLKEY_MSG % 'bad-key', device_api._get_device,
device_message.DeviceRequest(urlkey='bad-key'))
def test_unenroll_error(self, mock_device_cls):
mock_device_cls.get.return_value.unenroll.side_effect = (
device_model.FailedToUnenrollError())
request = device_message.DeviceRequest(
serial_number=self.unenrolled_device.serial_number)
with self.assertRaises(endpoints.BadRequestException):
self.service.unenroll(request)
def test_get_device_not_enrolled(self):
constants.ON_LOCAL = False
request = device_message.DeviceRequest(unknown_identifier='not-enrolled')
self.assertRaisesRegexp(
device_api.endpoints.NotFoundException,
device_api._NO_DEVICE_MSG % 'not-enrolled',
self.service.get_device, request)
def test_device_audit_check(self, mock_device_audit_check):
request = device_message.DeviceRequest(unknown_identifier='6765')
self.assertRaisesRegexp(device_api.endpoints.NotFoundException,
device_api._NO_DEVICE_MSG % '6765',
self.service.device_audit_check, request)
device_model.Device(serial_number='12345',
enrolled=True,
device_model='HP Chromebook 13 G1',
current_ou='/',
chrome_device_id='unique_id_1',
damaged=False).put()
request = device_message.DeviceRequest(unknown_identifier='12345')
response = self.service.device_audit_check(request)
assert mock_device_audit_check.call_count == 1
self.assertIsInstance(response, message_types.VoidMessage)
def test_mark_pending_return(self, mock_xsrf_token, mock_markreturned):
self.login_endpoints_user()
self.service.mark_pending_return(
device_message.DeviceRequest(urlkey=self.device.key.urlsafe()))
mock_markreturned.assert_called_once_with(
user_email=loanertest.USER_EMAIL)
assert mock_xsrf_token.call_count == 1
def test_mark_pending_return_unassigned(self):
self.device.assigned_user = None
self.device.put()
with self.assertRaisesRegexp(endpoints.UnauthorizedException,
device_model._UNASSIGNED_DEVICE):
self.service.mark_pending_return(
device_message.DeviceRequest(urlkey=self.device.key.urlsafe()))
def test_device_audit_check_device_damaged(self):
request = device_message.DeviceRequest(
unknown_identifier=self.device.serial_number)
self.device.damaged = True
with self.assertRaisesRegexp(
device_api.endpoints.BadRequestException,
device_model._DEVICE_DAMAGED_MSG %self.device.serial_number):
self.service.device_audit_check(request)
def test_enable_guest_unassigned(self):
config_model.Config.set('allow_guest_mode', True)
self.device.assigned_user = None
self.device.put()
with self.assertRaisesRegexp(endpoints.UnauthorizedException,
device_model._UNASSIGNED_DEVICE):
self.service.enable_guest_mode(
device_message.DeviceRequest(urlkey=self.device.key.urlsafe()))
def test_device_audit_check_device_not_enrolled(self):
request = device_message.DeviceRequest(
unknown_identifier=self.device.serial_number)
self.device.enrolled = False
with self.assertRaisesRegexp(
device_api.endpoints.BadRequestException,
device_model._DEVICE_NOT_ENROLLED_MSG % self.device.serial_number):
self.service.device_audit_check(request)
def test_resume_loan__unauthorized(self, mock_xsrf_token,
mock_resume_loan):
del mock_xsrf_token # unused.
self.login_endpoints_user()
mock_resume_loan.side_effect = device_model.UnauthorizedError()
with self.assertRaises(endpoints.UnauthorizedException):
self.service.resume_loan(
device_message.DeviceRequest(urlkey=self.device.key.urlsafe()))
def test_resume_loan(
self, mock_xsrf_token, mock_resume_loan, mock_confirm_user_action):
self.login_endpoints_user()
self.service.resume_loan(device_message.DeviceRequest(
urlkey=self.device.key.urlsafe()))
mock_resume_loan.assert_called_once()
mock_confirm_user_action.assert_called_once_with(
loanertest.USER_EMAIL, self.device)
mock_xsrf_token.assert_called_once()
def test_extend_loan_unassigned(self):
self.device.assigned_user = None
self.device.put()
with self.assertRaisesRegexp(endpoints.UnauthorizedException,
device_model._UNASSIGNED_DEVICE):
self.service.extend_loan(
device_message.ExtendLoanRequest(
device=device_message.DeviceRequest(
chrome_device_id=self.device.chrome_device_id)))
def test_mark_damaged(
self, mock_xsrf_token, mock_markdamaged, mock_confirm_user_action):
self.login_endpoints_user()
self.service.mark_damaged(device_message.DamagedRequest(
device=device_message.DeviceRequest(urlkey=self.device.key.urlsafe()),
damaged_reason='Foo'))
mock_markdamaged.assert_called_once_with(
user_email=loanertest.USER_EMAIL, damaged_reason='Foo')
mock_confirm_user_action.assert_called_once_with(
loanertest.USER_EMAIL, self.device)
mock_xsrf_token.assert_called_once()
mock_xsrf_token.reset_mock()
mock_markdamaged.reset_mock()
self.service.mark_damaged(device_message.DamagedRequest( # No reason given.
device=device_message.DeviceRequest(urlkey=self.device.key.urlsafe())))
mock_markdamaged.assert_called_once_with(
user_email=loanertest.USER_EMAIL, damaged_reason=None)
mock_xsrf_token.assert_called_once()
def test_mark_damaged__unauthorized(self, mock_xsrf, mock_markdamaged):
del mock_xsrf # unusued.
self.login_endpoints_user()
mock_markdamaged.side_effect = device_model.UnauthorizedError()
with self.assertRaises(endpoints.UnauthorizedException):
self.service.mark_damaged(
device_message.DamagedRequest(
device=device_message.DeviceRequest(
urlkey=self.device.key.urlsafe()),
damaged_reason='Foo'))
def test_get_device_unable_to_get_shelf(self):
# Delete the existing shelf key from datastore.
self.shelf.key.delete()
# Make sure it raises the execption after deleteing the key.
with self.assertRaisesRegexp(
device_api.endpoints.NotFoundException,
device_api._SHELF_NOT_FOUND_MSG % self.device.shelf.urlsafe()):
self.service.get_device(
device_message.DeviceRequest(
chrome_device_id=self.device.chrome_device_id))
def test_unenroll(self, mock_xsrf_token, mock_directoryclass):
mock_directoryclient = mock_directoryclass.return_value
mock_directoryclient.move_chrome_device_org_unit.return_value = (
loanertest.TEST_DIR_DEVICE_DEFAULT)
request = device_message.DeviceRequest(
serial_number=self.device.serial_number)
self.assertTrue(self.device.enrolled)
response = self.service.unenroll(request)
self.assertFalse(self.device.enrolled)
self.assertIsNone(self.device.assigned_user)
self.assertIsNone(self.device.due_date)
self.assertIsInstance(response, message_types.VoidMessage)
mock_xsrf_token.assert_called_once()
def test_unenroll_error(self, mock_directoryclass):
err_message = 'Failed to move device'
mock_directoryclient = mock_directoryclass.return_value
mock_directoryclient.move_chrome_device_org_unit.side_effect = (
device_model.directory.DirectoryRPCError(err_message))
request = device_message.DeviceRequest(
serial_number=self.unenrolled_device.serial_number)
ou = config_model.Config.get('unenroll_ou')
with self.assertRaisesRegexp(
endpoints.BadRequestException,
device_model._FAILED_TO_MOVE_DEVICE_MSG % (
self.unenrolled_device.serial_number, ou, err_message)):
self.service.unenroll(request)
def test_get_device(self):
constants.ON_LOCAL = False
asset_tag_response = self.service.get_device(
device_message.DeviceRequest(asset_tag='12345'))
chrome_device_id_response = self.service.get_device(
device_message.DeviceRequest(chrome_device_id='unique_id_1'))
serial_number_response = self.service.get_device(
device_message.DeviceRequest(serial_number='123ABC'))
urlkey_response = self.service.get_device(
device_message.DeviceRequest(urlkey=self.device.key.urlsafe()))
unknown_identifier_response = self.service.get_device(
device_message.DeviceRequest(unknown_identifier='123ABC'))
self.assertIsInstance(asset_tag_response, device_message.Device)
self.assertIsInstance(chrome_device_id_response, device_message.Device)
self.assertIsInstance(serial_number_response, device_message.Device)
self.assertIsInstance(urlkey_response, device_message.Device)
self.assertIsInstance(unknown_identifier_response, device_message.Device)
self.assertEqual(
self.device.serial_number, asset_tag_response.serial_number)
self.assertEqual(
self.device.device_model, urlkey_response.device_model)
def test_enable_guest_mode(
self, mock_xsrf_token, mock_enableguest, mock_confirm_user_action):
config_model.Config.set('allow_guest_mode', True)
self.login_endpoints_user()
self.service.enable_guest_mode(
device_message.DeviceRequest(urlkey=self.device.key.urlsafe()))
assert mock_enableguest.called
mock_confirm_user_action.assert_called_once_with(
loanertest.USER_EMAIL, self.device)
mock_xsrf_token.assert_called_once()
mock_xsrf_token.reset_mock()
mock_enableguest.reset_mock()
self.service.enable_guest_mode(device_message.DeviceRequest(
chrome_device_id=self.device.chrome_device_id))
assert mock_enableguest.called
mock_xsrf_token.assert_called_once()
def guest_disabled_error(*args, **kwargs):
del args, kwargs # Unused.
raise device_model.GuestNotAllowedError(
device_model._GUEST_MODE_DISABLED_MSG)
def directory_error(*args, **kwargs):
del args, kwargs # Unused.
raise device_model.EnableGuestError('Directory broke, all your fault.')
mock_enableguest.side_effect = guest_disabled_error
with self.assertRaises(endpoints.UnauthorizedException):
self.service.enable_guest_mode(
device_message.DeviceRequest(
chrome_device_id=self.device.chrome_device_id))
mock_enableguest.side_effect = directory_error
with self.assertRaises(endpoints.InternalServerErrorException):
self.service.enable_guest_mode(
device_message.DeviceRequest(
chrome_device_id=self.device.chrome_device_id))
def test_get_device(self, mock_directory_class):
mock_directory_client = mock_directory_class.return_value
mock_directory_client.given_name.return_value = 'given name value'
asset_tag_response = self.service.get_device(
device_message.DeviceRequest(asset_tag='12345'))
chrome_device_id_response = self.service.get_device(
device_message.DeviceRequest(chrome_device_id='unique_id_1'))
serial_number_response = self.service.get_device(
device_message.DeviceRequest(serial_number='123ABC'))
urlkey_response = self.service.get_device(
device_message.DeviceRequest(urlkey=self.device.key.urlsafe()))
unknown_identifier_response = self.service.get_device(
device_message.DeviceRequest(unknown_identifier='123ABC'))
self.assertIsInstance(asset_tag_response, device_message.Device)
self.assertIsInstance(chrome_device_id_response, device_message.Device)
self.assertIsInstance(serial_number_response, device_message.Device)
self.assertIsInstance(urlkey_response, device_message.Device)
self.assertIsInstance(unknown_identifier_response,
device_message.Device)
self.assertEqual(self.device.serial_number,
asset_tag_response.serial_number)
self.assertEqual(self.device.device_model,
urlkey_response.device_model)
def test_enroll(self, mock_xsrf_token, mock_directoryclass):
"""Tests Enroll with mock methods."""
mock_directoryclient = mock_directoryclass.return_value
mock_directoryclient.get_chrome_device.return_value = (
self.unenrolled_device)
retrieved_device = device_model.Device.get(
serial_number=self.unenrolled_device.serial_number)
self.assertFalse(retrieved_device.enrolled)
request = device_message.DeviceRequest(
serial_number=self.unenrolled_device.serial_number)
response = self.service.enroll(request)
self.assertIsInstance(response, message_types.VoidMessage)
retrieved_device = device_model.Device.get(
serial_number=self.unenrolled_device.serial_number)
self.assertTrue(retrieved_device.enrolled)
mock_xsrf_token.assert_called_once()
def test_enroll(self, mock_directoryclass):
"""Tests Enroll with mock methods."""
mock_directoryclient = mock_directoryclass.return_value
mock_directoryclient.get_chrome_device.return_value = (
self.unenrolled_device)
mock_directoryclient.get_chrome_device_by_serial.return_value = (
self.unenrolled_device_directory)
retrieved_device = device_model.Device.get(
serial_number=self.unenrolled_device.serial_number)
self.assertFalse(retrieved_device.enrolled)
request = device_message.DeviceRequest(
serial_number=self.unenrolled_device.serial_number)
with mock.patch.object(self.service, 'check_xsrf_token',
autospec=True) as mock_xsrf_token:
response = self.service.enroll(request)
self.assertIsInstance(response, message_types.VoidMessage)
retrieved_device = device_model.Device.get(
serial_number=self.unenrolled_device.serial_number)
self.assertTrue(retrieved_device.enrolled)
self.assertEqual(mock_xsrf_token.call_count, 1)
def test_get_device_unenrolled(self):
request = device_message.DeviceRequest(
unknown_identifier=self.device.serial_number)
self.device.enrolled = False
with self.assertRaises(device_api.endpoints.BadRequestException):
self.service.get_device(request)
def test_get_device_directory_errors(self, test_error,
mock_directory_class):
request = device_message.DeviceRequest(asset_tag='12345')
mock_directory_client = mock_directory_class.return_value
mock_directory_client.given_name.side_effect = test_error
self.assertIsNone(self.service.get_device(request).given_name)
def test_mark_lost(self, mock_xsrf_token, mock_marklost):
self.service.mark_lost(device_message.DeviceRequest(
urlkey=self.device.key.urlsafe()))
mock_marklost.assert_called_once_with(
user_email=loanertest.SUPER_ADMIN_EMAIL)
mock_xsrf_token.assert_called_once()
def test_mark_lost__unauthorized(self, mock_xsrf_token, mock_marklost):
del mock_xsrf_token # unused.
mock_marklost.side_effect = device_model.UnauthorizedError()
with self.assertRaises(endpoints.UnauthorizedException):
self.service.mark_lost(
device_message.DeviceRequest(urlkey=self.device.key.urlsafe()))
def test_resume_loan(self, mock_xsrf_token, mock_resume_loan):
self.login_endpoints_user()
self.service.resume_loan(
device_message.DeviceRequest(urlkey=self.device.key.urlsafe()))
assert mock_resume_loan.call_count == 1
assert mock_xsrf_token.call_count == 1
def test_get_device_no_shelf(self):
chrome_device_id_response = self.service.get_device(
device_message.DeviceRequest(chrome_device_id='unique_id_3'))
self.assertIsNone(chrome_device_id_response.shelf)
