~launchpad-pqm/launchpad/devel

Updating Product.remote_product

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

The remote_product attribute of a Product is used to present links for

filing and searching bugs in the Product's bug tracker, in case it's not

using Launchpad to track its bugs. We don't expect users to set the

remote_product themselves, so we have a script that tries to set this

automatically.

    >>> from lp.services.webapp.interfaces import (

    ...     IStoreSelector, DEFAULT_FLAVOR, MAIN_STORE)

    >>> store = getUtility(IStoreSelector).get(MAIN_STORE, DEFAULT_FLAVOR)

    >>> store.execute("UPDATE Product SET remote_product = 'not-None'")

    <storm...>

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

    >>> from lp.services.log.logger import FakeLogger, BufferLogger

    >>> from lp.bugs.scripts.updateremoteproduct import (

    ...     RemoteProductUpdater)

    >>> from lp.testing.faketransaction import FakeTransaction

    >>> updater = RemoteProductUpdater(FakeTransaction(), BufferLogger())

Testing

-------

To help testing, there is a method, _getExternalBugTracker(), that

creates the ExternalBugTracker for the given BugTracker.

    >>> rt = factory.makeBugTracker(

    ...     bugtrackertype=BugTrackerType.RT,

    ...     base_url=u'http://rt.example.com/')

    >>> rt_external = updater._getExternalBugTracker(rt)

    >>> rt_external.__class__.__name__

    'RequestTracker'

    >>> rt_external.baseurl

    u'http://rt.example.com'

For testing, _getExternalBugTracker() can be overridden to return an

ExternalBugTracker that doesn't require network access.

    >>> class FakeExternalBugTracker:

    ...

    ...     def initializeRemoteBugDB(self, bug_ids):

    ...         print "Initializing DB for bugs: %s." % bug_ids

    ...

    ...     def getRemoteProduct(self, remote_bug):

    ...         return 'product-for-bug-%s' % remote_bug

    >>> class NoNetworkRemoteProductUpdater(RemoteProductUpdater):

    ...

    ...     external_bugtracker_to_return = FakeExternalBugTracker

    ...

    ...     def _getExternalBugTracker(self, bug_tracker):

    ...         return self.external_bugtracker_to_return()

update()

--------

The update method simply loops over all the bug tracker types that can

track more than one product, and calls updateByBugTrackerType(). Any bug

tracker type that isn't specified as being for a single product is being

looped over. The EMAILADDRESS one is special, though. It could be used

for more than one product, but we have no way of interacting with it, so

it's skipped as well.

    >>> class TrackerTypeCollectingUpdater(RemoteProductUpdater):

    ...     def __init__(self):

    ...         self.logger = BufferLogger()

    ...         self.looped_over_bug_tracker_types = set()

    ...     def updateByBugTrackerType(self, bugtracker_type):

    ...         self.looped_over_bug_tracker_types.add(bugtracker_type)

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

    ...     SINGLE_PRODUCT_BUGTRACKERTYPES)

    >>> multi_product_trackers = set(

    ...     bugtracker_type for bugtracker_type in BugTrackerType.items

    ...     if bugtracker_type not in SINGLE_PRODUCT_BUGTRACKERTYPES)

    >>> multi_product_trackers.remove(BugTrackerType.EMAILADDRESS)

    >>> updater = TrackerTypeCollectingUpdater()

    >>> updater.update()

    >>> multi_product_trackers.symmetric_difference(

    ...     updater.looped_over_bug_tracker_types)

    set([])

updateByBugTrackerType()

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

The updateByBugTrackerType() method looks at the bug watches that are

linked to the product, to decide what remote_product should be set to.

It accepts a single parameter, the type of the bug tracker that should

be updated.

No bug watches

..............

If there are no bug watches, nothing will be done.

    >>> bugzilla_product = factory.makeProduct(

    ...     name=u'bugzilla-product', official_malone=False)

    >>> bugzilla = factory.makeBugTracker(

    ...     bugtrackertype=BugTrackerType.BUGZILLA)

    >>> bugzilla_product.bugtracker = bugzilla

    >>> rt_product = factory.makeProduct(

    ...     name=u'rt-product', official_malone=False)

    >>> rt = factory.makeBugTracker(

    ...     bugtrackertype=BugTrackerType.RT)

    >>> rt_product.bugtracker = rt

    >>> list(bugzilla_product.getLinkedBugWatches())

    []

    >>> updater.updateByBugTrackerType(BugTrackerType.RT)

    >>> print bugzilla_product.remote_product

    None

    >>> print rt_product.remote_product

    None

Linked bug watches

..................

If there are bug watches for a product having a None remote_product, an

arbitrary bug watch will be retrieved, and queried for its remote

product. Products having a bug tracker of a different type than the

given one are ignored.

    >>> import transaction

    >>> from lp.services.config import config

    >>> from lp.testing.layers import LaunchpadZopelessLayer

    >>> def switch_db_to_launchpad():

    ...     transaction.commit()

    ...     LaunchpadZopelessLayer.switchDbUser('launchpad')

    >>> def switch_db_to_updateremoteproduct():

    ...     transaction.commit()

    ...     LaunchpadZopelessLayer.switchDbUser(

    ...         config.updateremoteproduct.dbuser)

    >>> updater = NoNetworkRemoteProductUpdater(

    ...     FakeTransaction(), BufferLogger())

    >>> switch_db_to_launchpad()

    >>> bugzilla_bugtask = factory.makeBugTask(target=bugzilla_product)

    >>> bugzilla_bugwatch = factory.makeBugWatch(

    ...     '42', bugtracker=bugzilla, bug=bugzilla_bugtask.bug)

    >>> bugzilla_bugtask.bugwatch = bugzilla_bugwatch

    >>> rt_bugtask = factory.makeBugTask(target=rt_product)

    >>> rt_bugwatch = factory.makeBugWatch(

    ...     '84', bugtracker=rt, bug=rt_bugtask.bug)

    >>> rt_bugtask.bugwatch = rt_bugwatch

    >>> switch_db_to_updateremoteproduct()

    >>> updater.updateByBugTrackerType(BugTrackerType.RT)

    Initializing DB for bugs: [u'84'].

    >>> print rt_product.remote_product

    product-for-bug-84

    >>> print bugzilla_product.remote_product

    None

remote_product already set

..........................

If a product already has remote_product set, it will not be updated.

    >>> switch_db_to_launchpad()

    >>> rt_product = factory.makeProduct(official_malone=False)

    >>> rt = factory.makeBugTracker(

    ...     bugtrackertype=BugTrackerType.RT)

    >>> rt_product.bugtracker = rt

    >>> rt_bugtask = factory.makeBugTask(target=rt_product)

    >>> rt_bugwatch = factory.makeBugWatch(

    ...     '84', bugtracker=rt, bug=rt_bugtask.bug)

    >>> rt_bugtask.bugwatch = rt_bugwatch

    >>> switch_db_to_updateremoteproduct()

    >>> rt_product.remote_product = u'already-set'

    >>> updater = NoNetworkRemoteProductUpdater(

    ...     FakeTransaction(), BufferLogger())

    >>> updater.updateByBugTrackerType(BugTrackerType.RT)

    >>> print rt_product.remote_product

    already-set

Transaction handling

....................

To avoid long-running write transactions, the transaction is committed

after each product's remote_product has been updated.

    >>> switch_db_to_launchpad()

    >>> for index in range(3):

    ...     rt_product = factory.makeProduct(official_malone=False)

    ...     rt = factory.makeBugTracker(

    ...         bugtrackertype=BugTrackerType.RT)

    ...     rt_product.bugtracker = rt

    ...     rt_bugtask = factory.makeBugTask(target=rt_product)

    ...     rt_bugwatch = factory.makeBugWatch(

    ...         '84', bugtracker=rt, bug=rt_bugtask.bug)

    ...     rt_bugtask.bugwatch = rt_bugwatch

    >>> switch_db_to_updateremoteproduct()

    >>> updater = NoNetworkRemoteProductUpdater(

    ...     FakeTransaction(log_calls=True), BufferLogger())

    >>> updater.print_method_calls = False

    >>> updater.updateByBugTrackerType(BugTrackerType.RT)

    Initializing DB for bugs: [u'84'].

    COMMIT

    Initializing DB for bugs: [u'84'].

    COMMIT

    Initializing DB for bugs: [u'84'].

    COMMIT

Error handling

..............

If the ExternalBugTracker raises any BugWatchUpdateErrors,

updateByBugTrackerType() will simply log the error and then continue.

This is a simplistic approach but it means that problems with one bug

tracker don't break the run for all bug trackers.

    >>> switch_db_to_launchpad()

    >>> new_rt_product = factory.makeProduct(

    ...     name='fooix', official_malone=False)

    >>> new_rt_product.bugtracker = rt

    >>> new_rt_bugtask = factory.makeBugTask(target=new_rt_product)

    >>> new_rt_bugwatch = factory.makeBugWatch(

    ...     '42', bugtracker=rt, bug=new_rt_bugtask.bug)

    >>> new_rt_bugtask.bugwatch = new_rt_bugwatch

    >>> switch_db_to_updateremoteproduct()

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

    ...     BugNotFound, BugWatchUpdateError)

    >>> class BrokenOnInitExternalBugTracker(

    ...         FakeExternalBugTracker):

    ...     def initializeRemoteBugDB(self, bug_ids):

    ...         raise BugWatchUpdateError("This here is an error")

    >>> updater.logger = FakeLogger()

    >>> updater.external_bugtracker_to_return = (

    ...     BrokenOnInitExternalBugTracker)

    >>> updater.updateByBugTrackerType(BugTrackerType.RT)

    INFO  1 projects using RT needing updating.

    DEBUG Trying to update fooix

    ERROR Unable to set remote_product for 'fooix': This here is an error

    >>> class BrokenOnGetRemoteProductExternalBugTracker(

    ...         FakeExternalBugTracker):

    ...     def getRemoteProduct(self, remote_bug):

    ...         raise BugNotFound("Didn't find bug %s." % remote_bug)

    >>> updater.external_bugtracker_to_return = (

    ...     BrokenOnGetRemoteProductExternalBugTracker)

    >>> updater.updateByBugTrackerType(BugTrackerType.RT)

    INFO  1 projects using RT needing updating.

    DEBUG Trying to update fooix

    Initializing DB for bugs: [u'42'].

    ERROR Unable to set remote_product for 'fooix': Didn't find bug 42.

AssertionErrors are also handled.

    >>> class RaisesAssertionErrorExternalBugTracker(FakeExternalBugTracker):

    ...     def initializeRemoteBugDB(self, bug_ids):

    ...         assert True == False, "True isn't False!"

    >>> updater.external_bugtracker_to_return = (

    ...     RaisesAssertionErrorExternalBugTracker)

    >>> updater.updateByBugTrackerType(BugTrackerType.RT)

    INFO  1 projects using RT needing updating.

    DEBUG Trying to update fooix

    ERROR Unable to set remote_product for 'fooix': True isn't False!