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)