~launchpad-pqm/launchpad/devel

ExternalBugTracker: Bugzilla

============================

An ExternalBugtracker is used to talk to remote bug trackers and update bug

watches. This document describes how the Bugzilla implementation of

ExternalBugTracker works.

Basics

------

The class that implements ExternalBugTracker is called Bugzilla.

    >>> from lp.bugs.externalbugtracker import Bugzilla

    >>> from lp.bugs.interfaces.externalbugtracker import (

    ...     IExternalBugTracker)

    >>> from lp.services.webapp.testing import verifyObject

    >>> external_bugzilla = Bugzilla('http://example.com')

    >>> verifyObject(IExternalBugTracker, external_bugzilla)

    True

The Bugzilla ExternalBugTracker works differently depending on which

version of Bugzilla it is talking to. If it's a version we can't parse,

UnparsableBugTrackerVersion is raised:

    >>> from lp.testing.layers import LaunchpadZopelessLayer

    >>> txn = LaunchpadZopelessLayer.txn

    >>> external_bugzilla = Bugzilla('http://example.com/', version='A.B')

    Traceback (most recent call last):

      ...

    UnparsableBugTrackerVersion:

    Failed to parse version 'A.B' for http://...

The version parsing is carried out by the Bugzilla._parseVersion()

method, which takes a version string and returns a tuple of

(major_version, minor_version).

    >>> external_bugzilla = Bugzilla('http://example.com')

    >>> print external_bugzilla._parseVersion('3.2')

    (3, 2)

It can handle version strings with an -$foo suffix.

    >>> print external_bugzilla._parseVersion('3.2-foobar')

    (3, 2)

And will also handle versions which contain the string 'rc'.

    >>> print external_bugzilla._parseVersion('3.2rc')

    (3, 2)

+ characters in the version string will be removed.

    >>> print external_bugzilla._parseVersion('3.2+1')

    (3, 2, 1)

Since we don't want to depend on a working network connection, we use a

slightly modified implementation.

    >>> from lp.bugs.interfaces.bugtracker import IBugTrackerSet

    >>> from lp.bugs.tests.externalbugtracker import TestBugzilla

    >>> gnome_bugzilla = (

    ...     getUtility(IBugTrackerSet).getByName('gnome-bugzilla'))

    >>> external_bugzilla = TestBugzilla(gnome_bugzilla.baseurl)

    >>> version = external_bugzilla._probe_version()

    >>> version

    (2, 20)

Launchpad plugin

----------------

Some Bugzillas offer the Bugzilla 3.4 XML-RPC API or have a Launchpad

plugin installed. For these bugtrackers, we use the BugzillaAPI

ExternalBugTracker or its subclass, BugzillaLPPlugin, depending upon

which type of Bugzilla we're dealing with. The Bugzilla

ExternalBugTracker class has a getExternalBugTrackerToUse() method which

will return a BugzillaAPI instance if the remote Bugzilla offers the 3.4

API or a  BugzillaLPPlugin instance if the remote Bugzilla has the

plugin installed. If neither of these is offered, a standard Bugzilla

ExternalBugTracker will be returned.

The Bugzilla ExternalBugTracker has a _test_xmlrpc_proxy property which

we override for the purpose of this test.

    >>> import xmlrpclib

    >>> class FailingXMLRPCTransport(xmlrpclib.Transport):

    ...

    ...     error = xmlrpclib.Fault(

    ...         xmlrpclib.METHOD_NOT_FOUND, "Method doesn't exist")

    ...

    ...     def request(self, host, handler, request, verbose=None):

    ...         if self.error is not None:

    ...             raise self.error

    ...         else:

    ...             # We need to return something here, otherwise

    ...             # xmlrpclib will explode.

    ...             return '0.42-test'

    ...

    >>> test_transport = FailingXMLRPCTransport()

    >>> class BugzillaWithFakeProxy(Bugzilla):

    ...

    ...     _test_xmlrpc_proxy = xmlrpclib.ServerProxy(

    ...         'http://example.com/xmlrpc.cgi', transport=test_transport)

    >>> bugzilla = BugzillaWithFakeProxy('http://example.com')

When getExternalBugTrackerToUse() receives a Fault of type

METHOD_NOT_FOUND from the remote server in response to its check, it

will return a standard Bugzilla instance.

    >>> transaction.commit()

    >>> from lp.bugs.externalbugtracker import (

    ...     BugzillaAPI, BugzillaLPPlugin)

    >>> bugzilla_to_use = bugzilla.getExternalBugTrackerToUse()

The returned bugtracker will be a Bugzilla instance bug not a

BugzillaAPI instance.

    >>> (isinstance(bugzilla_to_use, Bugzilla) and

    ...  not isinstance(bugzilla_to_use, BugzillaAPI))

    True

The same is true if getExternalBugTrackerToUse() receives a 404 error

from the remote server.

    >>> test_transport.error = xmlrpclib.ProtocolError(

    ...     'http://example.com/xmlrpc.cgi', 404, 'Not Found', None)

    >>> bugzilla_to_use = bugzilla.getExternalBugTrackerToUse()

    >>> (isinstance(bugzilla_to_use, Bugzilla) and

    ...  not isinstance(bugzilla_to_use, BugzillaAPI))

    True

Some Bugzillas respond to an invalid XML-RPC method call by returning a

500 error. getExternalBugTrackerToUse() handles those, too.

    >>> test_transport.error = xmlrpclib.ProtocolError(

    ...     'http://example.com/xmlrpc.cgi', 500, 'Server Error', None)

    >>> bugzilla_to_use = bugzilla.getExternalBugTrackerToUse()

    >>> (isinstance(bugzilla_to_use, Bugzilla) and

    ...  not isinstance(bugzilla_to_use, BugzillaAPI))

    True

Some other Bugzillas generate an unparsable response, causing

ResponseError to be raised.

    >>> test_transport.error = xmlrpclib.ResponseError()

    >>> bugzilla_to_use = bugzilla.getExternalBugTrackerToUse()

    >>> (isinstance(bugzilla_to_use, Bugzilla) and

    ...  not isinstance(bugzilla_to_use, BugzillaAPI))

    True

If the remote Bugzilla offers the Bugzilla 3.4 API, an instance of

BuzillaAPI will be returned. To test this, we use a specially-crafted

XML-RPC proxy that behaves like a Bugzilla 3.4 instance.

    >>> class APIXMLRPCTransport(xmlrpclib.Transport):

    ...

    ...     version = '3.4.2'

    ...

    ...     def request(self, host, handler, request, verbose=None):

    ...         args, method_name = xmlrpclib.loads(request)

    ...

    ...         if method_name == 'Bugzilla.version':

    ...             return [{'version': self.version}]

    ...         else:

    ...             raise xmlrpclib.Fault(

    ...                 xmlrpclib.METHOD_NOT_FOUND, 'No such method')

    ...

    >>> test_transport = APIXMLRPCTransport()

    >>> bugzilla._test_xmlrpc_proxy = xmlrpclib.ServerProxy(

    ...     'http://example.com/xmlrpc.cgi',

    ...     transport=test_transport)

    >>> bugzilla_to_use = bugzilla.getExternalBugTrackerToUse()

    >>> (isinstance(bugzilla_to_use, BugzillaAPI) and

    ...  not isinstance(bugzilla_to_use, BugzillaLPPlugin))

    True

If the remote system has the Launchpad plugin installed, an

getExternalBugTrackerToUse() will return a BugzillaLPPlugin instance.

    >>> class PluginXMLRPCTransport(xmlrpclib.Transport):

    ...

    ...     def request(self, host, handler, request, verbose=None):

    ...         args, method_name = xmlrpclib.loads(request)

    ...

    ...         if method_name == 'Launchpad.plugin_version':

    ...             return [{'version': '0.2'}]

    ...         else:

    ...             raise xmlrpclib.Fault(

    ...                 xmlrpclib.METHOD_NOT_FOUND, 'No such method')

    ...

    >>> test_transport = PluginXMLRPCTransport()

    >>> bugzilla._test_xmlrpc_proxy = xmlrpclib.ServerProxy(

    ...     'http://example.com/xmlrpc.cgi',

    ...     transport=test_transport)

    >>> bugzilla_to_use = bugzilla.getExternalBugTrackerToUse()

    >>> isinstance(bugzilla_to_use, BugzillaLPPlugin)

    True

Older versions of the Bugzilla API return tuples rather than mappings

in response to XML-RPC calls. When something other than a mapping is

returned, the standard non-API non-plugin external bug tracker is

selected.

    >>> class OldXMLRPCTransport(xmlrpclib.Transport):

    ...     def request(self, host, handler, request, verbose=None):

    ...         args, method_name = xmlrpclib.loads(request)

    ...

    ...         if method_name == 'Bugzilla.version':

    ...             return ('versionResponse', {'version': '3.2.5+'})

    ...         else:

    ...             raise xmlrpclib.Fault(

    ...                 xmlrpclib.METHOD_NOT_FOUND, 'No such method')

    ...

    >>> test_transport = OldXMLRPCTransport()

    >>> bugzilla._test_xmlrpc_proxy = xmlrpclib.ServerProxy(

    ...     'http://example.com/xmlrpc.cgi',

    ...     transport=test_transport)

    >>> bugzilla_to_use = bugzilla.getExternalBugTrackerToUse()

    >>> (isinstance(bugzilla_to_use, BugzillaAPI) or

    ...  isinstance(bugzilla_to_use, BugzillaLPPlugin))

    False

Some Bugzillas return 'Client' instead of METHOD_NOT_FOUND when a method

is not discovered over XML-RPC. It's not clear if this is an error in

Bugzilla or in and XML-RPC library used by Bugzilla. In any case, we

recognize and treat it the same as METHOD_NOT_FOUND.

    >>> class OldBrokenXMLRPCTransport(xmlrpclib.Transport):

    ...     def request(self, host, handler, request, verbose=None):

    ...         args, method_name = xmlrpclib.loads(request)

    ...

    ...         if method_name == 'Bugzilla.version':

    ...             return ('versionResponse', {'version': '3.2.5+'})

    ...         else:

    ...             raise xmlrpclib.Fault('Client', 'No such method')

    ...

    >>> test_transport = OldBrokenXMLRPCTransport()

    >>> bugzilla._test_xmlrpc_proxy = xmlrpclib.ServerProxy(

    ...     'http://example.com/xmlrpc.cgi',

    ...     transport=test_transport)

    >>> bugzilla_to_use = bugzilla.getExternalBugTrackerToUse()

    >>> (isinstance(bugzilla_to_use, BugzillaAPI) or

    ...  isinstance(bugzilla_to_use, BugzillaLPPlugin))

    False

Status Conversion

-----------------

It contains a function for converting one of its own status to a Malone

status. Bugzilla statuses consist of two parts, the status, and the

resolution, separated by a space character. The resolution only exists

if the bug is closed:

    >>> external_bugzilla.convertRemoteStatus('UNCONFIRMED').title

    'New'

    >>> external_bugzilla.convertRemoteStatus('NEW').title

    'Confirmed'

    >>> external_bugzilla.convertRemoteStatus('ASSIGNED').title

    'In Progress'

    >>> external_bugzilla.convertRemoteStatus('REOPENED').title

    'Confirmed'

    >>> external_bugzilla.convertRemoteStatus('NEEDINFO').title

    'Incomplete'

    >>> external_bugzilla.convertRemoteStatus('NEEDINFO_REPORTER').title

    'Incomplete'

    >>> external_bugzilla.convertRemoteStatus('NEEDSINFO').title

    'Incomplete'

    >>> external_bugzilla.convertRemoteStatus('MODIFIED').title

    'Fix Committed'

    >>> external_bugzilla.convertRemoteStatus('UPSTREAM').title

    'Confirmed'

    >>> external_bugzilla.convertRemoteStatus('PENDINGUPLOAD').title

    'Fix Committed'

    >>> external_bugzilla.convertRemoteStatus('RESOLVED FIXED').title

    'Fix Released'

    >>> external_bugzilla.convertRemoteStatus('RESOLVED UPSTREAM').title

    "Won't Fix"

    >>> external_bugzilla.convertRemoteStatus(

    ...     'CLOSED PATCH_ALREADY_AVAILABLE').title

    'Fix Released'

    >>> external_bugzilla.convertRemoteStatus('RESOLVED CODE_FIX').title

    'Fix Released'

    >>> external_bugzilla.convertRemoteStatus('VERIFIED WONTFIX').title

    "Won't Fix"

    >>> external_bugzilla.convertRemoteStatus('CLOSED INVALID').title

    'Invalid'

    >>> external_bugzilla.convertRemoteStatus('CLOSED DUPLICATE').title

    'Invalid'

    >>> external_bugzilla.convertRemoteStatus('CLOSED UPSTREAM').title

    "Won't Fix"

If the status can't be converted an UnknownRemoteStatusError will be

returned.

    >>> external_bugzilla.convertRemoteStatus('FOO').title

    Traceback (most recent call last):

      ...

    UnknownRemoteStatusError: FOO

    >>> external_bugzilla.convertRemoteStatus('CLOSED BAR').title

    Traceback (most recent call last):

      ...

    UnknownRemoteStatusError: CLOSED BAR

Importance Conversion

---------------------

There is also a function for conversion of bugzilla importances to

launchpad importances.  The Bugzilla importance is comprised of priority

and severity, but we only use severity in mapping the value unless it

isn't available in which case we map against priority values.

    >>> external_bugzilla.convertRemoteImportance('URGENT BLOCKER').title

    'Critical'

    >>> external_bugzilla.convertRemoteImportance('LOW BLOCKER').title

    'Critical'

    >>> external_bugzilla.convertRemoteImportance('BLOCKER').title

    'Critical'

    >>> external_bugzilla.convertRemoteImportance('URGENT CRITICAL').title

    'Critical'

    >>> external_bugzilla.convertRemoteImportance('LOW CRITICAL').title

    'Critical'

    >>> external_bugzilla.convertRemoteImportance('CRITICAL').title

    'Critical'

    >>> external_bugzilla.convertRemoteImportance('URGENT MAJOR').title

    'High'

    >>> external_bugzilla.convertRemoteImportance('LOW MAJOR').title

    'High'

    >>> external_bugzilla.convertRemoteImportance('MAJOR').title

    'High'

    >>> external_bugzilla.convertRemoteImportance('CRASH').title

    'High'

    >>> external_bugzilla.convertRemoteImportance('GRAVE').title

    'High'

    >>> external_bugzilla.convertRemoteImportance('URGENT NORMAL').title

    'Medium'

    >>> external_bugzilla.convertRemoteImportance('LOW NORMAL').title

    'Medium'

    >>> external_bugzilla.convertRemoteImportance('NORMAL').title

    'Medium'

    >>> external_bugzilla.convertRemoteImportance('NOR').title

    'Medium'

    >>> external_bugzilla.convertRemoteImportance('URGENT MINOR').title

    'Low'

    >>> external_bugzilla.convertRemoteImportance('LOW MINOR').title

    'Low'

    >>> external_bugzilla.convertRemoteImportance('MINOR').title

    'Low'

    >>> external_bugzilla.convertRemoteImportance('URGENT TRIVIAL').title

    'Low'

    >>> external_bugzilla.convertRemoteImportance('LOW TRIVIAL').title

    'Low'

    >>> external_bugzilla.convertRemoteImportance('TRIVIAL').title

    'Low'

    >>> external_bugzilla.convertRemoteImportance('LOW ENHANCEMENT').title

    'Wishlist'

    >>> external_bugzilla.convertRemoteImportance('ENHANCEMENT').title

    'Wishlist'

    >>> external_bugzilla.convertRemoteImportance('WISHLIST').title

    'Wishlist'

    >>> external_bugzilla.convertRemoteImportance('IMMEDIATE').title

    'Critical'

    >>> external_bugzilla.convertRemoteImportance('URGENT').title

    'Critical'

    >>> external_bugzilla.convertRemoteImportance('HIGH').title

    'High'

    >>> external_bugzilla.convertRemoteImportance('MEDIUM').title

    'Medium'

    >>> external_bugzilla.convertRemoteImportance('LOW').title

    'Low'

    >>> external_bugzilla.convertRemoteImportance('P5').title

    'Critical'

    >>> external_bugzilla.convertRemoteImportance('P4').title

    'High'

    >>> external_bugzilla.convertRemoteImportance('P3').title

    'Medium'

    >>> external_bugzilla.convertRemoteImportance('P2').title

    'Low'

    >>> external_bugzilla.convertRemoteImportance('P1').title

    'Low'

Some bugzillas don't provide a value, resulting in blank strings for

priority and severity.  We simply leave the importance unknown in this

case.

    >>> external_bugzilla.convertRemoteImportance('').title

    'Unknown'

However, we still treat as an error if the priority or severity are set

to some other unexpected string.

    >>> external_bugzilla.convertRemoteImportance('foo bar')

    Traceback (most recent call last):

    ...

    UnknownRemoteImportanceError: foo bar

    >>> external_bugzilla.convertRemoteImportance('%&*@*#&$%!')

    Traceback (most recent call last):

    ...

    UnknownRemoteImportanceError: %&*@*#&$%!

Updating Bug Watches

--------------------

The main use of an ExternalBugtracker is to update bug watches. This is

done through updateBugWatches(), which expects a list of bug watches to

update:

    >>> from lp.bugs.scripts.checkwatches import CheckwatchesMaster

    >>> bug_watch_updater = CheckwatchesMaster(txn)

    >>> for bug_watch in gnome_bugzilla.watches:

    ...     print "%s: %s %s" % (bug_watch.remotebug,

    ...           bug_watch.remotestatus,

    ...           bug_watch.remote_importance)

    304070: None None

    3224:  None

    >>> bug_watch_updater.updateBugWatches(

    ...     external_bugzilla, gnome_bugzilla.watches)

    INFO:...:Updating 2 watches for 2 bugs on http://bugzilla.gnome.org/bugs

    INFO:...Didn't find bug u'304070' on

    http://bugzilla.gnome.org/bugs (local bugs: 15).

    >>> for bug_watch in gnome_bugzilla.watches:

    ...     print "%s: %s %s" % (bug_watch.remotebug,

    ...           bug_watch.remotestatus,

    ...           bug_watch.remote_importance)

    304070: None None

    3224: RESOLVED FIXED MINOR URGENT

Let's add a handful of watches:

    >>> from lp.bugs.interfaces.bug import IBugSet

    >>> from lp.bugs.interfaces.bugwatch import IBugWatchSet

    >>> from lp.registry.interfaces.person import IPersonSet

    >>> sample_person = getUtility(IPersonSet).getByEmail(

    ...     'test@canonical.com')

    >>> bug_one = getUtility(IBugSet).get(1)

    >>> bug_watch_set = getUtility(IBugWatchSet)

    >>> expected_remote_statuses = dict(

    ...     [(int(bug_watch.remotebug), bug_watch.remotestatus)

    ...      for bug_watch in gnome_bugzilla.watches])

    >>> expected_remote_importances = dict(

    ...     [(int(bug_watch.remotebug), bug_watch.remote_importance)

    ...      for bug_watch in gnome_bugzilla.watches])

    >>> for remote_bug_id in range(50,55):

    ...     bug_watch = bug_watch_set.createBugWatch(

    ...         bug=bug_one, owner=sample_person, bugtracker=gnome_bugzilla,

    ...         remotebug=str(remote_bug_id))

    ...     external_bugzilla.bugzilla_bugs[remote_bug_id] = (

    ...         'RESOLVED', 'FIXED', 'HIGH', 'ENHANCEMENT')

    ...     expected_remote_statuses[remote_bug_id] = 'RESOLVED FIXED'

    ...     expected_remote_importances[remote_bug_id] = 'HIGH ENHANCEMENT'

Set the batch threshold higher than the number of bug watches.

    >>> external_bugzilla.batch_query_threshold = 10

Then updateBugWatches() will make one request per bug watch:

    >>> external_bugzilla.trace_calls = True

    >>> bug_watch_updater.updateBugWatches(

    ...     external_bugzilla, gnome_bugzilla.watches)

    INFO:...:Updating 7 watches for 7 bugs on http://bugzilla.gnome.org/bugs

    CALLED _postPage()

    CALLED _postPage()

    CALLED _postPage()

    CALLED _postPage()

    CALLED _postPage()

    CALLED _postPage()

    CALLED _postPage()

    INFO:...:Didn't find bug u'304070' on

    http://bugzilla.gnome.org/bugs (local bugs: 15).

    >>> remote_statuses = dict(

    ...     [(int(bug_watch.remotebug), bug_watch.remotestatus)

    ...      for bug_watch in gnome_bugzilla.watches])

    >>> remote_statuses == expected_remote_statuses

    True

    >>> remote_importances = dict(

    ...     [(int(bug_watch.remotebug), bug_watch.remote_importance)

    ...      for bug_watch in gnome_bugzilla.watches])

    >>> remote_importances == expected_remote_importances

    True

    >>> external_bugzilla.trace_calls = False

Let's add a few more watches:

    >>> expected_remote_statuses = dict(

    ...     [(int(bug_watch.remotebug), bug_watch.remotestatus)

    ...      for bug_watch in gnome_bugzilla.watches])

    >>> expected_remote_importances = dict(

    ...     [(int(bug_watch.remotebug), bug_watch.remote_importance)

    ...      for bug_watch in gnome_bugzilla.watches])

    >>> for remote_bug_id in range(100,300):

    ...     bug_watch = bug_watch_set.createBugWatch(

    ...         bug=bug_one, owner=sample_person, bugtracker=gnome_bugzilla,

    ...         remotebug=str(remote_bug_id))

    ...     external_bugzilla.bugzilla_bugs[remote_bug_id] = (

    ...         'ASSIGNED', '', 'MEDIUM', 'URGENT')

    ...     expected_remote_statuses[remote_bug_id] = 'ASSIGNED'

    ...     expected_remote_importances[remote_bug_id] = 'MEDIUM URGENT'

Set the batch threshold very low and remove the batch size limit:

    >>> external_bugzilla.batch_query_threshold = 0

    >>> external_bugzilla.batch_size = None

Instead of issuing one request per bug watch, like was done before,

updateBugWatches() issues only one request to update all watches:

    >>> external_bugzilla.trace_calls = True

    >>> bug_watch_updater.updateBugWatches(

    ...     external_bugzilla, gnome_bugzilla.watches)

    INFO:...:Updating 207 watches for 207 bugs...

    CALLED _postPage()

    INFO:...:Didn't find bug u'304070' on

    http://bugzilla.gnome.org/bugs (local bugs: 15).

    >>> remote_statuses = dict(

    ...     [(int(bug_watch.remotebug), bug_watch.remotestatus)

    ...      for bug_watch in gnome_bugzilla.watches])

    >>> remote_statuses == expected_remote_statuses

    True

    >>> remote_importances = dict(

    ...     [(int(bug_watch.remotebug), bug_watch.remote_importance)

    ...      for bug_watch in gnome_bugzilla.watches])

    >>> remote_importances == expected_remote_importances

    True

    >>> external_bugzilla.trace_calls = False

updateBugWatches() updates the lastchecked attribute on the watches, so

now no bug watches are in need of updating:

    >>> from lp.services.database.sqlbase import flush_database_updates

    >>> flush_database_updates()

    >>> gnome_bugzilla.watches_needing_update.count()

    0

If the status isn't different, the lastchanged attribute doesn't get

updated:

    >>> import pytz

    >>> from datetime import datetime, timedelta

    >>> bug_watch = gnome_bugzilla.watches[0]

    >>> now = datetime.now(pytz.timezone('UTC'))

    >>> bug_watch.lastchanged = now - timedelta(weeks=2)

    >>> old_last_changed = bug_watch.lastchanged

    >>> bug_watch_updater.updateBugWatches(external_bugzilla, [bug_watch])

    INFO:...:Updating 1 watches for 1 bugs on http://bugzilla.gnome.org/bugs

    >>> bug_watch.lastchanged == old_last_changed

    True

Now let's take a look at what happens when a bug watch is linked to

from a bug task.

    >>> bug_nine = getUtility(IBugSet).get(9)

    >>> thunderbird_task = bug_nine.bugtasks[0]

    >>> print thunderbird_task.status.title

    Unknown

    >>> thunderbird_task.bugwatch.remotestatus is None

    True

    >>> thunderbird_task.bugwatch.remote_importance is None

    True

Importance gets updated for Bugzilla bugs.  Let's set it to some bogus

value, and see that it gets set to a proper value.

    >>> from lp.bugs.interfaces.bugtask import BugTaskImportance

    >>> thunderbird_task.transitionToImportance(

    ...     BugTaskImportance.HIGH,

    ...     thunderbird_task.pillar.owner)

We need to create a new ExternalBugtracker for the Mozilla tracker:

    >>> mozilla_bugzilla = getUtility(IBugTrackerSet).getByName(

    ...     'mozilla.org')

    >>> external_bugzilla = TestBugzilla(mozilla_bugzilla.baseurl, '2.20')

    >>> external_bugzilla.bugzilla_bugs = {1234: (

    ...     'ASSIGNED', '', 'MEDIUM', 'ENHANCEMENT')}

Let's update the bug watch, and see that the linked bug watch got

synced:

    >>> bug_watch_updater.updateBugWatches(

    ...     external_bugzilla, [thunderbird_task.bugwatch])

    INFO:...:Updating 1 watches for 1 bugs on https://bugzilla.mozilla.org

    >>> bug_nine = getUtility(IBugSet).get(9)

    >>> thunderbird_task = bug_nine.bugtasks[0]

    >>> print thunderbird_task.status.title

    In Progress

    >>> print thunderbird_task.importance.title

    Wishlist

    >>> print thunderbird_task.bugwatch.remotestatus

    ASSIGNED

    >>> print thunderbird_task.bugwatch.remote_importance

    MEDIUM ENHANCEMENT

If we change the bugtask status, it will be updated again even though

the remote status hasn't changed. This can happen if we change the

status mapping.

    >>> from lp.bugs.interfaces.bugtask import BugTaskStatus

    >>> thunderbird_task.transitionToStatus(

    ...     BugTaskStatus.CONFIRMED,

    ...     getUtility(IPersonSet).getByName('no-priv'))

    >>> bug_watch_updater.updateBugWatches(

    ...     external_bugzilla, [thunderbird_task.bugwatch])

    INFO:...:Updating 1 watches for 1 bugs on https://bugzilla.mozilla.org

    >>> bug_nine = getUtility(IBugSet).get(9)

    >>> thunderbird_task = bug_nine.bugtasks[0]

    >>> print thunderbird_task.status.title

    In Progress

    >>> print thunderbird_task.importance.title

    Wishlist

    >>> print thunderbird_task.bugwatch.remotestatus

    ASSIGNED

    >>> print thunderbird_task.bugwatch.remote_importance

    MEDIUM ENHANCEMENT

If there are two bug watches, linked to different bugs, pointing to the

same remote bug, both will of course be updated.

    >>> external_bugzilla.bugzilla_bugs[42] = (

    ...     'RESOLVED', 'FIXED', 'LOW', 'BLOCKER')

    >>> bug_watch1 = bug_watch_set.createBugWatch(

    ...     bug=bug_one, owner=sample_person, bugtracker=mozilla_bugzilla,

    ...     remotebug='42')

    >>> bug_watch1_id = bug_watch1.id

    >>> bug_two = getUtility(IBugSet).get(2)

    >>> bug_watch2 = bug_watch_set.createBugWatch(

    ...     bug=bug_two, owner=sample_person, bugtracker=mozilla_bugzilla,

    ...     remotebug='42')

    >>> bug_watch2_id = bug_watch2.id

    >>> bug_watch_updater.updateBugWatches(

    ...     external_bugzilla, [bug_watch1, bug_watch2])

    INFO:...:Updating 2 watches for 1 bugs on https://bugzilla.mozilla.org

    >>> bug_watch1 = getUtility(IBugWatchSet).get(bug_watch1_id)

    >>> print bug_watch1.remotestatus

    RESOLVED FIXED

    >>> print bug_watch1.remote_importance

    LOW BLOCKER

    >>> bug_watch2 = getUtility(IBugWatchSet).get(bug_watch2_id)

    >>> print bug_watch2.remotestatus

    RESOLVED FIXED

    >>> print bug_watch2.remote_importance

    LOW BLOCKER

If updateBugWatches() can't parse the XML file returned from the remote

bug tracker, an error is logged.

    >>> external_bugzilla._postPage = (

    ...     lambda self, data, repost_on_redirect: '<invalid xml>')

    >>> bug_watch_updater.updateBugWatches(

    ...     external_bugzilla, [bug_watch1, bug_watch2])

    Traceback (most recent call last):

    ...

    UnparsableBugData:

    Failed to parse XML description for https://bugzilla.mozilla.org...

The error is also recorded in each bug watch's last_error_type field so that

it can be displayed to the user.

    >>> bug_watch1 = getUtility(IBugWatchSet).get(bug_watch1_id)

    >>> bug_watch1.last_error_type.title

    'Unparsable Bug'

    >>> bug_watch2 = getUtility(IBugWatchSet).get(bug_watch2_id)

    >>> bug_watch2.last_error_type.title

    'Unparsable Bug'

Getting Remote Product

----------------------

getRemoteProduct() returns the product a remote bug is associated with

in Bugzilla. getRemoteProduct() has to be called after

initializeRemoteBugDB() has been called, in order for the bug

information to be fetched from the external Bugzilla instance.

    >>> external_bugzilla = TestBugzilla()

    >>> external_bugzilla.bugzilla_bugs = {84: (

    ...     'RESOLVED', 'FIXED', 'MEDIUM', 'NORMAL')}

    >>> external_bugzilla.initializeRemoteBugDB(['84'])

    >>> external_bugzilla.remote_bug_product['84']

    u'product-84'

    >>> external_bugzilla.getRemoteProduct('84')

    u'product-84'

Sometimes we might not get the product in the bug listing. In these

cases getRemoteProduct() returns None.

    >>> external_bugzilla = TestBugzilla()

    >>> external_bugzilla.bugzilla_bugs = {84: (

    ...     'RESOLVED', 'FIXED', 'MEDIUM', 'NORMAL')}

    >>> # Make the buglist XML not include the product tag.

    >>> external_bugzilla.bug_item_file = 'gnome_bug_li_item_noproduct.xml'

    >>> external_bugzilla.initializeRemoteBugDB(['84'])

    >>> print external_bugzilla.getRemoteProduct('84')

    None

Requesting the product for a bug that doesn't exist raises BugNotFound.

    >>> external_bugzilla = TestBugzilla()

    >>> external_bugzilla.bugzilla_bugs = {84: (

    ...     'RESOLVED', 'FIXED', 'MEDIUM', 'NORMAL')}

    >>> external_bugzilla.initializeRemoteBugDB(['84'])

    >>> external_bugzilla.getRemoteProduct('42')

    Traceback (most recent call last):

    ...

    BugNotFound: 42