Пример #1
0
 def test_list_devices_with_search_constraints(self):
     expressions = shared_messages.SearchExpression(
         expression='serial_number')
     expected_response = device_messages.ListDevicesResponse(
         devices=[device_messages.Device(serial_number='6789')],
         has_additional_results=False)
     request = device_messages.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.has_additional_results)
Пример #2
0
  def testListDevicesResponse(self):
    device1 = device_messages.Device(serial_number='FAKE-DEVICE-SERIAL-1')
    device2 = device_messages.Device(serial_number='FAKE-DEVICE-SERIAL-2')
    list_device_resp = device_messages.ListDevicesResponse(
        devices=[device1, device2],
        has_additional_results=True,
        page_token='FAKE-PAGE-TOKEN')

    self.assertTrue(list_device_resp.has_additional_results)
    self.assertEqual(list_device_resp.devices[0].serial_number,
                     'FAKE-DEVICE-SERIAL-1')
    self.assertEqual(list_device_resp.devices[1].serial_number,
                     'FAKE-DEVICE-SERIAL-2')
    self.assertEqual(list_device_resp.page_token, 'FAKE-PAGE-TOKEN')
Пример #3
0
 def test_list_devices_with_search_constraints(self):
     expressions = shared_messages.SearchExpression(
         expression='serial_number')
     expected_response = device_messages.ListDevicesResponse(
         devices=[
             device_messages.Device(serial_number='6789',
                                    guest_permitted=True)
         ],
         total_results=1,
         total_pages=1)
     request = device_messages.Device(query=shared_messages.SearchRequest(
         query_string='sn:6789',
         expressions=[expressions],
         returned_fields=['serial_number']))
     response = self.service.list_devices(request)
     self.assertEqual(response, expected_response)
Пример #4
0
    def list_devices(self, request):
        """Lists all devices based on any device attribute."""
        self.check_xsrf_token(self.request_state)
        if request.page_size <= 0:
            raise endpoints.BadRequestException(
                'The value for page_size must be greater than 0.')
        query, sort_options, returned_fields = (
            search_utils.set_search_query_options(request.query))
        if not query:
            shelf_query = ''
            if request.shelf:
                shelf_urlsafe_key = request.shelf.shelf_request.urlsafe_key
                if not shelf_urlsafe_key:
                    shelf_urlsafe_key = shelf_api.get_shelf(
                        request.shelf.shelf_request).key.urlsafe()
                request.shelf = None
                shelf_query = ':'.join(('shelf', shelf_urlsafe_key))
            query = search_utils.to_query(request, device_model.Device)
            query = ' '.join((query, shelf_query))

        offset = search_utils.calculate_page_offset(
            page_size=request.page_size, page_number=request.page_number)

        search_results = device_model.Device.search(
            query_string=query,
            query_limit=request.page_size,
            offset=offset,
            sort_options=sort_options,
            returned_fields=returned_fields)
        total_pages = search_utils.calculate_total_pages(
            page_size=request.page_size,
            total_results=search_results.number_found)
        guest_permitted = config_model.Config.get('allow_guest_mode')
        messages = []
        for document in search_results.results:
            message = search_utils.document_to_message(
                document, device_messages.Device())
            message.guest_permitted = guest_permitted
            messages.append(message)

        return device_messages.ListDevicesResponse(
            devices=messages,
            total_results=search_results.number_found,
            total_pages=total_pages)
Пример #5
0
 def test_list_devices_inactive_no_shelf(self):
     request = device_messages.Device(enrolled=False, page_size=1)
     response = self.service.list_devices(request)
     expected_response = device_messages.ListDevicesResponse(
         devices=[
             device_messages.Device(
                 serial_number=self.unenrolled_device.serial_number,
                 identifier=self.unenrolled_device.serial_number,
                 enrolled=self.unenrolled_device.enrolled,
                 device_model=self.unenrolled_device.device_model,
                 current_ou=self.unenrolled_device.current_ou,
                 locked=self.unenrolled_device.locked,
                 lost=self.unenrolled_device.lost,
                 chrome_device_id=self.unenrolled_device.chrome_device_id,
                 damaged=self.unenrolled_device.damaged,
                 guest_permitted=True)
         ],
         has_additional_results=False)
     self.assertEqual(expected_response, response)
Пример #6
0
    def list_devices(self, request):
        """Lists all devices based on any device attribute."""
        self.check_xsrf_token(self.request_state)
        query, sort_options, returned_fields = (
            search_utils.set_search_query_options(request.query))
        if not query:
            shelf_query = ''
            if request.shelf:
                shelf_urlsafe_key = request.shelf.shelf_request.urlsafe_key
                if not shelf_urlsafe_key:
                    shelf_urlsafe_key = shelf_api.get_shelf(
                        request.shelf.shelf_request).key.urlsafe()
                request.shelf = None
                shelf_query = ':'.join(('shelf', shelf_urlsafe_key))
            query = search_utils.to_query(request, device_model.Device)
            query = ' '.join((query, shelf_query))

        cursor = search_utils.get_search_cursor(request.page_token)

        search_results = device_model.Device.search(
            query_string=query,
            query_limit=request.page_size,
            cursor=cursor,
            sort_options=sort_options,
            returned_fields=returned_fields)
        new_search_cursor = None
        if search_results.cursor:
            new_search_cursor = search_results.cursor.web_safe_string
        guest_permitted = config_model.Config.get('allow_guest_mode')
        messages = []
        for document in search_results.results:
            message = search_utils.document_to_message(
                document, device_messages.Device())
            message.guest_permitted = guest_permitted
            if message.current_ou == constants.ORG_UNIT_DICT['GUEST']:
                message.guest_enabled = True
            messages.append(message)

        return device_messages.ListDevicesResponse(
            devices=messages,
            has_additional_results=bool(new_search_cursor),
            page_token=new_search_cursor)
Пример #7
0
 def test_list_devices_with_filter_message(self):
     message = device_messages.Device(enrolled=True,
                                      device_model='HP Chromebook 13 G1',
                                      current_ou='/')
     filters = api_utils.to_dict(message, device_model.Device)
     request = device_messages.Device(**filters)
     response = self.service.list_devices(request)
     expected_response = device_messages.ListDevicesResponse(
         devices=[
             device_messages.Device(serial_number='6789',
                                    identifier='6789',
                                    enrolled=True,
                                    device_model='HP Chromebook 13 G1',
                                    current_ou='/',
                                    locked=False,
                                    lost=False,
                                    chrome_device_id='unique_id_2',
                                    damaged=False,
                                    guest_permitted=True)
         ],
         has_additional_results=False)
     self.assertEqual(response, expected_response)