def test_get_connection_with_sandbox(self): """ Test for DataView.get_connection() """ # Mock connections['dataview'] to return special connection mocker = Mocker() connections = mocker.replace("django.db.connections") special_connection = mocker.mock() expect(connections['dataview']).result(special_connection) with mocker: observed = DataView.get_connection() expected = special_connection self.assertIs(observed, expected)
def test_get_connection_without_sandbox(self): # Mock connections['dataview'] to raise ConnectionDoesNotExist from django.db.utils import ConnectionDoesNotExist mocker = Mocker() connections = mocker.replace("django.db.connections") expect(connections['dataview']).throw(ConnectionDoesNotExist) connection = mocker.replace("django.db.connection") logging = mocker.replace("logging") logging.warning("dataview-specific database connection not available, dataview query is NOT sandboxed") with mocker: observed = DataView.get_connection() expected = connection self.assertIs(observed, expected)
def test_get_connection_without_sandbox(self): # Mock connections['dataview'] to raise ConnectionDoesNotExist from django.db.utils import ConnectionDoesNotExist mocker = Mocker() connections = mocker.replace("django.db.connections") expect(connections['dataview']).throw(ConnectionDoesNotExist) connection = mocker.replace("django.db.connection") logging = mocker.replace("logging") logging.warning( "dataview-specific database connection not available, dataview query is NOT sandboxed" ) with mocker: observed = DataView.get_connection() expected = connection self.assertIs(observed, expected)
class DashboardAPI(ExposedAPI): """ Dashboard API object. All public methods are automatically exposed as XML-RPC methods """ data_view_connection = DataView.get_connection() @xml_rpc_signature('str') def version(self): """ Name ---- `version` () Description ----------- Return dashboard server version. The version is a string with dots separating five components. The components are: 1. major version 2. minor version 3. micro version 4. release level 5. serial See: http://docs.python.org/library/sys.html#sys.version_info Return value ------------- Server version string """ return ".".join(map(str, __version__)) def _put(self, content, content_filename, pathname): try: logging.debug("Getting bundle stream") if self.user and self.user.is_superuser: bundle_stream = BundleStream.objects.get(pathname=pathname) else: bundle_stream = BundleStream.objects.accessible_by_principal( self.user).get(pathname=pathname) except BundleStream.DoesNotExist: logging.debug("Bundle stream does not exist, aborting") raise xmlrpclib.Fault(errors.NOT_FOUND, "Bundle stream not found") if not bundle_stream.can_upload(self.user): raise xmlrpclib.Fault(errors.FORBIDDEN, "You cannot upload to this stream") try: logging.debug("Creating bundle object") bundle = Bundle.objects.create_with_content( bundle_stream, self.user, content_filename, content) except (IntegrityError, ValueError) as exc: logging.debug("Raising xmlrpclib.Fault(errors.CONFLICT)") raise xmlrpclib.Fault(errors.CONFLICT, str(exc)) except: logging.exception("big oops") raise else: logging.debug("Deserializing bundle") bundle.deserialize() return bundle @xml_rpc_signature('str', 'str', 'str', 'str') def put(self, content, content_filename, pathname): """ Name ---- `put` (`content`, `content_filename`, `pathname`) Description ----------- Upload a bundle to the server. Arguments --------- `content`: string Full text of the bundle. This *SHOULD* be a valid JSON document and it *SHOULD* match the "Dashboard Bundle Format 1.0" schema. The SHA1 of the content *MUST* be unique or a ``Fault(409, "...")`` is raised. This is used to protect from simple duplicate submissions. `content_filename`: string Name of the file that contained the text of the bundle. The `content_filename` can be an arbitrary string and will be stored along with the content for reference. `pathname`: string Pathname of the bundle stream where a new bundle should be created and stored. This argument *MUST* designate a pre-existing bundle stream or a ``Fault(404, "...")`` exception is raised. In addition the user *MUST* have access permission to upload bundles there or a ``Fault(403, "...")`` exception is raised. See below for access rules. Return value ------------ If all goes well this function returns the SHA1 of the content. Exceptions raised ----------------- 404 Either: - Bundle stream not found - Uploading to specified stream is not permitted 409 Duplicate bundle content Rules for bundle stream access ------------------------------ The following rules govern bundle stream upload access rights: - all anonymous streams are accessible - personal streams are accessible to owners - team streams are accessible to team members """ bundle = self._put(content, content_filename, pathname) logging.debug("Returning bundle SHA1") return bundle.content_sha1 @xml_rpc_signature('str', 'str', 'str', 'str') def put_ex(self, content, content_filename, pathname): """ Name ---- `put` (`content`, `content_filename`, `pathname`) Description ----------- Upload a bundle to the server. A variant on put_ex that returns the URL of the bundle instead of its SHA1. Arguments --------- `content`: string Full text of the bundle. This *SHOULD* be a valid JSON document and it *SHOULD* match the "Dashboard Bundle Format 1.0" schema. The SHA1 of the content *MUST* be unique or a ``Fault(409, "...")`` is raised. This is used to protect from simple duplicate submissions. `content_filename`: string Name of the file that contained the text of the bundle. The `content_filename` can be an arbitrary string and will be stored along with the content for reference. `pathname`: string Pathname of the bundle stream where a new bundle should be created and stored. This argument *MUST* designate a pre-existing bundle stream or a ``Fault(404, "...")`` exception is raised. In addition the user *MUST* have access permission to upload bundles there or a ``Fault(403, "...")`` exception is raised. See below for access rules. Return value ------------ If all goes well this function returns the full URL of the bundle. Exceptions raised ----------------- 404 Either: - Bundle stream not found - Uploading to specified stream is not permitted 409 Duplicate bundle content Rules for bundle stream access ------------------------------ The following rules govern bundle stream upload access rights: - all anonymous streams are accessible - personal streams are accessible to owners - team streams are accessible to team members """ bundle = self._put(content, content_filename, pathname) logging.debug("Returning permalink to bundle") return self._context.request.build_absolute_uri( reverse('dashboard_app.views.redirect_to_bundle', kwargs={'content_sha1': bundle.content_sha1})) def put_pending(self, content, pathname, group_name): """ Name ---- `put_pending` (`content`, `pathname`, `group_name`) Description ----------- MultiNode internal call. Stores the bundle until the coordinator allows the complete bundle list to be aggregated from the list and submitted by put_group Arguments --------- `content`: string Full text of the bundle. This *MUST* be a valid JSON document and it *SHOULD* match the "Dashboard Bundle Format 1.0" schema. The SHA1 of the content *MUST* be unique or a ``Fault(409, "...")`` is raised. This is used to protect from simple duplicate submissions. `pathname`: string Pathname of the bundle stream where a new bundle should be created and stored. This argument *MUST* designate a pre-existing bundle stream or a ``Fault(404, "...")`` exception is raised. In addition the user *MUST* have access permission to upload bundles there or a ``Fault(403, "...")`` exception is raised. See below for access rules. `group_name`: string Unique ID of the MultiNode group. Other pending bundles will be aggregated into a single result bundle for this group. Return value ------------ If all goes well this function returns the SHA1 of the content. Exceptions raised ----------------- 404 Either: - Bundle stream not found - Uploading to specified stream is not permitted 409 Duplicate bundle content Rules for bundle stream access ------------------------------ The following rules govern bundle stream upload access rights: - all anonymous streams are accessible - personal streams are accessible to owners - team streams are accessible to team members """ try: logging.debug("Getting bundle stream") if self.user.is_superuser: bundle_stream = BundleStream.objects.get(pathname=pathname) else: bundle_stream = BundleStream.objects.accessible_by_principal( self.user).get(pathname=pathname) except BundleStream.DoesNotExist: logging.debug("Bundle stream does not exist, aborting") raise xmlrpclib.Fault(errors.NOT_FOUND, "Bundle stream not found") if not bundle_stream.can_upload(self.user): raise xmlrpclib.Fault(errors.FORBIDDEN, "You cannot upload to this stream") try: # add this to a list which put_group can use. sha1 = hashlib.sha1() sha1.update(content) hexdigest = sha1.hexdigest() groupfile = "/tmp/%s" % group_name with open(groupfile, "a+") as grp_file: grp_file.write("%s\n" % content) return hexdigest except Exception as e: logging.debug( "Dashboard pending submission caused an exception: %s" % e) def put_group(self, content, content_filename, pathname, group_name): """ Name ---- `put_group` (`content`, `content_filename`, `pathname`, `group_name`) Description ----------- MultiNode internal call. Adds the final bundle to the list, aggregates the list into a single group bundle and submits the group bundle. Arguments --------- `content`: string Full text of the bundle. This *MUST* be a valid JSON document and it *SHOULD* match the "Dashboard Bundle Format 1.0" schema. The SHA1 of the content *MUST* be unique or a ``Fault(409, "...")`` is raised. This is used to protect from simple duplicate submissions. `content_filename`: string Name of the file that contained the text of the bundle. The `content_filename` can be an arbitrary string and will be stored along with the content for reference. `pathname`: string Pathname of the bundle stream where a new bundle should be created and stored. This argument *MUST* designate a pre-existing bundle stream or a ``Fault(404, "...")`` exception is raised. In addition the user *MUST* have access permission to upload bundles there or a ``Fault(403, "...")`` exception is raised. See below for access rules. `group_name`: string Unique ID of the MultiNode group. Other pending bundles will be aggregated into a single result bundle for this group. At least one other bundle must have already been submitted as pending for the specified MultiNode group. LAVA Coordinator causes the parent job to wait until all nodes have been marked as having pending bundles, even if some bundles are empty. Return value ------------ If all goes well this function returns the full URL of the bundle. Exceptions raised ----------------- ValueError: One or more bundles could not be converted to JSON prior to aggregation. 404 Either: - Bundle stream not found - Uploading to specified stream is not permitted 409 Duplicate bundle content Rules for bundle stream access ------------------------------ The following rules govern bundle stream upload access rights: - all anonymous streams are accessible - personal streams are accessible to owners - team streams are accessible to team members """ grp_file = "/tmp/%s" % group_name bundle_set = {} bundle_set[group_name] = [] if os.path.isfile(grp_file): with open(grp_file, "r") as grp_data: grp_list = grp_data.readlines() for testrun in grp_list: bundle_set[group_name].append(json.loads(testrun)) # Note: now that we have the data from the group, the group data file could be re-used # as an error log which is simpler than debugging through XMLRPC. else: raise ValueError( "Aggregation failure for %s - check coordinator rpc_delay?" % group_name) group_tests = [] try: json_data = json.loads(content) except ValueError: logging.debug("Invalid JSON content within the sub_id zero bundle") json_data = None try: bundle_set[group_name].append(json_data) except Exception as e: logging.debug("appending JSON caused exception %s" % e) try: for bundle_list in bundle_set[group_name]: for test_run in bundle_list['test_runs']: group_tests.append(test_run) except Exception as e: logging.debug("aggregating bundles caused exception %s" % e) group_content = json.dumps({ "test_runs": group_tests, "format": json_data['format'] }) bundle = self._put(group_content, content_filename, pathname) logging.debug("Returning permalink to aggregated bundle for %s" % group_name) permalink = self._context.request.build_absolute_uri( reverse('dashboard_app.views.redirect_to_bundle', kwargs={'content_sha1': bundle.content_sha1})) # only delete the group file when things go well. if os.path.isfile(grp_file): os.remove(grp_file) return permalink def get(self, content_sha1): """ Name ---- `get` (`content_sha1`) Description ----------- Download a bundle from the server. Arguments --------- `content_sha1`: string SHA1 hash of the content of the bundle to download. This *MUST* designate an bundle or ``Fault(404, "...")`` is raised. Return value ------------ This function returns an XML-RPC struct with the following fields: `content_filename`: string The value that was stored on a previous call to put() `content`: string The full text of the bundle Exceptions raised ----------------- - 404 Bundle not found - 403 Permission denied Rules for bundle stream access ------------------------------ The following rules govern bundle stream download access rights: - all anonymous streams are accessible - personal streams are accessible to owners - team streams are accessible to team members """ try: bundle = Bundle.objects.get(content_sha1=content_sha1) if not bundle.bundle_stream.is_accessible_by(self.user): raise xmlrpclib.Fault( 403, "Permission denied. User does not have permissions " "to access this bundle.") except Bundle.DoesNotExist: raise xmlrpclib.Fault(errors.NOT_FOUND, "Bundle not found") else: return { "content": bundle.content.read(), "content_filename": bundle.content_filename } @xml_rpc_signature('struct') def streams(self): """ Name ---- `streams` () Description ----------- List all bundle streams that the user has access to Arguments --------- None Return value ------------ This function returns an XML-RPC array of XML-RPC structs with the following fields: `pathname`: string The pathname of the bundle stream `name`: string The user-configurable name of the bundle stream `user`: string The username of the owner of the bundle stream for personal streams or an empty string for public and team streams. `group`: string The name of the team that owsn the bundle stream for team streams or an empty string for public and personal streams. `bundle_count`: int Number of bundles that are in this stream Exceptions raised ----------------- None Rules for bundle stream access ------------------------------ The following rules govern bundle stream download access rights: - all anonymous streams are accessible - personal streams are accessible to owners - team streams are accessible to team members """ if self.user and self.user.is_superuser: bundle_streams = BundleStream.objects.all() else: bundle_streams = BundleStream.objects.accessible_by_principal( self.user) return [{ 'pathname': bundle_stream.pathname, 'name': bundle_stream.name, 'user': bundle_stream.user.username if bundle_stream.user else "", 'group': bundle_stream.group.name if bundle_stream.group else "", 'bundle_count': bundle_stream.bundles.count(), } for bundle_stream in bundle_streams] def bundles(self, pathname): """ Name ---- `bundles` (`pathname`) Description ----------- List all bundles in a specified bundle stream Arguments --------- `pathname`: string The pathname of the bundle stream to query. This argument *MUST* designate an existing stream or Fault(404, "...") is raised. The user *MUST* have access to this stream or Fault(403, "...") is raised. Return value ------------ This function returns an XML-RPC array of XML-RPC structs with the following fields: `uploaded_by`: string The username of the user that uploaded this bundle or empty string if this bundle was uploaded anonymously. `uploaded_on`: datetime The timestamp when the bundle was uploaded `content_filename`: string The filename of the original bundle file `content_sha1`: string The SHA1 hash if the content of the bundle `content_size`: int This element was added in server version 0.4 The size of the content `is_deserialized`: bool True if the bundle was de-serialized successfully, false otherwise Exceptions raised ----------------- 404 Either: - Bundle stream not found - Listing bundles in this bundle stream is not permitted Rules for bundle stream access ------------------------------ The following rules govern bundle stream download access rights: - all anonymous streams are accessible - personal streams are accessible to owners - team streams are accessible to team members """ try: if self.user and self.user.is_superuser: bundle_stream = BundleStream.objects.get(pathname=pathname) else: bundle_stream = BundleStream.objects.accessible_by_principal( self.user).get(pathname=pathname) except BundleStream.DoesNotExist: raise xmlrpclib.Fault(errors.NOT_FOUND, "Bundle stream not found") return [{ 'uploaded_by': bundle.uploaded_by.username if bundle.uploaded_by else "", 'uploaded_on': bundle.uploaded_on, 'content_filename': bundle.content_filename, 'content_sha1': bundle.content_sha1, 'content_size': bundle.content.size, 'is_deserialized': bundle.is_deserialized } for bundle in bundle_stream.bundles.all().order_by("uploaded_on")] @xml_rpc_signature('str') def get_test_names(self, device_type=None): """ Name ---- `get_test_names` ([`device_type`]]) Description ----------- Get the name of all the tests that have run on a particular device type. Arguments --------- `device_type`: string The type of device the retrieved test names should apply to. Return value ------------ This function returns an XML-RPC array of test names. """ test_names = [] if device_type: for test in Test.objects.filter( test_runs__attributes__name='target.device_type', test_runs__attributes__value=device_type).distinct(): test_names.append(test.test_id) else: for test in Test.objects.all(): test_names.append(test.test_id) return test_names def deserialize(self, content_sha1): """ Name ---- `deserialize` (`content_sha1`) Description ----------- Deserialize bundle on the server Arguments --------- `content_sha1`: string SHA1 hash of the content of the bundle to download. This *MUST* designate an bundle or ``Fault(404, "...")`` is raised. Return value ------------ True - deserialization okay False - deserialization not needed Exceptions raised ----------------- 404 Bundle not found 409 Bundle import failed """ try: bundle = Bundle.objects.get(content_sha1=content_sha1) except Bundle.DoesNotExist: raise xmlrpclib.Fault(errors.NOT_FOUND, "Bundle not found") if bundle.is_deserialized: return False bundle.deserialize() if bundle.is_deserialized is False: raise xmlrpclib.Fault(errors.CONFLICT, bundle.deserialization_error.error_message) return True def make_stream(self, pathname, name): """ Name ---- `make_stream` (`pathname`, `name`) Description ----------- Create a bundle stream with the specified pathname Arguments --------- `pathname`: string The pathname must refer to an anonymous stream `name`: string The name of the stream (free form description text) Return value ------------ pathname is returned Exceptions raised ----------------- 403 Pathname does not designate an anonymous stream 409 Bundle stream with the specified pathname already exists Available Since --------------- 0.3 """ # Work around bug https://bugs.launchpad.net/lava-dashboard/+bug/771182 # Older clients would send None as the name and this would trigger an # IntegrityError to be raised by BundleStream.objects.create() below # which in turn would be captured by the fault handler and reported as # an unrelated issue to the user. Let's work around that by using an # empty string instead. if name is None: name = "" try: user_name, group_name, slug, is_public, is_anonymous = BundleStream.parse_pathname( pathname) except ValueError as ex: raise xmlrpclib.Fault(errors.FORBIDDEN, str(ex)) # Start with those to simplify the logic below user = None group = None if is_anonymous is False: if self.user is not None: assert is_anonymous is False assert self.user is not None if user_name is not None: if not self.user.is_superuser: if user_name != self.user.username: raise xmlrpclib.Fault( errors.FORBIDDEN, "Only user {user!r} could create this stream". format(user=user_name)) user = self.user # map to real user object elif group_name is not None: try: if self.user.is_superuser: group = Group.objects.get(name=group_name) else: group = self.user.groups.get(name=group_name) except Group.DoesNotExist: raise xmlrpclib.Fault( errors.FORBIDDEN, "Only a member of group {group!r} could create this stream" .format(group=group_name)) else: assert is_anonymous is False assert self.user is None raise xmlrpclib.Fault( errors.FORBIDDEN, "Only anonymous streams can be constructed (you are not signed in)" ) else: assert is_anonymous is True assert user_name is None assert group_name is None if self.user is not None: user = self.user else: # Hacky but will suffice for now user = User.objects.get_or_create( username="******")[0] try: bundle_stream = BundleStream.objects.create( user=user, group=group, slug=slug, is_public=is_public, is_anonymous=is_anonymous, name=name) except IntegrityError: raise xmlrpclib.Fault( errors.CONFLICT, "Stream with the specified pathname already exists") else: return bundle_stream.pathname def data_views(self): """ Name ---- `data_views` () Description ----------- List all data views Arguments --------- None Return value ------------ This function returns an XML-RPC array of XML-RPC structs with the following fields: `name`: string Data view name declared in the definition file `summary`: string One-line description string suitable for developers Exceptions raised ----------------- None """ return [{ 'name': data_view.name, 'summary': data_view.summary, "documentation": data_view.documentation, "arguments": [{ "name": arg.name, "type": arg.type, "help": arg.help, "default": arg.default } for arg in data_view.arguments] } for data_view in DataView.repository.all()] def data_view_info(self, name): """ Name ---- `data_view_info` (`name`) Description ----------- Describe a specific data view. This function looks up data view by name and returns rich information. See below for details Arguments --------- `name`: string Name of the data view to lookup Return value ------------ This function returns an XML-RPC struct with the following fields: `name`: string Data view name declared in the definition file `summary`: string One-line description string suitable for developers `documentation`: string Longer documentation that described the purpose and indented usage of this data view `sql`: string or null The SQL of query specific to the currently running database (the actual query that is executed by query-data-view. Since some data views use database specific SQL the query may not be available. `argments` an XML-RPC array of XML-RPC structs with the following fields: `name`: Argument name `type`: Argument type, one of "number", "string" or "boolean" `help`: Help string for this argument `default`: Default value of an argument (or null if not available) Exceptions raised ----------------- 404 Name does not designate a data view """ try: data_view = DataView.repository.get(name=name) except DataView.DoesNotExist: raise xmlrpclib.Fault(errors.NOT_FOUND, "Data view not found") else: query = data_view.get_backend_specific_query( self.data_view_connection) return { "name": data_view.name, "summary": data_view.summary, "documentation": data_view.documentation, "sql": query.sql_template if query is not None else None, "arguments": [{ "name": arg.name, "type": arg.type, "help": arg.help, "default": arg.default } for arg in data_view.arguments] } def query_data_view(self, name, arguments): """ Name ---- `query_data_view` (name, arguments) Description ----------- List all data views Arguments --------- None Return value ------------ This function returns an XML-RPC struct with the following fields: `rows`: XML-RPC array of XML-RPC arrays Each item corresponds to cell in a row `columns`: XML-RPC array of XML-RPC structs with the following fields: `name`: XML-RPC string - name of the column `type`: XML-RPC string - column type (future extension, currently unused) Exceptions raised ----------------- TBD """ try: data_view = DataView.repository.get(name=name) except DataView.DoesNotExist: raise xmlrpclib.Fault(errors.NOT_FOUND, "Data view not found") try: rows, columns = data_view(self.data_view_connection, **arguments) except (LookupError, TypeError, ValueError, DatabaseError) as exc: raise xmlrpclib.Fault(errors.INTERNAL_SERVER_ERROR, str(exc)) else: rows = [[ float(cell) if isinstance(cell, decimal.Decimal) else cell for cell in row ] for row in rows] return { "rows": rows, "columns": [{ "name": item[0], "type": item[1] } for item in columns] } def _get_filter_data(self, filter_name): match = re.match("~([-_A-Za-z0-9]+)/([-_A-Za-z0-9]+)", filter_name) if not match: raise xmlrpclib.Fault( errors.BAD_REQUEST, "filter_name must be of form ~owner/filter-name") owner_name, filter_name = match.groups() try: owner = User.objects.get(username=owner_name) except User.NotFound: raise xmlrpclib.Fault(errors.NOT_FOUND, "user %s not found" % owner_name) try: filter = TestRunFilter.objects.get(owner=owner, name=filter_name) except TestRunFilter.NotFound: raise xmlrpclib.Fault(errors.NOT_FOUND, "filter %s not found" % filter_name) if not filter.public and self.user != owner: if self.user: raise xmlrpclib.Fault(errors.FORBIDDEN, "forbidden") else: raise xmlrpclib.Fault(errors.AUTH_REQUIRED, "authentication required") return filter.as_data() def get_filter_results(self, filter_name, count=10, offset=0): """ Name ---- :: get_filter_results(filter_name, count=10, offset=0) Description ----------- Return information about the test runs and results that a given filter matches. Arguments --------- ``filter_name``: The name of a filter in the format ~owner/name. ``count``: The maximum number of matches to return. ``offset``: Skip over this many results. Return value ------------ A list of "filter matches". A filter match describes the results of matching a filter against one or more test runs:: { 'tag': either a stringified date (bundle__uploaded_on) or a build number 'test_runs': [{ 'test_id': test_id 'link': link-to-test-run, 'passes': int, 'fails': int, 'skips': int, 'total': int, # only present if filter specifies cases for this test: 'specific_results': [{ 'test_case_id': test_case_id, 'link': link-to-test-result, 'result': pass/fail/skip/unknown, 'measurement': string-containing-decimal-or-None, 'units': units, }], }] # Only present if filter does not specify tests: 'pass_count': int, 'fail_count': int, } """ filter_data = self._get_filter_data(filter_name) matches = evaluate_filter(self.user, filter_data, descending=False) matches = matches[offset:offset + count] return [match.serializable() for match in matches] def get_filter_results_since(self, filter_name, since=None): """ Name ---- :: get_filter_results_since(filter_name, since=None) Description ----------- Return information about the test runs and results that a given filter matches that are more recent than a previous match -- in more detail, results where the ``tag`` is greater than the value passed in ``since``. The idea of this method is that it will be called from a cron job to update previously accessed results. Something like this:: previous_results = json.load(open('results.json')) results = previous_results + server.dashboard.get_filter_results_since( filter_name, previous_results[-1]['tag']) ... do things with results ... json.save(results, open('results.json', 'w')) If called without passing ``since`` (or with ``since`` set to ``None``), this method returns up to 100 matches from the filter. In fact, the matches are always capped at 100 -- so set your cronjob to execute frequently enough that there are less than 100 matches generated between calls! Arguments --------- ``filter_name``: The name of a filter in the format ~owner/name. ``since``: The 'tag' of the most recent result that was retrieved from this filter. Return value ------------ A list of "filter matches". A filter match describes the results of matching a filter against one or more test runs:: { 'tag': either a stringified date (bundle__uploaded_on) or a build number 'test_runs': [{ 'test_id': test_id 'link': link-to-test-run, 'passes': int, 'fails': int, 'skips': int, 'total': int, # only present if filter specifies cases for this test: 'specific_results': [{ 'test_case_id': test_case_id, 'link': link-to-test-result, 'result': pass/fail/skip/unknown, 'measurement': string-containing-decimal-or-None, 'units': units, }], }] # Only present if filter does not specify tests: 'pass_count': int, 'fail_count': int, } """ filter_data = self._get_filter_data(filter_name) matches = evaluate_filter(self.user, filter_data, descending=False) if since is not None: if filter_data.get('build_number_attribute') is not None: try: since = datetime.datetime.strptime(since, "%Y-%m-%d %H:%M:%S.%f") except ValueError: raise xmlrpclib.Fault( errors.BAD_REQUEST, "cannot parse since argument as datetime") matches = matches.since(since) matches = matches[:100] return [match.serializable() for match in matches] @xml_rpc_signature('str') def get_test_definitions(self, os=None, device=None, environment=None): """ Name ---- `get_test_definitions` ([`os`[, `device`[, `environment`]]]) Description ----------- Get the name and url of all the test definitions. Arguments --------- `os`: string The type of operating system the retrieved test definitions should apply to. `device`: string The type of device the retrieved test definitions should apply to. `environment`: string The type of test environment the retrieved test definitions should apply to. Return value ------------ This function returns an XML-RPC structure of test definition name and URL where the test definition exists. """ testdefs = {} tds = TestDefinition.objects.all() if os: tds = tds.filter(target_os__contains=os) if device: tds = tds.filter(target_dev_types__contains=device) if environment: tds = tds.filter(environment__contains=environment) for testdef in tds: testdefs[testdef.name] = testdef.url return testdefs