def test_list_devices_with_filter_message(self):
message = device_message.Device(
enrolled=True, device_model='HP Chromebook 13 G1', current_ou='/')
service = root_api.Service()
filters = service.to_dict(message, device_model.Device)
request = device_message.Device(**filters)
response = self.service.list_devices(request)
self.assertEqual(1, len(response.devices))
self.assertEqual(response.devices[0].serial_number, '6789')
def test_list_devices_with_page_token(self):
request = device_message.Device(enrolled=True, page_size=1)
response = self.service.list_devices(request)
response_devices = []
while response.page_token or response.additional_results:
for device in response.devices:
response_devices.append(device)
request = device_message.Device(
enrolled=True, page_size=1, page_token=response.page_token)
response = self.service.list_devices(request)
self.assertEqual(2, len(response_devices))
def test_list_devices_with_search_constraints(self):
expressions = shared_messages.SearchExpression(
expression='serial_number')
expected_response = device_message.ListDevicesResponse(
devices=[device_message.Device(serial_number='6789')],
additional_results=False)
request = device_message.Device(query=shared_messages.SearchRequest(
query_string='sn:6789',
expressions=[expressions],
returned_fields=['serial_number']))
response = self.service.list_devices(request)
self.assertEqual(response.devices[0].serial_number,
expected_response.devices[0].serial_number)
self.assertFalse(response.additional_results)
def test_list_devices(self):
request = device_message.Device(enrolled=True)
response = self.service.list_devices(request)
self.assertEqual(2, len(response.devices))
# Test list_devices with current ou filter.
request = device_message.Device(enrolled=True, current_ou='/')
response = self.service.list_devices(request)
self.assertEqual(2, len(response.devices))
# Test list_devices with chrome_device_id filter.
request = device_message.Device(
enrolled=True, chrome_device_id='unique_id_2')
response = self.service.list_devices(request)
self.assertEqual(1, len(response.devices))
def test_list_devices_with_malformed_page_token(self):
"""Test list devices with a fake token, raises BadRequestException."""
request = device_message.Device(page_token='malformedtoken')
with self.assertRaisesRegexp(
endpoints.BadRequestException,
root_api._MALFORMED_PAGE_TOKEN_MSG):
self.service.list_devices(request)
def _build_device_message(device,
shelf_message,
last_reminder_message,
next_reminder_message,
max_extend_date=None,
guest_enabled=None,
guest_permitted=None):
"""Builds a device_message.Device message with the passed device's attributes.
Args:
device: device_model.Device, an instance of device used to populate the
ProtoRPC message.
shelf_message: ProtoRPC message containing a shelf_message.Shelf.
last_reminder_message: ProtoRPC message containing a
device_message.Reminder.
next_reminder_message: ProtoRPC message containing a
device_message.Reminder.
max_extend_date: datetime, Indicates maximum extend date a device can have.
guest_enabled: bool, Indicates if guest mode has been already enabled.
guest_permitted: bool, Indicates if guest mode has been allowed.
Returns:
A device_message.Device ProtoRPC message.
"""
message = device_message.Device(
serial_number=device.serial_number,
asset_tag=device.asset_tag,
enrolled=device.enrolled,
device_model=device.device_model,
due_date=device.due_date,
last_known_healthy=device.last_known_healthy,
shelf=shelf_message,
assigned_user=device.assigned_user,
assignment_date=device.assignment_date,
current_ou=device.current_ou,
ou_changed_date=device.ou_changed_date,
locked=device.locked,
lost=device.lost,
mark_pending_return_date=device.mark_pending_return_date,
chrome_device_id=device.chrome_device_id,
last_heartbeat=device.last_heartbeat,
damaged=device.damaged,
damaged_reason=device.damaged_reason,
last_reminder=last_reminder_message,
next_reminder=next_reminder_message)
if device.assigned_user is not None:
return_dates = device.calculate_return_dates()
message.return_date = return_dates.default
if max_extend_date is not None:
message.max_extend_date = max_extend_date
if guest_enabled is not None:
message.guest_enabled = guest_enabled
if guest_permitted is not None:
message.guest_permitted = guest_permitted
return message
def test_build_device_message_from_model(self):
"""Test the construction of a device message from a device entity."""
test_device = device_model.Device(
serial_number='test_serial_value',
asset_tag='test_asset_tag_value',
enrolled=True,
device_model='test model value',
due_date=datetime.datetime(year=2018, month=1, day=1),
last_known_healthy=datetime.datetime(year=2018, month=1, day=2),
shelf=self.test_shelf_model.key,
assigned_user='******',
assignment_date=datetime.datetime(year=2018, month=1, day=3),
current_ou=constants.ORG_UNIT_DICT['GUEST'],
ou_changed_date=datetime.datetime(year=2018, month=1, day=4),
locked=True,
lost=False,
mark_pending_return_date=datetime.datetime(year=2018,
month=1,
day=5),
chrome_device_id='device id value',
last_heartbeat=datetime.datetime(year=2018, month=1, day=6),
damaged=None,
damaged_reason='Not damaged',
last_reminder=device_model.Reminder(level=1),
next_reminder=device_model.Reminder(level=2),
).put().get()
expected_message = device_message.Device(
serial_number='test_serial_value',
asset_tag='test_asset_tag_value',
enrolled=True,
device_model='test model value',
due_date=datetime.datetime(year=2018, month=1, day=1),
last_known_healthy=datetime.datetime(year=2018, month=1, day=2),
shelf=self.expected_shelf_message,
assigned_user='******',
assignment_date=datetime.datetime(year=2018, month=1, day=3),
current_ou=constants.ORG_UNIT_DICT['GUEST'],
ou_changed_date=datetime.datetime(year=2018, month=1, day=4),
locked=True,
lost=False,
mark_pending_return_date=datetime.datetime(year=2018,
month=1,
day=5),
chrome_device_id='device id value',
last_heartbeat=datetime.datetime(year=2018, month=1, day=6),
damaged=None,
damaged_reason='Not damaged',
last_reminder=device_message.Reminder(level=1),
next_reminder=device_message.Reminder(level=2),
guest_permitted=True,
guest_enabled=True,
max_extend_date=test_device.calculate_return_dates().max,
)
actual_message = api_utils.build_device_message_from_model(
test_device, True)
self.assertEqual(actual_message, expected_message)
def test_list_devices_with_shelf_filter(self, mock_get_shelf):
# Test for shelf location as filter.
mock_get_shelf.return_value = self.shelf
shelf_request_message = shelf_messages.ShelfRequest(
location=self.shelf.location)
message = shelf_messages.Shelf(shelf_request=shelf_request_message)
request = device_message.Device(shelf=message)
response = self.service.list_devices(request)
mock_get_shelf.assert_called_once_with(shelf_request_message)
self.assertEqual(len(response.devices), 2)
def test_list_devices_with_shelf_filter(
self, mock_get_shelf, mock_model_list_devices):
# Test for shelf location as filter.
mock_model_list_devices.return_value = ([self.device], None, False)
mock_get_shelf.return_value = self.shelf
message = shelf_message.Shelf(location=self.shelf.location)
request = device_message.Device(shelf=message)
response = self.service.list_devices(request)
mock_get_shelf.assert_called_once_with(location=self.shelf.location)
self.assertEqual(
response.devices[0].serial_number, self.device.serial_number)
def build_device_message_from_model(device, guest_permitted):
"""Builds a device_message.Device ProtoRPC message.
Args:
device: device_model.Device, a device entity to convert into a message.
guest_permitted: bool, whether or not guest is permitted for this
organization.
Returns:
A populated device_message.Device ProtoRPC message.
"""
message = device_message.Device(
serial_number=device.serial_number,
asset_tag=device.asset_tag,
enrolled=device.enrolled,
device_model=device.device_model,
due_date=device.due_date,
last_known_healthy=device.last_known_healthy,
assigned_user=device.assigned_user,
assignment_date=device.assignment_date,
current_ou=device.current_ou,
ou_changed_date=device.ou_changed_date,
locked=device.locked,
lost=device.lost,
mark_pending_return_date=device.mark_pending_return_date,
chrome_device_id=device.chrome_device_id,
last_heartbeat=device.last_heartbeat,
damaged=device.damaged,
damaged_reason=device.damaged_reason,
guest_enabled=device.guest_enabled,
guest_permitted=guest_permitted,
)
if device.last_reminder:
message.last_reminder = build_reminder_message_from_model(
device.last_reminder)
if device.next_reminder:
message.next_reminder = build_reminder_message_from_model(
device.next_reminder)
if device.is_assigned:
message.max_extend_date = device.calculate_return_dates().max
if device.shelf:
message.shelf = build_shelf_message_from_model(device.shelf.get())
return message
def list_user_devices(self, request):
"""Lists all devices assigned to the user."""
self.check_xsrf_token(self.request_state)
user = user_lib.get_user_email()
device_messages = []
for device in device_model.Device.list_by_user(user):
return_dates = device.calculate_return_dates()
guest_enabled, max_extend_date, due_date, guest_permitted = (
get_loan_data(device))
del due_date # Unused
device_messages.append(
device_message.Device(serial_number=device.serial_number,
asset_tag=device.asset_tag,
device_model=device.device_model,
due_date=device.due_date,
last_heartbeat=device.last_heartbeat,
assignment_date=device.assignment_date,
max_extend_date=max_extend_date,
return_date=return_dates.default,
guest_enabled=guest_enabled,
guest_permitted=guest_permitted))
return device_message.ListUserDeviceResponse(devices=device_messages)
def test_list_devices_inactive_no_shelf(self): request = device_message.Device(enrolled=False, page_size=1) response = self.service.list_devices(request) self.assertEqual(1, len(response.devices))
class DeviceApiTest(parameterized.TestCase, loanertest.EndpointsTestCase):
"""Tests for the Device API."""
def setUp(self):
super(DeviceApiTest, self).setUp()
self.service = device_api.DeviceApi()
self.login_admin_endpoints_user()
self.shelf = shelf_model.Shelf.enroll(user_email=loanertest.USER_EMAIL,
location='NYC',
capacity=10,
friendly_name='GnG',
latitude=40.6892534,
longitude=-74.0466891,
altitude=1.0)
self.device = device_model.Device()
self.device.serial_number = '123ABC'
self.device.asset_tag = '12345'
self.device.enrolled = True
self.device.device_model = 'Google Pixelbook'
self.device.due_date = datetime.datetime(2017, 11, 15)
self.device.last_known_healthy = datetime.datetime(2017, 11, 1)
self.device.shelf = self.shelf.key
self.device.assigned_user = loanertest.USER_EMAIL
self.device.assignment_date = datetime.datetime(2017, 11, 1)
self.device.current_ou = '/'
self.device.ou_changed_date = datetime.datetime(2017, 11, 1)
self.device.locked = False
self.device.lost = False
self.device.chrome_device_id = 'unique_id_1'
self.device.last_heartbeat = datetime.datetime(2017, 11, 1)
self.device.damaged = False
self.device.damaged_reason = None
self.device.put()
self.device.set_last_reminder(0)
self.device.set_next_reminder(1, datetime.timedelta(hours=2))
device_model.Device(
serial_number='6789',
enrolled=True,
device_model='HP Chromebook 13 G1',
current_ou='/',
chrome_device_id='unique_id_2',
shelf=self.shelf.key,
damaged=False,
).put()
self.unenrolled_device = device_model.Device(
serial_number='4567',
enrolled=False,
device_model='HP Chromebook 13 G1',
current_ou='/',
chrome_device_id='unique_id_3',
damaged=False,
)
self.unenrolled_device.put()
self.unenrolled_device_directory = {
'deviceId': 'unique_id',
'serialNumber': '4567',
'status': 'ACTIVE',
'lastSync': datetime.datetime.utcnow(),
'model': 'HP Chromebook 13 G1',
'orgUnitPath': constants.ORG_UNIT_DICT['DEFAULT'],
}
def tearDown(self):
super(DeviceApiTest, self).tearDown()
self.service = None
@mock.patch.object(directory, 'DirectoryApiClient', autospec=True)
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)
@parameterized.parameters((datastore_errors.BadValueError, ),
(device_model.DeviceCreationError, ))
@mock.patch.object(device_model, 'Device', autospec=True)
def test_enroll_error(self, test_error, mock_device_cls):
mock_device_cls.enroll.side_effect = test_error
request = device_message.DeviceRequest(
serial_number=self.unenrolled_device.serial_number)
with self.assertRaises(endpoints.BadRequestException):
self.service.enroll(request)
@mock.patch.object(device_model, 'Device', autospec=True)
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)
@mock.patch.object(directory, 'DirectoryApiClient', autospec=True)
@mock.patch.object(root_api.Service, 'check_xsrf_token', autospec=True)
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)
assert mock_xsrf_token.call_count == 1
@mock.patch('__main__.device_model.Device.device_audit_check')
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_device_audit_check_device_not_enrolled(self):
request = device_message.DeviceRequest(
unknown_identifier=self.device.serial_number)
self.device.enrolled = False
with self.assertRaises(device_api.endpoints.BadRequestException):
self.service.device_audit_check(request)
def test_device_audit_check_device_damaged(self):
request = device_message.DeviceRequest(
unknown_identifier=self.device.serial_number)
self.device.damaged = True
with self.assertRaises(device_api.endpoints.BadRequestException):
self.service.device_audit_check(request)
@mock.patch.object(directory, 'DirectoryApiClient', autospec=True)
def test_get_device_not_found(self, mock_directory_class):
mock_directory_client = mock_directory_class.return_value
mock_directory_client.given_name.return_value = 'given name value'
request = device_message.DeviceRequest(unknown_identifier='not-found')
with self.assertRaises(device_api.endpoints.NotFoundException):
self.service.get_device(request)
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)
@mock.patch.object(directory, 'DirectoryApiClient', autospec=True)
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)
@parameterized.parameters(directory.DirectoryRPCError,
directory.GivenNameDoesNotExistError)
@mock.patch.object(directory, 'DirectoryApiClient', autospec=True)
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)
@parameterized.parameters((
device_message.Device(enrolled=True),
2,
), (
device_message.Device(current_ou='/'),
2,
), (
device_message.Device(enrolled=False),
1,
), (
device_message.Device(query=shared_messages.SearchRequest(
query_string='sn:6789')),
1,
), (
device_message.Device(query=shared_messages.SearchRequest(
query_string='at:12345')),
1,
))
def test_list_devices(self, request, response_length):
response = self.service.list_devices(request)
self.assertEqual(response_length, len(response.devices))
def test_list_devices_with_search_constraints(self):
expressions = shared_messages.SearchExpression(
expression='serial_number')
expected_response = device_message.ListDevicesResponse(
devices=[device_message.Device(serial_number='6789')],
additional_results=False)
request = device_message.Device(query=shared_messages.SearchRequest(
query_string='sn:6789',
expressions=[expressions],
returned_fields=['serial_number']))
response = self.service.list_devices(request)
self.assertEqual(response.devices[0].serial_number,
expected_response.devices[0].serial_number)
self.assertFalse(response.additional_results)
def test_list_devices_with_filter_message(self):
message = device_message.Device(enrolled=True,
device_model='HP Chromebook 13 G1',
current_ou='/')
filters = api_utils.to_dict(message, device_model.Device)
request = device_message.Device(**filters)
response = self.service.list_devices(request)
self.assertEqual(1, len(response.devices))
self.assertEqual(response.devices[0].serial_number, '6789')
@mock.patch('__main__.device_api.shelf_api.get_shelf')
def test_list_devices_with_shelf_filter(self, mock_get_shelf):
# Test for shelf location as filter.
mock_get_shelf.return_value = self.shelf
shelf_request_message = shelf_messages.ShelfRequest(
location=self.shelf.location)
message = shelf_messages.Shelf(shelf_request=shelf_request_message)
request = device_message.Device(shelf=message)
response = self.service.list_devices(request)
mock_get_shelf.assert_called_once_with(shelf_request_message)
self.assertEqual(len(response.devices), 2)
def test_list_devices_with_page_token(self):
request = device_message.Device(enrolled=True, page_size=1)
response_devices = []
while True:
response = self.service.list_devices(request)
for device in response.devices:
response_devices.append(device)
request = device_message.Device(enrolled=True,
page_size=1,
page_token=response.page_token)
if not response.additional_results:
break
self.assertEqual(2, len(response_devices))
@mock.patch.object(search_utils,
'to_query',
return_value='enrolled:enrolled',
autospec=True)
def test_list_devices_with_malformed_page_token(self, mock_to_query):
"""Test list devices with a fake token, raises BadRequestException."""
request = device_message.Device(page_token='malformedtoken')
with self.assertRaises(endpoints.BadRequestException):
self.service.list_devices(request)
def test_list_devices_inactive_no_shelf(self):
request = device_message.Device(enrolled=False, page_size=1)
response = self.service.list_devices(request)
self.assertEqual(1, len(response.devices))
@mock.patch('__main__.device_model.Device.list_by_user')
@mock.patch.object(root_api.Service, 'check_xsrf_token', autospec=True)
def test_list_user_devices(self, mock_xsrf_token, mock_list_by_user):
self.login_endpoints_user()
device2 = device_model.Device()
device2.serial_number = '123ABC'
device2.assigned_user = loanertest.USER_EMAIL
device2.assignment_date = datetime.datetime(2017, 11, 1)
device2.due_date = datetime.datetime(2017, 11, 4)
device2.put()
request = message_types.VoidMessage()
mock_list_by_user.return_value = [self.device, device2]
response = self.service.list_user_devices(request)
self.assertEqual(response.devices[0].serial_number,
self.device.serial_number)
self.assertEqual(len(response.devices), 2)
assert mock_xsrf_token.call_count == 1
mock_list_by_user.assert_called_once_with(loanertest.USER_EMAIL)
@mock.patch('__main__.device_model.Device.enable_guest_mode')
@mock.patch.object(root_api.Service, 'check_xsrf_token', autospec=True)
def test_enable_guest_mode(self, mock_xsrf_token, mock_enableguest):
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
assert mock_xsrf_token.call_count == 1
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
assert mock_xsrf_token.call_count == 1
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_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()))
@mock.patch('__main__.device_model.Device.loan_extend')
@mock.patch.object(root_api.Service, 'check_xsrf_token', autospec=True)
def test_extend_loan(self, mock_xsrf_token, mock_loanextend):
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)
assert mock_xsrf_token.call_count == 1
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)
assert mock_xsrf_token.call_count == 1
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_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)))
@mock.patch('__main__.device_model.Device.mark_damaged')
@mock.patch.object(root_api.Service, 'check_xsrf_token', autospec=True)
def test_mark_damaged(self, mock_xsrf_token, mock_markdamaged):
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')
assert mock_xsrf_token.call_count == 1
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)
assert mock_xsrf_token.call_count == 1
@mock.patch.object(device_model.Device, 'mark_damaged')
@mock.patch.object(root_api.Service, 'check_xsrf_token', autospec=True)
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'))
@mock.patch('__main__.device_model.Device.mark_lost')
@mock.patch.object(root_api.Service, 'check_xsrf_token', autospec=True)
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)
assert mock_xsrf_token.call_count == 1
@mock.patch.object(device_model.Device, 'mark_lost')
@mock.patch.object(root_api.Service, 'check_xsrf_token', autospec=True)
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()))
@mock.patch('__main__.device_model.Device.mark_pending_return')
@mock.patch.object(root_api.Service, 'check_xsrf_token', autospec=True)
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()))
@mock.patch('__main__.device_model.Device.resume_loan')
@mock.patch.object(root_api.Service, 'check_xsrf_token', autospec=True)
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
@mock.patch.object(device_model.Device, 'resume_loan')
@mock.patch.object(root_api.Service, 'check_xsrf_token', autospec=True)
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_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_list_devices_with_malformed_page_token(self, mock_to_query):
"""Test list devices with a fake token, raises BadRequestException."""
request = device_message.Device(page_token='malformedtoken')
with self.assertRaises(endpoints.BadRequestException):
self.service.list_devices(request)
