def setUp(self):
super(DeviceModelTest, self).setUp()
config_model.Config.set(
'device_identifier_mode',
config_model.DeviceIdentifierMode.SERIAL_NUMBER)
self.shelf = shelf_model.Shelf.enroll(user_email=loanertest.USER_EMAIL,
location='MTV',
capacity=10,
friendly_name='MTV office')
device_model.Device(serial_number='12321',
enrolled=True,
device_model='HP Chromebook 13 G1',
current_ou='/',
shelf=self.shelf.key,
chrome_device_id='unique_id_1',
damaged=False).put()
device_model.Device(serial_number='67890',
enrolled=True,
device_model='Google Pixelbook',
current_ou='/',
shelf=self.shelf.key,
chrome_device_id='unique_id_2',
damaged=False).put()
device_model.Device(serial_number='VOID',
enrolled=False,
device_model='HP Chromebook 13 G1',
current_ou='/',
shelf=self.shelf.key,
chrome_device_id='unique_id_8',
damaged=False).put()
self.device1 = device_model.Device.get(serial_number='12321')
self.device2 = device_model.Device.get(serial_number='67890')
self.device3 = device_model.Device.get(serial_number='Void')
datastore_user = user_model.User.get_user(loanertest.USER_EMAIL)
datastore_user.update(superadmin=True)
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 tests_send_user_email_bad_device(self):
"""Test sending mail to users with devices with incomplete loan data."""
now = datetime.datetime.utcnow()
last_week = now - datetime.timedelta(days=7)
test_device_no_assigned_user = device_model.Device(
serial_number='12345ABC',
chrome_device_id='4815162342',
assignment_date=last_week,
due_date=now)
test_device_no_assignment_date = device_model.Device(
serial_number='67890DEF',
chrome_device_id='314159265',
assigned_user=loanertest.USER_EMAIL,
due_date=now)
test_device_no_due_date = device_model.Device(
serial_number='12345GHI',
chrome_device_id='35897932',
assigned_user=loanertest.USER_EMAIL,
assignment_date=last_week)
self.assertRaises(send_email.SendEmailError,
send_email.send_user_email,
test_device_no_assigned_user,
'test_reminder_template')
self.assertRaises(send_email.SendEmailError,
send_email.send_user_email,
test_device_no_assignment_date,
'test_reminder_template')
self.assertRaises(send_email.SendEmailError,
send_email.send_user_email, test_device_no_due_date,
'test_reminder_template')
def test_get(self):
test_devices = [
device_model.Device(
asset_tag='ASSET_TAG_{}'.format(str(number)),
chrome_device_id='chrome_id_{}'.format(str(number)),
serial_number='SERIAL_NUMBER_{}'.format(str(number)))
for number in xrange(3)
]
for device in test_devices:
device.put()
with self.assertRaises(device_model.DeviceIdentifierError):
device_model.Device.get() # No args.
self.assertEqual(
device_model.Device.get(asset_tag='asset_tag_0').serial_number,
'SERIAL_NUMBER_0')
self.assertEqual(
device_model.Device.get(serial_number='serial_number_1').asset_tag,
'ASSET_TAG_1')
self.assertEqual(
device_model.Device.get(chrome_device_id='chrome_id_2').asset_tag,
'ASSET_TAG_2')
# Unknown_identifier is can take either an asset tag or serial number.
self.assertEqual(
device_model.Device.get(
unknown_identifier='asset_tag_0').asset_tag, 'ASSET_TAG_0')
self.assertEqual(
device_model.Device.get(
unknown_identifier='serial_number_1').serial_number,
'SERIAL_NUMBER_1')
def test_run_success(self, mock_lock):
device = device_model.Device(
serial_number='123456', chrome_device_id='123',
next_reminder=device_model.Reminder(level=0))
self.action.run(device=device)
mock_lock.assert_called_with(constants.ADMIN_USERNAME)
def test_enroll_unenrolled_device(self, mock_directoryclass, mock_logging,
mock_to_document):
mock_directoryclient = mock_directoryclass.return_value
mock_directoryclient.move_chrome_device_org_unit.return_value = (
loanertest.TEST_DIR_DEVICE_DEFAULT)
mock_directoryclient.get_chrome_device_by_serial.return_value = (
loanertest.TEST_DIR_DEVICE_DEFAULT)
device = device_model.Device()
device.enrolled = False
device.model = 'HP Chromebook 13 G1'
device.serial_number = '123456'
device.asset_tag = '123ABC'
device.chrome_device_id = 'unique_id'
device.put()
self.assertEqual(mock_to_document.call_count, 1)
device = device_model.Device.enroll(user_email=loanertest.USER_EMAIL,
serial_number='123456')
self.assertEqual(mock_logging.info.call_count, 2)
retrieved_device = device_model.Device.get(serial_number='123456')
self.assertTrue(retrieved_device.enrolled)
self.testbed.mock_raiseevent.assert_any_call('device_enroll',
device=device)
def test_process_action_handler(self, mock_importactions, mock_loginfo):
"""Test the ProcessActionHandler, which imports the sample action."""
class ActionSample(object):
ACTION_NAME = 'sample'
FRIENDLY_NAME = 'Sample action'
def run(self, device=None, shelf=None):
"""Run the action."""
del shelf # Unused.
info = 'Action with a %s.' % device.__class__.__name__
logging.info(info)
mock_importactions.return_value = {'async': {'sample': ActionSample()}}
test_device = device_model.Device()
payload = pickle.dumps({
'action_name': 'sample',
'device': test_device,
'shelf': None
})
response = self.testapp.post(r'/_ah/queue/process-action', payload)
self.assertEqual(response.status_int, 200)
self.assertEqual(mock_loginfo.call_count, 2)
expected_calls = [
mock.call('ProcessActionHandler loaded %d async actions: %s', 1,
"['sample']"),
mock.call('Action with a Device.')
]
mock_loginfo.assert_has_calls(expected_calls)
def setUp(self):
super(BigQueryRowModelTest, self).setUp()
self.test_shelf = shelf_model.Shelf(friendly_name='Test',
location='Here',
capacity=16)
self.test_shelf.put()
self.test_device = device_model.Device(
serial_number='VOID',
enrolled=False,
device_model='HP Chromebook 13 G1',
current_ou='/',
shelf=self.test_shelf.key,
chrome_device_id='unique_id_8',
damaged=False)
self.test_device.put()
self.test_row_1 = bigquery_row_model.BigQueryRow.add(
self.test_shelf, datetime.datetime.utcnow(),
'test@{}'.format(loanertest.USER_DOMAIN), 'test', 'This is a test')
self.test_row_2 = bigquery_row_model.BigQueryRow.add(
self.test_device, datetime.datetime.utcnow(),
'test@{}'.format(loanertest.USER_DOMAIN), 'test', 'This is a test')
mock_bigquery = mock.patch.object(bigquery_row_model,
'bigquery',
autospec=True)
self.addCleanup(mock_bigquery.stop)
self.mock_bigquery = mock_bigquery.start()
self.mock_bigquery_client = mock.Mock()
self.mock_bigquery.BigQueryClient.return_value = self.mock_bigquery_client
def test_run_success(self, mock_lock):
device = device_model.Device(
serial_number='123456', chrome_device_id='123',
next_reminder=device_model.Reminder(level=0))
self.action.run(device=device)
self.assertEqual(mock_lock.call_count, 1)
def test_run_success(self, mock_sendemail):
device = device_model.Device(serial_number='123456',
chrome_device_id='123')
self.action.run(device=device)
mock_sendemail.assert_called_with(device, 'reminder_return_thanks',
False)
def test_get_whitespace_identifiers(self):
whitespace_test_device = device_model.Device(
enrolled=False,
serial_number='123456',
asset_tag='ABCDE',
chrome_device_id='unique_id').put().get()
self.assertEqual(
device_model.Device.get(asset_tag=' ABCDE '),
whitespace_test_device)
self.assertEqual(
device_model.Device.get(serial_number=' 123456 '),
whitespace_test_device)
self.assertEqual(
device_model.Device.get(chrome_device_id=' unique_id '),
whitespace_test_device)
# Tests using the identifier argument with a serial number.
self.assertEqual(
device_model.Device.get(identifier=' ABCDE '),
whitespace_test_device)
# Tests using the identifier argument with an asset tag.
self.assertEqual(
device_model.Device.get(identifier=' 123456 '),
whitespace_test_device)
def test_create_table(self):
self.table.create.side_effect = cloud.exceptions.Conflict('Exist')
self.client._create_table(
constants.BIGQUERY_DEVICE_TABLE, device_model.Device())
self.assertEqual(self.table.create.call_count, 1)
self.assertEqual(self.table.reload.call_count, 1)
self.assertEqual(self.table.patch.call_count, 1)
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_messages.Device(
serial_number='test_serial_value',
asset_tag='test_asset_tag_value',
identifier='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_messages.Reminder(level=1),
next_reminder=device_messages.Reminder(level=2),
guest_permitted=True,
guest_enabled=True,
max_extend_date=device_model.calculate_return_dates(
test_device.assignment_date).max,
overdue=True,
)
actual_message = api_utils.build_device_message_from_model(
test_device, True)
self.assertEqual(actual_message, expected_message)
def test_run_no_next_reminder(self):
device = device_model.Device(serial_number='123456',
chrome_device_id='123')
self.assertRaisesRegexp( # Raises generic because imported != loaded.
Exception,
'.*without next_reminder.*',
self.action.run,
device=device)
def test_run_no_event(self):
device = device_model.Device( # Raises generic because imported != loaded.
serial_number='123456',
next_reminder=device_model.Reminder(level=0))
self.assertRaisesRegexp(Exception,
'.*no ReminderEvent.*',
self.action.run,
device=device)
def test_lock(self, mock_directoryclass):
mock_directoryclient = mock_directoryclass.return_value
unlocked_device = device_model.Device(
serial_number='123456', chrome_device_id='fake-chrome-789')
unlocked_device.lock(loanertest.USER_EMAIL)
retrieved_device = device_model.Device.get(serial_number='123456')
mock_directoryclient.disable_chrome_device.assert_called_with(
'fake-chrome-789')
self.assertTrue(retrieved_device.locked)
def setUp(self):
super(DeviceModelTest, self).setUp()
config_model.Config.set(
'device_identifier_mode',
config_model.DeviceIdentifierMode.SERIAL_NUMBER)
self.shelf = shelf_model.Shelf.enroll(
user_email=loanertest.USER_EMAIL, location='MTV', capacity=10,
friendly_name='MTV office')
self.tag1_key = tag_model.Tag(
name='TestTag1', hidden=False, protect=True,
color='blue', description='Description 1.').put()
self.tag2_key = tag_model.Tag(
name='TestTag2', hidden=False, protect=False,
color='red', description='Description 2.').put()
self.tag1_data = tag_model.TagData(
tag=self.tag1_key.get(), more_info='tag1_data info.')
self.tag2_data = tag_model.TagData(
tag=self.tag2_key.get(), more_info='tag2_data info.')
device_model.Device(
serial_number='12321', enrolled=True,
device_model='HP Chromebook 13 G1', current_ou='/',
shelf=self.shelf.key, chrome_device_id='unique_id_1',
damaged=False).put()
device_model.Device(
serial_number='67890', enrolled=True,
device_model='Google Pixelbook', current_ou='/',
shelf=self.shelf.key, chrome_device_id='unique_id_2',
damaged=False, tags=[self.tag1_data]).put()
device_model.Device(
serial_number='VOID', enrolled=False,
device_model='HP Chromebook 13 G1', current_ou='/',
shelf=self.shelf.key, chrome_device_id='unique_id_8',
damaged=False, tags=[self.tag1_data, self.tag2_data]).put()
self.device1 = device_model.Device.get(serial_number='12321')
self.device2 = device_model.Device.get(serial_number='67890')
self.device3 = device_model.Device.get(serial_number='Void')
datastore_user = user_model.User.get_user(loanertest.USER_EMAIL)
datastore_user.update(superadmin=True)
def test_stream_row_bq_errors(self):
self.table.insert_data.return_value = 'Oh no it exploded'
now = datetime.datetime.utcnow()
test_device = device_model.Device(serial_number='abc123',
chrome_device_id='123123')
test_device.put()
row = bigquery_row_model.BigQueryRow.add(test_device, now,
loanertest.USER_EMAIL,
'Enroll', 'This is a test')
self.assertRaises(bigquery_client.InsertError, self.client.stream_row,
'test', row._to_bq_format())
def test_stream_row(self):
now = datetime.datetime.utcnow()
test_device = device_model.Device(serial_number='abc123',
chrome_device_id='123123')
test_device.put()
row = bigquery_row_model.BigQueryRow.add(test_device, now,
loanertest.USER_EMAIL,
'Enroll', 'This is a test')
self.client.stream_row('Test table', row._to_bq_format())
self.table.insert_data.called_once()
def test_import(
self, mock_impimporter, mock_getmembers, mock_logwarning):
"""Tests importing modules and actions with success."""
mock_action_loader = mock.Mock()
mock_impimporter.return_value = mock_action_loader
mock_module_loader = mock.Mock()
mock_action_loader.find_module = mock_module_loader
mock_action_loader.iter_modules.return_value = [
('module1', 'fake_module'),
('module2', 'fake_module'),
('module3', 'fake_module'),
('module4', 'fake_module'),
('module5', 'fake_module'),
('module6', 'fake_module'),
('module1_test', 'fake_module'), # Skipped test module.
('base_action', 'fake_module'), # Skipped base_action module.
('module7', 'fake_module')
]
mock_getmembers.side_effect = [
(('WorkingActionClass1', WorkingActionClass1),
('NonClassObject', 'not-a-class')),
(('WorkingActionClass2', WorkingActionClass2),
('NonClassObject', 'not-a-class')),
(('NonWorkingActionClass3', NonWorkingActionClass3),),
(('ActionClassWithoutActionName4', ActionClassWithoutActionName4),),
(('ActionClassWithoutFriendlyName5', ActionClassWithoutFriendlyName5),),
(('ActionClassWithoutRunMethod6', ActionClassWithoutRunMethod6),),
(('DuplicateActionClass', DuplicateActionClass),),
]
test_action_dict = action_loader.load_actions()
test_device = device_model.Device()
self.assertEqual(
test_action_dict[base_action.ActionType.SYNC]['action1'].run(
device=test_device),
test_device)
self.assertIsNone(
test_action_dict[base_action.ActionType.ASYNC]['action2'].run())
mock_logwarning.assert_has_calls([
mock.call(action_loader._INSTANTIATION_ERROR_MSG % (
'ActionClassWithoutActionName4', 'module4',
base_action._NO_ACTION_NAME_MSG % (
'ActionClassWithoutActionName4'))),
mock.call(action_loader._INSTANTIATION_ERROR_MSG % (
'ActionClassWithoutFriendlyName5', 'module5',
base_action._NO_FRIENDLY_NAME_MSG % (
'ActionClassWithoutFriendlyName5'))),
mock.call(action_loader._INSTANTIATION_ERROR_MSG % (
'ActionClassWithoutRunMethod6', 'module6',
base_action._NO_RUN_METHOD_MSG % (
'ActionClassWithoutRunMethod6'))),
])
def test_run_success(self, mock_sendemail):
device = device_model.Device(
serial_number='123456',
chrome_device_id='123',
next_reminder=device_model.Reminder(level=0))
reminder_event = event_models.ReminderEvent.create(0)
reminder_event.template = 'fake_template_name'
self.assertFalse(device.last_reminder)
self.action.run(device=device)
mock_sendemail.assert_called_with(device, 'fake_template_name')
device = device.key.get()
self.assertTrue(device.last_reminder)
def setUp(self):
super(DeviceModelTest, self).setUp()
self.shelf = shelf_model.Shelf.enroll(
user_email=loanertest.USER_EMAIL, location='MTV', capacity=10,
friendly_name='MTV office')
device_model.Device(
serial_number='12321', enrolled=True,
device_model='HP Chromebook 13 G1', current_ou='/',
shelf=self.shelf.key, chrome_device_id='unique_id_1',
damaged=False).put()
device_model.Device(
serial_number='67890', enrolled=True,
device_model='Google Pixelbook', current_ou='/',
shelf=self.shelf.key, chrome_device_id='unique_id_2',
damaged=False).put()
device_model.Device(
serial_number='Void', enrolled=False,
device_model='HP Chromebook 13 G1', current_ou='/',
shelf=self.shelf.key, chrome_device_id='unique_id_8',
damaged=False).put()
self.device = device_model.Device.get(serial_number='12321')
self.device2 = device_model.Device.get(serial_number='67890')
self.device3 = device_model.Device.get(serial_number='Void')
def test_enroll_unenrolled_damaged_device(
self, mock_directoryclass):
mock_directoryclient = mock_directoryclass.return_value
mock_directoryclient.get_chrome_device_by_serial.return_value = (
loanertest.TEST_DIR_DEVICE_DEFAULT)
device_model.Device(
damaged=True, enrolled=False, serial_number='123456').put()
device_model.Device.enroll(
user_email=loanertest.USER_EMAIL, serial_number='123456')
retrieved_device = device_model.Device.get(serial_number='123456')
self.assertTrue(retrieved_device.enrolled)
self.assertFalse(retrieved_device.damaged)
def test_device_audit_check(self, mock_device_audit_check):
request = device_messages.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_messages.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 create_device(self, enrolled=True, assigned_user=None, asset_tag=None):
loan_resumes_if_late_patcher = mock.patch.object(
device_model.Device, 'loan_resumes_if_late')
loan_resumes_if_late_patcher.start()
self.device = device_model.Device(asset_tag=asset_tag,
serial_number=SERIAL_NUMBER,
enrolled=enrolled,
device_model='HP Chromebook 13 G1',
current_ou='/',
chrome_device_id=UNIQUE_ID)
self.device.put()
self.mock_loan_resumes_if_late = self.device.loan_resumes_if_late
if assigned_user:
self.device.loan_assign(assigned_user)
def test_enroll_move_ou_error(self, mock_directoryclass):
device_model.Device(
enrolled=False,
serial_number='5467FD',
chrome_device_id='unique_id_09',
current_ou='not_default').put()
err_message = 'Failed to move device'
mock_directoryclient = mock_directoryclass.return_value
mock_directoryclient.move_chrome_device_org_unit.side_effect = (
directory.DirectoryRPCError(err_message))
ou = constants.ORG_UNIT_DICT['DEFAULT']
with self.assertRaisesRegexp(
device_model.DeviceCreationError,
device_model._FAILED_TO_MOVE_DEVICE_MSG % (
'5467FD', ou, err_message)):
device_model.Device.enroll(
user_email=loanertest.USER_EMAIL, serial_number='5467FD')
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)
def test_enroll_unenrolled_device(self, mock_directoryclass, mock_logging):
mock_directoryclient = mock_directoryclass.return_value
mock_directoryclient.move_chrome_device_org_unit.return_value = (
loanertest.TEST_DIR_DEVICE_DEFAULT)
device = device_model.Device()
device.enrolled = False
device.model = 'HP Chromebook 13 G1'
device.serial_number = '123ABC'
device.chrome_device_id = 'unique_id'
device.put()
device = device_model.Device.enroll('123ABC', loanertest.USER_EMAIL)
self.assertEqual(2, mock_logging.call_count)
retrieved_device = device_model.Device.get(serial_number='123ABC')
self.assertTrue(retrieved_device.enrolled)
self.testbed.mock_raiseevent.assert_any_call('device_enroll', device=device)
def test_run_success(self, config_return, send_email_call_count):
device = device_model.Device(
serial_number='123456',
chrome_device_id='123',
next_reminder=device_model.Reminder(level=0))
with mock.patch.object(config_model.Config,
'get',
return_value=config_return):
with mock.patch.object(send_email,
'send_user_email') as mock_sendemail:
event_models.ReminderEvent.create(0)
self.assertFalse(device.last_reminder)
self.action.run(device=device)
device = device.key.get()
self.assertTrue(device.last_reminder)
self.assertEqual(mock_sendemail.call_count,
send_email_call_count)
def test_enroll_unenrolled_device_changed_asset_tag(
self, mock_directoryclass, mock_logging, mock_to_document):
"""Tests enrolling by asset tag when Device was previously serial-only."""
def special_side_effect(event_name, device=None, shelf=None):
"""Side effect for raise_event that returns the model with a serial."""
del event_name, shelf # Unused.
device.serial_number = '123456'
return device
config_model.Config.set(
'device_identifier_mode',
config_model.DeviceIdentifierMode.ASSET_TAG)
self.testbed.raise_event_patcher.stop()
special_mock_raiseevent = mock.Mock(side_effect=special_side_effect)
special_raise_event_patcher = mock.patch.object(
events, 'raise_event', special_mock_raiseevent)
special_raise_event_patcher.start()
mock_directoryclient = mock_directoryclass.return_value
mock_directoryclient.move_chrome_device_org_unit.return_value = (
loanertest.TEST_DIR_DEVICE_DEFAULT)
mock_directoryclient.get_chrome_device_by_serial.return_value = (
loanertest.TEST_DIR_DEVICE_DEFAULT)
device = device_model.Device()
device.enrolled = False
device.model = 'HP Chromebook 13 G1'
device.asset_tag = 'OLD_TAG'
device.serial_number = '123456'
device.chrome_device_id = 'unique_id'
device.put()
self.assertEqual(mock_to_document.call_count, 1)
device = device_model.Device.enroll(
user_email=loanertest.USER_EMAIL, asset_tag='123ABC')
self.assertEqual(mock_logging.info.call_count, 2)
retrieved_device = device_model.Device.get(serial_number='123456')
self.assertEqual(retrieved_device.asset_tag, '123ABC')
self.assertTrue(retrieved_device.enrolled)
self.assertEqual(special_mock_raiseevent.call_count, 1)
special_raise_event_patcher.stop()
self.testbed.raise_event_patcher.start()
