Merge lp:~michael.nelson/software-center/833982-purchased-app-not-available into lp:software-center

[Michael Nelson]

This branch is part 1 of a fix for bug 917137 - Previous purchases empty in precise.

The cause of the bug seemed to be that the SoftwareCenterAgentParser was expecting a json object from the 1.0 'my subscriptions' api - where the attributes for the application related to each subscription were flattened into the one dict.

The 2.0 api does not do this, intentionally nesting the application attributes.

After chatting with mvo, we decided 2 parsers should be included - one for parsing applications (from 2.0 available apps call), the other for parsing subscriptions ("Purchased applications", from 2.0 subscriptions_for_me call).

Also done:
 * Removed the 'icon' attribute from the mapping, as we no-longer support it via the API (check with mvo).
 * Fixed get_desktop_categories

Testing
=======
cd test;make
Note: I get two failures (test_reviews, test_database) as well as python-coverage crashing while running the tests: http://paste.ubuntu.com/807433/

Anyway, still to do in a follow-up branch coming shortly:
 * Check if we can update PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME = "For Purchase" (value returned via API). How will this affect existing clients, if at all?
 * remove the need for the SCASubscriptionParser to both inherit from and encapsulate the SoftwareCenterAgentParser,
 * Filter results of the my_subscriptions call (only keep Complete ones), as currently it looks like this: http://people.canonical.com/~michaeln/tmp/833982-previous-purchases-working-but-dupes.png
 * Rename s/SoftwareCenterAgentParser/SCAApplicationParser for consistency
 * Replace the MockAvailableForMeItem/List with real PistonResponseObjects

[lp:~michael.nelson/software-center/833982-purchased-app-not-available]

2676. By Michael Nelson on 2012-01-17

REFACTOR: replaced help/* in bzr ignore, updated requirement in README.

[Gary Lasker (gary-lasker)]

Hi Michael! This is really nice work and the additional changes that you are working on sound just right.

As we discussed in IRC earlier, there's one problem that I found in the current branch, and that is that with this change we getting an empty list for For Purchase apps. THis appears to be an issue with setting the "magic channel" to PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME in the SoftwareCenterAgentParser class.

I made a quick attempt to fix this in the following branch:

  lp:~gary-lasker/software-center/noodles-833982-purchased-app-not-available

You can see that I separated the two "magic channel" settings into the corresponding parser classes. This indeed restores the apps for purchase , but now I'm getting an empty list for the previous purchases, so it's not correct yet. Unfortunately, I had to leave for the day and and could not go further, but hopefully it's something simple and it won't be too hard to finish up tomorrow. In any case, I hope this branch is some help. I'll check in with you when I get back online in the morning.

Btw, I'm testing using the Oneiric apps for purchase by using:

  SOFTWARE_CENTER_DISTRO_CODENAME="oneiric" PYTHONPATH=. python ./software-center

Thanks!

[lp:~michael.nelson/software-center/833982-purchased-app-not-available]

2677. By Michael Nelson on 2012-01-18

RED: applications and purchased applications should have the correct magic channel.

2678. By Michael Nelson on 2012-01-18

GREEN: applications and purchased applications should have the correct magic channel.

[Michael Nelson (michael.nelson)]

> Hi Michael! This is really nice work and the additional changes that you are
> working on sound just right.
>
> As we discussed in IRC earlier, there's one problem that I found in the
> current branch, and that is that with this change we getting an empty list for
> For Purchase apps. THis appears to be an issue with setting the "magic
> channel" to PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME in the
> SoftwareCenterAgentParser class.

Right - I'd not realised it was being set on the entry before instantiating the parser - thanks for the pointer.

>
> I made a quick attempt to fix this in the following branch:
>
> lp:~gary-lasker/software-center/noodles-833982-purchased-app-not-available
>
> You can see that I separated the two "magic channel" settings into the
> corresponding parser classes. This indeed restores the apps for purchase , but
> now I'm getting an empty list for the previous purchases, so it's not correct
> yet. Unfortunately, I had to leave for the day and and could not go further,
> but hopefully it's something simple and it won't be too hard to finish up
> tomorrow. In any case, I hope this branch is some help. I'll check in with you
> when I get back online in the morning.

Thanks - that helped. I've pushed some failing tests with r2677 then fixed the issue with r2678. Now I see both for purchase apps and my previously installed.

[Gary Lasker (gary-lasker)]

So, it's indeed fixed (nice, clean fix!) and already merged so I'll set this a approved. Thanks again for this and also thanks for the README dev setup instructions!

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2011-05-27 08:25:15 +0000
+++ .bzrignore	2012-01-18 09:00:32 +0000
@@ -17,3 +17,8 @@
 data/xapian/spelling.baseA
 data/xapian/spelling.baseB
 build/
+test/.coverage
+test/coverage_html
+test/coverage_summary
+test/output
+help/*

=== modified file 'README'
--- README	2011-07-27 16:43:26 +0000
+++ README	2012-01-18 09:00:32 +0000
@@ -7,6 +7,23 @@
 
 All non UI code must come with tests in the test/ subdirectoy.
 
+To setup your development environment, you'll need to ensure the following
+extra packages are installed:
+
+sudo apt-get install xvfb python-coverage python-mock python-aptdaemon.test \
+     python-qt4 python-unittest2
+sudo apt-get build-dep software-center
+
+You can then run tests with:
+
+cd test;make
+
+You can run a developer instance with:
+
+python setup.py build
+./software-center
+
+
 == query parser ==
 
 The query parser understands :
@@ -15,7 +32,7 @@
 
 == aptdaemon ==
  * the dbus limits for the system bus are rather low, this means that
-   adding  <limit name="max_match_rules_per_connection">512</limit> 
+   adding  <limit name="max_match_rules_per_connection">512</limit>
    and using something bigger than 512 is a good idea
 
 == environment ==
@@ -54,7 +71,7 @@
 SCPkgname - e.g. "gimp"
 
 Additional .menu files can be added in:
-/usr/share/app-install/menu.d 
+/usr/share/app-install/menu.d
 that software-center will read and parse.
 
 == XAPIAN ==
@@ -66,9 +83,9 @@
 AS - archive pocket (main)
 AE - archive section (mail, base, ...)
 AC - category (AudioVideo)
-AM - MimeType (application/x-ogg) 
+AM - MimeType (application/x-ogg)
 AT - type (Application)
-AH - channel 
+AH - channel
 
 
 The following values are used:
@@ -89,5 +106,5 @@
 XAPIAN_VALUE_PURCHASED_DATE - the data a for-pay app was purchased (only available after the software-center-agent server was queried)
 XAPIAN_VALUE_SCREENSHOT_URL - a (optional) screenshot url that overrides the default
 XAPIAN_VALUE_ICON_NEEDS_DOWNLOAD - icon needs to be fetched
-XAPIAN_VALUE_THUMBNAIL_URL - thumbnail url 
+XAPIAN_VALUE_THUMBNAIL_URL - thumbnail url
 

=== modified file 'softwarecenter/db/update.py'
--- softwarecenter/db/update.py	2012-01-05 08:52:42 +0000
+++ softwarecenter/db/update.py	2012-01-18 09:00:32 +0000
@@ -26,6 +26,7 @@
 import time
 
 from gi.repository import GObject
+from piston_mini_client import PistonResponseObject
 
 from softwarecenter.utils import utf8
 
@@ -131,6 +132,7 @@
     def desktopf(self):
         """ return the file that the AppInfo comes from """
 
+
 class SoftwareCenterAgentParser(AppInfoParserBase):
     """ map the data we get from the software-center-agent """
 
@@ -140,20 +142,17 @@
                 'Package'    : 'package_name',
                 'Categories' : 'categories',
                 'Channel'    : 'channel',
-                'Deb-Line'   : 'deb_line',
                 'Signing-Key-Id' : 'signing_key_id',
                 'License'    : 'license',
                 'Date-Published' : 'date_published',
-                'Purchased-Date' : 'purchase_date',
-                'License-Key' : 'license_key',
-                'License-Key-Path' : 'license_key_path',
                 'PPA'        : 'archive_id',
-                'Icon'       : 'icon',
                 'Screenshot-Url' : 'screenshot_url',
                 'Thumbnail-Url' : 'thumbnail_url',
                 'Video-Url' :  'video_url',
                 'Icon-Url'   : 'icon_url',
                 'Support-Url'   : 'support_url',
+                'Description' : 'Description',
+                'Comment' : 'Comment',
               }
 
     # map from requested key to a static data element
@@ -164,6 +163,7 @@
         self.sca_entry = sca_entry
         self.origin = "software-center-agent"
         self._apply_exceptions()
+
     def _apply_exceptions(self):
         # for items from the agent, we use the full-size screenshot for
         # the thumbnail and scale it for display, this is done because
@@ -172,25 +172,86 @@
             not hasattr(self.sca_entry, "thumbnail_url")):
             self.sca_entry.thumbnail_url = self.sca_entry.screenshot_url
         if hasattr(self.sca_entry, "description"):
-            self.sca_entry.Comment = self.sca_entry.description.split("\n")[0]
-            self.sca_entry.Description = "\n".join(self.sca_entry.description.split("\n")[1:])
+            self.sca_entry.Comment = self.sca_entry.description.split("\n")[0].strip()
+            self.sca_entry.Description = "\n".join(
+                self.sca_entry.description.split("\n")[1:]).strip()
+        # WARNING: item.name needs to be different than
+        #          the item.name in the DB otherwise the DB
+        #          gets confused about (appname, pkgname) duplication
+        self.sca_entry.name = utf8(_("%s (already purchased)")) % utf8(
+            self.sca_entry.name)
+
+        # XXX 2012-01-16 bug=917109
+        # We can remove these work-arounds once the above bug is fixed on
+        # the server. Until then, we fake a channel here and empty category
+        # to make the parser happy. Note: available_apps api call includes
+        # these already, it's just the apps with subscriptions_for_me which
+        # don't currently.
+        self.sca_entry.channel = AVAILABLE_FOR_PURCHASE_MAGIC_CHANNEL_NAME
+        if not hasattr(self.sca_entry, 'categories'):
+            self.sca_entry.categories = ""
+
     def get_desktop(self, key, translated=True):
         if key in self.STATIC_DATA:
             return self.STATIC_DATA[key]
         return getattr(self.sca_entry, self._apply_mapping(key))
+
     def get_desktop_categories(self):
         try:
             return ['DEPARTMENT:' + self.sca_entry.department[-1]] + self._get_desktop_list("Categories")
         except:
             return self._get_desktop_list("Categories")
+
     def has_option_desktop(self, key):
         return (key in self.STATIC_DATA or
                 hasattr(self.sca_entry, self._apply_mapping(key)))
+
     @property
     def desktopf(self):
         return self.origin
 
 
+class SCAPurchasedApplicationParser(SoftwareCenterAgentParser):
+    """A subscription has its own attrs with a subset of the app attributes.
+    
+    We inherit from SoftwareCenterAgentParser so that we get other methods for
+    free, and we compose a SoftwareCenterAgentParser because we need the
+    get_desktop method with the correct MAPPING. TODO: There must be a nicer
+    way to organise this so that we don't need both inheritance and composition
+    for a DRY implementation.
+    """
+
+    def __init__(self, sca_subscription):
+        # The sca_subscription is a PistonResponseObject, whereas any child
+        # objects are normal Python dicts.
+        self.sca_subscription = sca_subscription
+        self.application_parser = SoftwareCenterAgentParser(
+            PistonResponseObject.from_dict(sca_subscription.application))
+        super(SCAPurchasedApplicationParser, self).__init__(
+            PistonResponseObject.from_dict(sca_subscription.application))
+        self.application_parser.sca_entry.channel = (
+            PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME)
+
+    MAPPING = { 'Deb-Line'   : 'deb_line',
+                'Purchased-Date' : 'purchase_date',
+                'License-Key' : 'license_key',
+                'License-Key-Path' : 'license_key_path',
+              }
+
+    def get_desktop(self, key, translated=True):
+        if self.application_parser.has_option_desktop(key):
+            return self.application_parser.get_desktop(key, translated)
+
+        return getattr(self.sca_subscription, self._apply_mapping(key))
+
+    def has_option_desktop(self, key):
+        subscription_has_option = hasattr(
+            self.sca_subscription, self._apply_mapping(key))
+        application_has_option = (
+            self.application_parser.has_option_desktop(key))
+        return subscription_has_option or application_has_option
+
+
 class JsonTagSectionParser(AppInfoParserBase):
 
     MAPPING = { 'Name'       : 'application_name',
@@ -505,15 +566,7 @@
         #    continue
         # index the item
         try:
-            # we fake a channel here
-            item.channel = PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME
-            # and empty category to make the parser happy
-            item.categories = ""
-            # WARNING: item.name needs to be different than
-            #          the item.name in the DB otherwise the DB
-            #          gets confused about (appname, pkgname) duplication
-            item.name = utf8(_("%s (already purchased)")) % utf8(item.name)
-            parser = SoftwareCenterAgentParser(item)
+            parser = SCAPurchasedApplicationParser(item)
             index_app_info_from_parser(parser, db_purchased, cache)
         except Exception as e:
             LOG.exception("error processing: %s " % e)
@@ -560,8 +613,6 @@
         while context.pending():
             context.iteration()
         try:
-            # magic channel
-            entry.channel = AVAILABLE_FOR_PURCHASE_MAGIC_CHANNEL_NAME
             # now the normal parser
             parser = SoftwareCenterAgentParser(entry)
             index_app_info_from_parser(parser, db, cache)
@@ -663,20 +714,21 @@
         # date published
         if parser.has_option_desktop("X-AppInstall-Date-Published"):
             date_published = parser.get_desktop("X-AppInstall-Date-Published")
-            # strip the subseconds from the end of the published date string
-            date_published = str(date_published).split(".")[0]
-            doc.add_value(XapianValues.DATE_PUBLISHED,
-                          date_published)
-            # we use the date published value for the cataloged time as well
-            if "catalogedtime" in axi_values:
-                LOG.debug(
-                        ("pkgname: %s, date_published cataloged time is: %s" %
-                             (pkgname, parser.get_desktop("date_published"))))
-                date_published_sec = time.mktime(
-                                        time.strptime(date_published,
-                                                      "%Y-%m-%d  %H:%M:%S"))
-                doc.add_value(axi_values["catalogedtime"], 
-                              xapian.sortable_serialise(date_published_sec))
+            if date_published:
+                # strip the subseconds from the end of the published date string
+                date_published = str(date_published).split(".")[0]
+                doc.add_value(XapianValues.DATE_PUBLISHED,
+                              date_published)
+                # we use the date published value for the cataloged time as well
+                if "catalogedtime" in axi_values:
+                    LOG.debug(
+                            ("pkgname: %s, date_published cataloged time is: %s" %
+                                 (pkgname, parser.get_desktop("date_published"))))
+                    date_published_sec = time.mktime(
+                                            time.strptime(date_published,
+                                                          "%Y-%m-%d  %H:%M:%S"))
+                    doc.add_value(axi_values["catalogedtime"], 
+                                  xapian.sortable_serialise(date_published_sec))
         # purchased date
         if parser.has_option_desktop("X-AppInstall-Purchased-Date"):
             date = parser.get_desktop("X-AppInstall-Purchased-Date")

=== modified file 'test/test_reinstall_purchased.py'
--- test/test_reinstall_purchased.py	2012-01-16 14:42:49 +0000
+++ test/test_reinstall_purchased.py	2012-01-18 09:00:32 +0000
@@ -7,28 +7,89 @@
 import unittest
 import xapian
 
+from piston_mini_client import PistonResponseObject
 from testutils import setup_test_env
 setup_test_env()
-from softwarecenter.enums import XapianValues
+
+from softwarecenter.enums import (XapianValues,
+                                  AVAILABLE_FOR_PURCHASE_MAGIC_CHANNEL_NAME,
+                                  PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME,
+                                  )
 from softwarecenter.db.database import StoreDatabase
-from softwarecenter.db.update import add_from_purchased_but_needs_reinstall_data
+from softwarecenter.db.update import (
+    add_from_purchased_but_needs_reinstall_data,
+    SCAPurchasedApplicationParser,
+    SoftwareCenterAgentParser,
+    )
 
-# from
-#  https://wiki.canonical.com/Ubuntu/SoftwareCenter/10.10/Roadmap/SoftwareCenterAgent
-AVAILABLE_FOR_ME_JSON = """
-[
-    {
-        "archive_id": "mvo/private-test",
-        "deb_line": "deb https://username:[e-mail]/mvo/private-test/ubuntu maverick main #Personal access of username to private-test",
-        "purchase_price": "19.95",
-        "purchase_date": "2010-06-24 20:08:23",
-        "name": "Ubiteme",
-        "description": "One of the best strategy games you\'ll ever play!",
-        "package_name": "hellox",
-        "signing_key_id": "1024R/0EB12F05",
-        "series": {"natty": ["i386", "amd64"], 
-                   "maverick": ["i386", "amd64"], 
-                   "lucid": ["i386", "amd64"]}
+# Example taken from running:
+# PYTHONPATH=. utils/piston-helpers/piston_generic_helper.py --output=pickle \
+#           --debug --needs-auth SoftwareCenterAgentAPI subscriptions_for_me
+# then:
+#    f = open('my_subscriptions.pickle')
+#    subscriptions = pickle.load(f)
+#    completed_subs = [subs for subs in subscriptions if subs.state=='Complete']
+#    completed_subs[0].__dict__
+SUBSCRIPTIONS_FOR_ME_JSON = """
+[
+    {
+         "deb_line": "deb https://username:[e-mail]/commercial-ppa-uploaders/photobomb/ubuntu natty main",
+         "purchase_price": "2.99",
+         "purchase_date": "2011-09-16 06:37:52",
+         "state": "Complete",
+         "failures": [],
+         "open_id": "https://login.ubuntu.com/+id/ABCDEF",
+         "application": {
+              "archive_id": "commercial-ppa-uploaders/photobomb",
+              "signing_key_id": "1024R/75254D99",
+              "name": "Photobomb",
+              "package_name": "photobomb",
+              "description": "Easy and Social Image Editor\\nPhotobomb give you easy access to images in your social networking feeds, pictures on your computer and peripherals, and pictures on the web, and let\'s you draw, write, crop, combine, and generally have a blast mashing \'em all up. Then you can save off your photobomb, or tweet your creation right back to your social network."
+         },
+         "distro_series": {"code_name": "natty", "version": "11.04"}
+    }
+]
+"""
+# Taken directly from:
+# https://software-center.ubuntu.com/api/2.0/applications/en/ubuntu/oneiric/i386/
+AVAILABLE_APPS_JSON = """
+[
+    {
+        "archive_id": "commercial-ppa-uploaders/fluendo-dvd",
+        "signing_key_id": "1024R/75254D99",
+        "license": "Proprietary",
+        "name": "Fluendo DVD Player",
+        "package_name": "fluendo-dvd",
+        "support_url": "",
+        "series": {
+            "maverick": [
+                "i386",
+                "amd64"
+            ],
+            "natty": [
+                "i386",
+                "amd64"
+            ],
+            "oneiric": [
+                "i386",
+                "amd64"
+            ]
+        },
+        "price": "24.95",
+        "demo": null,
+        "date_published": "2011-12-05 18:43:21.653868",
+        "status": "Published",
+        "channel": "For Purchase",
+        "icon_data": "...",
+        "department": [
+            "Sound & Video"
+        ],
+        "archive_root": "https://private-ppa.launchpad.net/",
+        "screenshot_url": "http://software-center.ubuntu.com/site_media/screenshots/2011/05/fluendo-dvd-maverick_.png",
+        "tos_url": "https://software-center.ubuntu.com/licenses/3/",
+        "icon_url": "http://software-center.ubuntu.com/site_media/icons/2011/05/fluendo-dvd.png",
+        "categories": "AudioVideo",
+        "description": "Play DVD-Videos\\r\\n\\r\\nFluendo DVD Player is a software application specially designed to\\r\\nreproduce DVD on Linux/Unix platforms, which provides end users with\\r\\nhigh quality standards.\\r\\n\\r\\nThe following features are provided:\\r\\n* Full DVD Playback\\r\\n* DVD Menu support\\r\\n* Fullscreen support\\r\\n* Dolby Digital pass-through\\r\\n* Dolby Digital 5.1 output and stereo downmixing support\\r\\n* Resume from last position support\\r\\n* Subtitle support\\r\\n* Audio selection support\\r\\n* Multiple Angles support\\r\\n* Support for encrypted discs\\r\\n* Multiregion, works in all regions\\r\\n* Multiple video deinterlacing algorithms"
     }
 ]
 """
@@ -39,11 +100,11 @@
             setattr(self, key, value)
         self.MimeType = ""
         self.department = []
-            
+
 class MockAvailableForMeList(list):
 
     def __init__(self):
-        alist = json.loads(AVAILABLE_FOR_ME_JSON)
+        alist = json.loads(SUBSCRIPTIONS_FOR_ME_JSON)
         for entry_dict in alist:
             self.append(MockAvailableForMeItem(entry_dict))
 
@@ -62,7 +123,8 @@
     def test_reinstall_purchased_mock(self):
         # test if the mocks are ok
         self.assertEqual(len(self.available_to_me), 1)
-        self.assertEqual(self.available_to_me[0].package_name, "hellox")
+        self.assertEqual(
+            self.available_to_me[0].application['package_name'], "photobomb")
 
     def test_reinstall_purchased_xapian(self):
         db = StoreDatabase("/var/cache/software-center/xapian", self.cache)
@@ -81,12 +143,167 @@
         self.assertEqual(len(matches), 1)
         for m in matches:
             doc = db.xapiandb.get_document(m.docid)
-            self.assertEqual(doc.get_value(XapianValues.PKGNAME), "hellox")
-            self.assertEqual(doc.get_value(XapianValues.ARCHIVE_SIGNING_KEY_ID), "1024R/0EB12F05")
+            self.assertEqual(doc.get_value(XapianValues.PKGNAME), "photobomb")
+            self.assertEqual(
+                doc.get_value(XapianValues.ARCHIVE_SIGNING_KEY_ID),
+                "1024R/75254D99")
             self.assertEqual(doc.get_value(XapianValues.ARCHIVE_DEB_LINE),
-                                           "deb https://username:[e-mail]/mvo/private-test/ubuntu maverick main #Personal access of username to private-test")
-            break # only one match
-        
+                "deb https://username:random3atoken@"
+                 "private-ppa.launchpad.net/commercial-ppa-uploaders"
+                 "/photobomb/ubuntu natty main")
+
+
+class SoftwareCenterAgentParserTestCase(unittest.TestCase):
+
+    def _make_application_parser(self, piston_application=None):
+        if piston_application is None:
+            piston_application = PistonResponseObject.from_dict(
+                json.loads(AVAILABLE_APPS_JSON)[0])
+        return SoftwareCenterAgentParser(piston_application)
+
+    def test_parses_application_from_available_apps(self):
+        parser = self._make_application_parser()
+        inverse_map = dict(
+            (val, key) for key, val in SoftwareCenterAgentParser.MAPPING.items())
+
+        # Delete the keys which are not yet provided via the API:
+        del(inverse_map['video_url'])
+
+        for key in inverse_map:
+            self.assertTrue(parser.has_option_desktop(inverse_map[key]))
+            self.assertEqual(
+                getattr(parser.sca_entry, key),
+                parser.get_desktop(inverse_map[key]))
+
+    def test_keys_not_provided_by_api(self):
+        parser = self._make_application_parser()
+
+        self.assertFalse(parser.has_option_desktop('Video-Url'))
+        self.assertTrue(parser.has_option_desktop('Type'))
+        self.assertEqual('Application', parser.get_desktop('Type'))
+
+    def test_thumbnail_is_screenshot(self):
+        parser = self._make_application_parser()
+
+        self.assertEqual(
+            "http://software-center.ubuntu.com/site_media/screenshots/"
+            "2011/05/fluendo-dvd-maverick_.png",
+            parser.get_desktop('Thumbnail-Url'))
+
+    def test_extracts_description(self):
+        parser = self._make_application_parser()
+
+        self.assertEqual("Play DVD-Videos", parser.get_desktop('Comment'))
+        self.assertEqual(
+            "Fluendo DVD Player is a software application specially designed "
+            "to\r\nreproduce DVD on Linux/Unix platforms, which provides end "
+            "users with\r\nhigh quality standards.\r\n\r\nThe following "
+            "features are provided:\r\n* Full DVD Playback\r\n* DVD Menu "
+            "support\r\n* Fullscreen support\r\n* Dolby Digital pass-through"
+            "\r\n* Dolby Digital 5.1 output and stereo downmixing support\r\n"
+            "* Resume from last position support\r\n* Subtitle support\r\n"
+            "* Audio selection support\r\n* Multiple Angles support\r\n"
+            "* Support for encrypted discs\r\n"
+            "* Multiregion, works in all regions\r\n"
+            "* Multiple video deinterlacing algorithms",
+            parser.get_desktop('Description'))
+
+    def test_desktop_categories_uses_department(self):
+        parser = self._make_application_parser()
+
+        self.assertEqual([u'DEPARTMENT:Sound & Video', "AudioVideo"],
+            parser.get_desktop_categories())
+
+    def test_desktop_categories_no_department(self):
+        piston_app = PistonResponseObject.from_dict(
+            json.loads(AVAILABLE_APPS_JSON)[0])
+        del(piston_app.department)
+        parser = self._make_application_parser(piston_app)
+
+        self.assertEqual(["AudioVideo"], parser.get_desktop_categories())
+
+    def test_magic_channel(self):
+        parser = self._make_application_parser()
+
+        self.assertEqual(
+            AVAILABLE_FOR_PURCHASE_MAGIC_CHANNEL_NAME,
+            parser.get_desktop('Channel'))
+
+
+class SCAPurchasedApplicationParserTestCase(unittest.TestCase):
+
+    def _make_application_parser(self, piston_subscription=None):
+        if piston_subscription is None:
+            piston_subscription = PistonResponseObject.from_dict(
+                json.loads(SUBSCRIPTIONS_FOR_ME_JSON)[0])
+
+        return SCAPurchasedApplicationParser(piston_subscription)
+
+    def test_get_desktop_subscription(self):
+        parser = self._make_application_parser()
+
+        expected_results = {
+             "Deb-Line": "deb https://username:random3atoken@"
+                         "private-ppa.launchpad.net/commercial-ppa-uploaders"
+                         "/photobomb/ubuntu natty main",
+             "Purchased-Date": "2011-09-16 06:37:52",
+            }
+        for key in expected_results:
+            result = parser.get_desktop(key)
+            self.assertEqual(expected_results[key], result)
+
+    def test_get_desktop_application(self):
+        # The parser passes application attributes through to
+        # an application parser for handling.
+        parser = self._make_application_parser()
+
+        expected_results = {
+            "Name": "Photobomb (already purchased)",
+            "Package": "photobomb",
+            "Signing-Key-Id": "1024R/75254D99",
+            "PPA": "commercial-ppa-uploaders/photobomb",
+            }
+        for key in expected_results.keys():
+            result = parser.get_desktop(key)
+            self.assertEqual(expected_results[key], result)
+
+    def test_has_option_desktop_includes_app_keys(self):
+        # The SCAPurchasedApplicationParser handles application keys also
+        # (passing them through to the composited application parser).
+        parser = self._make_application_parser()
+
+        for key in ('Name', 'Package', 'Signing-Key-Id', 'PPA'):
+            self.assertTrue(parser.has_option_desktop(key))
+        for key in ('Deb-Line', 'Purchased-Date'):
+            self.assertTrue(parser.has_option_desktop(key),
+                    'Key: {0} was not an option.'.format(key))
+
+    def test_license_key_present(self):
+        piston_subscription = PistonResponseObject.from_dict(
+            json.loads(SUBSCRIPTIONS_FOR_ME_JSON)[0])
+        piston_subscription.license_key = 'abcd'
+        piston_subscription.license_key_path = '/foo'
+        parser = self._make_application_parser(piston_subscription)
+
+        self.assertTrue(parser.has_option_desktop('License-Key'))
+        self.assertTrue(parser.has_option_desktop('License-Key-Path'))
+        self.assertEqual('abcd', parser.get_desktop('License-Key'))
+        self.assertEqual('/foo', parser.get_desktop('License-Key-Path'))
+
+    def test_license_key_not_present(self):
+        parser = self._make_application_parser()
+
+        self.assertFalse(parser.has_option_desktop('License-Key'))
+        self.assertFalse(parser.has_option_desktop('License-Key-Path'))
+
+    def test_magic_channel(self):
+        parser = self._make_application_parser()
+
+        self.assertEqual(
+            PURCHASED_NEEDS_REINSTALL_MAGIC_CHANNEL_NAME,
+            parser.get_desktop('Channel'))
+
+
 if __name__ == "__main__":
     logging.basicConfig(level=logging.DEBUG)
     unittest.main()