closedbugs.py

# -*- coding: utf-8 -*-
#
#   closedbugs.py — closedbugs plugin
#
#   This file is part of debexpo - https://alioth.debian.org/projects/debexpo/
#
#   Copyright © 2008 Jonny Lamb <jonny@debian.org>
#               2011 Arno Töll <debian@toell.net>
#
#   Permission is hereby granted, free of charge, to any person
#   obtaining a copy of this software and associated documentation
#   files (the "Software"), to deal in the Software without
#   restriction, including without limitation the rights to use,
#   copy, modify, merge, publish, distribute, sublicense, and/or sell
#   copies of the Software, and to permit persons to whom the
#   Software is furnished to do so, subject to the following
#   conditions:
#
#   The above copyright notice and this permission notice shall be
#   included in all copies or substantial portions of the Software.
#
#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
#   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
#   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
#   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
#   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
#   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
#   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
#   OTHER DEALINGS IN THE SOFTWARE.

"""
Holds the closedbugs plugin.
"""

__author__ = 'Arno Töll'
__copyright__ = 'Copyright © 2011 Arno Töll'
__license__ = 'MIT'

from collections import defaultdict
import logging

import SOAPpy

from debexpo.lib import constants
from debexpo.plugins.api import *
from debexpo.model import meta


log = logging.getLogger(__name__)

@test_result
class ClosedbugsTest(PluginResult):
    """
    Represents the result of the 'closed bugs' test.
    """

    nb_closed = int_field('nb_closed')
    nb_errors = int_field('nb_errors')
    closes_wnpp = bool_field('wnpp')

    def get_bugs(self):
        q = meta.session.query(ClosedBug)
        q = q.filter_by(package_version_id = self.package_version.id)
        # exists = True)
        d = {}
        for bug in q.all():
            d.setdefault(bug.package, list()).append(bug)
        return d

    def __str__(self):
        if (self.closes_wnpp and self.nb_closed == 1 and
            self.nb_errors == 0):
            return 'Package closes a WNPP bug'

        strings = []
        strings.append('closes {} bug{plural}'.format(
            self.nb_closed if self.nb_closed else 'no',
            plural='s' if self.nb_closed > 1 else ''))

        if self.nb_errors:
            strings.append('wrongfully claims to be closing {} bug{plural}'.format(
                self.nb_errors,
                plural='s' if self.nb_closed > 1 else ''))
        return 'Package ' + ' and '.join(strings)

class ClosedBug(PluginResult):
    """
    Represents a bug closed by the package.
    """

    exists = bool_field('exists')
    belongs = bool_field('exists')
    number = int_field('number')
    is_error = bool_field('is_error')

    @property
    def package(self):
        return self['package']

    @property
    def is_wnpp(self):
        return self.package == 'wnpp'

    def __str__(self):
        if self.exists:
            string = '{package} ({severity}: {subject}'.format(
                package=self['package'],
                severity=self['severity'],
                subject=self['subject'])
        else:
            string = 'Bug #{} does not exist for'.format(self.number)

        return string


class ClosedBugsPlugin(QAPlugin):
    URL = "http://bugs.debian.org/cgi-bin/soap.cgi"
    NS = "Debbugs/SOAP"

    @importercmd
    def test_closed_bugs(self):
        """
        Check to make sure the bugs closed belong to the package.
        """

        if 'Closes' not in self.changes:
            log.debug('Package does not close any bugs')
            return

        log.debug('Checking whether the bugs closed in the package belongs'
                  ' to the package')

        bugs = [int(x) for x in self.changes['Closes'].split()]

        test_result = self.new_test_result(nb_closed=0,
                                           nb_errors=0,
                                           wnpp='false')

        if not bugs:
            log.debug('Package does not close any bugs')
            return

        if bugs:
            log.debug('Creating SOAP proxy to bugs.debian.org')
            try:
                server = SOAPpy.SOAPProxy(self.URL, self.NS, simplify_objects = 1)
                bugs_retrieved = server.get_status(*bugs)

            except Exception as e:
                log.critical('An error occurred when creating the SOAP proxy at "%s"'
                            ' (ns: "%s"): %s' % (self.URL, self.NS, e))
                return

            if 'item' in bugs_retrieved:
                bugs_retrieved = bugs_retrieved['item']
            else:
                bugs_retrieved = []
            # Force argument to be a list, SOAPpy returns a
            # dictionary instead of a dictionary list if only one
            # bug was found
            if not isinstance(bugs_retrieved, list):
                bugs_retrieved = [bugs_retrieved]

            raw_bugs = {}

            # Index bugs retrieved
            for bug in bugs_retrieved:
                if 'key' in bug and 'value' in bug:
                    raw_bugs[int(bug['key'])] = bug['value']
                else:
                    continue

            severity = constants.PLUGIN_SEVERITY_INFO

            for bug in bugs:
                bug_result = self.new_result(ClosedBug, number=bug)
                if not bug in raw_bugs:
                    log.debug('{} does not exist'.format(bug))
                    bug_result.exists = False
                    bug_result.belongs = False
                    bug_result.is_error = True
                    test_result.nb_errors += 1
                    test_result['severity'] = max(severity, constants.PLUGIN_SEVERITY_ERROR)
                    continue

                bug_result.exists = True
                log.debug('Found bug {}'.format(bug))

                package = raw_bugs[bug]['package']
                bug_result['package'] = package
                bug_result['subject'] = raw_bugs[bug]['subject']
                bug_result['severity'] = raw_bugs[bug]['severity']

                source = raw_bugs[bug]['source'].split(', ')


                if package == 'wnpp':
                    log.debug('Package closes a wnpp bug')
                    test_result.nb_closed += 1
                    test_result.closes_wnpp = True
                    bug_result.belongs = True

                elif self.changes['Source'] in source:
                    test_result.nb_closed += 1
                    bug_result.belongs = True

                else:
                    bug_result.belongs = False
                    test_result.nb_errors += 1
                    test_result['severity'] = max(severity,
                                                  constants.PLUGIN_SEVERITY_ERROR)


plugin = ClosedBugsPlugin
models = [
    ClosedbugsTest,
    ClosedBug,
    ]