Merge lp:~psivaa/utah/utah-upgrade2 into lp:~utah/utah/jenkins-upgradetest-setup

[Para Siva]

As per the comment in https://code.launchpad.net/~psivaa/utah/utah-upgrade/+merge/177884 and superseding it. Re-basing.
Contains the following changes:
1. Incorporate install_all_main.py rather than using it from the old location with some modification, for ease of maintenance
2. Changed the number of post upgrade tests
3. Added a line to destroy VMs at the end of the test.

[Max Brustkern (nuclearbob)]

Are you cleaning up the disks when destroying the machine?

[Para Siva (psivaa)]

I am not in favour of cleaning up the disks because that way we could manually restart the VM to investigate the VMs for any information that are not captured from the client logs in case of any failures. Destroying the VMs was introduced to reduce the processor load on the servers.

[Max Brustkern (nuclearbob)]

I forgot that 'destroy' in libvirt doesn't mean destroy in the way I usually think of it. Keeping them around for that makes sense.

On line 34, should redhat-cluster-suit be redhat-cluster-suite ?

Do the commented lines on 44, 52, 66, 74, and 176 need to stay in?

If it would be useful for the block starting on 629, we can work on doing a display-capable automated test, but I don't think that should hold up this merge.

post-upgrade/ts_control seems unnecessary since everything is commented out, but having it there as a placeholder isn't an unreasonable thing to do.

All of the actual important bits seem reasonable enough to me.

[lp:~psivaa/utah/utah-upgrade2]

44. By Para Siva on 2013-08-12

Fixing review comments bar the display-post upgrade test

[Para Siva (psivaa)]

review: Needs Resubmitting

[Max Brustkern (nuclearbob)]

Awesome!

review: Approve

=== modified file 'jenkins/jenkins.sh'
--- jenkins/jenkins.sh	2013-05-31 20:03:27 +0000
+++ jenkins/jenkins.sh	2013-08-12 10:37:39 +0000
@@ -92,4 +92,6 @@
 ${SCP} root@${MACHINE}:/var/log/dist-upgrade/* ${LOG_DIR}/
 ${SCP} root@${MACHINE}:/var/crash/* ${LOG_DIR}/
 
+virsh destroy $MACHINE
+
 exit $RETCODE

=== added file 'main/install_main/install_all_main.py'
--- main/install_main/install_all_main.py	1970-01-01 00:00:00 +0000
+++ main/install_main/install_all_main.py	2013-08-12 10:37:39 +0000
@@ -0,0 +1,89 @@
+#!/usr/bin/python3
+
+from __future__ import print_function
+
+import apt
+import apt_pkg
+import platform
+
+
+def blacklisted(name):
+    # we need to blacklist linux-image-* as it does not install
+    # cleanly in the chroot (postinst failes)
+    blacklist = ["libkdc2", "libkdc", "libjpeg", "libgpod", "libapache2",
+                 "libgd", "heimdal", "bacula", "grub", "linux-image-",
+                 "ltsp-client", "glibc-doc-reference", "libpthread-dev",
+                 "cman", "mysql-server", "fuse-utils",
+                 "ltspfs", "gfs2-tools", "edubuntu-server",
+                 "gnbd-client", "gnbd-server", "mysql-server-5.0",
+                 "rgmanager", "clvm", "redhat-cluster-suite",
+                 # has a funny "can not be upgraded automatically" policy
+                 # see debian #368226
+                 "quagga",
+                 "system-config-cluster", "gfs-tools"]
+    for b in blacklist:
+        if name.startswith(b):
+            return True
+    return False
+
+
+cache = apt.Cache()
+group = apt_pkg.ActionGroup(cache._depcache)
+
+arch = "i386"
+if platform.machine() == "x86_64":
+    arch = "amd64"
+
+troublemaker = set()
+for pkg in cache:
+    if not pkg.candidate and arch not in pkg.fullname:
+        continue
+    for c in pkg.candidate.origins:
+        if c.component == "main":
+            current = set([p.name for p in cache if p.marked_install])
+            if  (not (pkg.is_installed or blacklisted(pkg.name)) and
+                    arch in pkg.fullname):
+                pkg.mark_install()
+                print("Install candidate: %s" % pkg.name)
+            new = set([p.name for p in cache if p.marked_install])
+            if not (pkg.is_installed or pkg.marked_install):
+                print("Can't install: %s" % pkg.name)
+            if len(current - new) > 0:
+                troublemaker.add(pkg.name)
+                print("Installing '%s'\
+                       caused removals_ %s" % (pkg.name, current - new))
+
+for pkg in ["ubuntu-desktop", "ubuntu-minimal", "ubuntu-standard"]:
+    cache[pkg].mark_install()
+
+# make sure we don't install blacklisted stuff
+for pkg in cache:
+    if blacklisted(pkg.name):
+        pkg.mark_keep()
+
+print("We can install:")
+print(len([pkg.name for pkg in cache if pkg.marked_install]))
+print("Download: ")
+pm = apt_pkg.PackageManager(cache._depcache)
+fetcher = apt_pkg.Acquire()
+pm.get_archives(fetcher, cache._list, cache._records)
+print(apt_pkg.size_to_str(fetcher.fetch_needed))
+print("Total space: ", apt_pkg.size_to_str(cache._depcache.usr_size))
+
+res = False
+current = 0
+maxRetries = 3
+while current < maxRetries:
+    try:
+        res = cache.commit(apt.progress.text.AcquireProgress(),
+                           apt.progress.base.InstallProgress())
+    except IOError as e:
+        # fetch failed, will be retried
+        current += 1
+        print("Retrying to fetch: ", current)
+        continue
+    except SystemError as e:
+        print("Error installing packages! ")
+        print(e)
+    print("Install result: ", res)
+    break

=== modified file 'main/install_main/tc_control'
--- main/install_main/tc_control	2013-05-31 19:55:55 +0000
+++ main/install_main/tc_control	2013-08-12 10:37:39 +0000
@@ -6,5 +6,6 @@
   1. all packages from main are installed
 type: userland
 timeout: 3600 # 10 hours
-command: ./auto-upgrade-testing/share/scripts/install_all_main
-tc_setup: bzr branch lp:auto-upgrade-testing
+command: ./install_all_main.py
+run_as: root
+

=== added directory 'post-upgrade'
=== added file 'post-upgrade/README'
--- post-upgrade/README	1970-01-01 00:00:00 +0000
+++ post-upgrade/README	2013-08-12 10:37:39 +0000
@@ -0,0 +1,8 @@
+The scripts in this folder are run after the upgrade was performed
+and after a reboot. They can test various functionality like
+- is the latest kernel running
+- is the xserver running
+- is python still working
+- are my daemons still running
+
+etc

=== added directory 'post-upgrade/conffiles'
=== added file 'post-upgrade/conffiles/tc_control'
--- post-upgrade/conffiles/tc_control	1970-01-01 00:00:00 +0000
+++ post-upgrade/conffiles/tc_control	2013-08-12 10:37:39 +0000
@@ -0,0 +1,9 @@
+description: Check if there are obsolete conf files left over after upgrade
+dependencies: none
+action: |
+  1. Test if there are obsolete config files left after the upgrade
+expected_results: |
+  1. No obsolete conf files left afte the upgrade
+type: userland
+timeout: 60 # 1 minute
+command: ./test_conffiles.py

=== added file 'post-upgrade/conffiles/test_conffiles.py'
--- post-upgrade/conffiles/test_conffiles.py	1970-01-01 00:00:00 +0000
+++ post-upgrade/conffiles/test_conffiles.py	2013-08-12 10:37:39 +0000
@@ -0,0 +1,77 @@
+#!/usr/bin/python
+#
+# This script checks status of configuration files after upgrade.
+# Current checks are:
+#    - Obsolete config files
+#    - Existence of *.dpkg-dist files. It means there was a prompt for an
+#    unmodified configuration during upgrade
+#
+# (C) 2012 Canonical Ltd.
+# Author: Jean-Baptiste Lallement <[e-mail]>
+# License: GPL v2 or higher
+
+import unittest
+import subprocess
+import glob
+
+class TestConfFiles(unittest.TestCase):
+    def test_obsolete_configfile(self):
+        '''Check for obsolete config files after upgrade'''
+        cmd = ['dpkg-query' ,'-W', '-f=${Package}\n${Conffiles}\n\n']
+        output_file = '/tmp/obsolete_conffiles.log'
+        test_output = ''
+
+        dpkgquery = subprocess.check_output(cmd)
+        current = set()
+        obsolete = {}
+        for pkg in dpkgquery.split('\n\n'):
+            pkg = pkg.strip().split('\n')
+            pkgname = pkg[0]
+            cfgfiles = pkg[1:]
+            for cfgfile in cfgfiles:
+                cfgbits = cfgfile.strip().split()
+                if len(cfgbits) < 3:
+                    # No status, not obsolete
+                    current.add(cfgbits[0])
+                else:
+                    file, md5, status = cfgbits[:3]
+                    if 'obsolete' in status:
+                        obsolete.setdefault(pkgname, []).append(file)
+                    else:
+                        current.add(file)
+
+        for pkgname in sorted(obsolete.keys()):
+            cfgfiles = [cfgfile for cfgfile in obsolete[pkgname]
+                        if cfgfile not in current]
+            if cfgfiles:
+                test_output += "%s\n  %s\n" % (pkgname, "\n  ".join(cfgfiles))
+
+        if test_output:
+            with open(output_file, 'w') as f:
+                print >>f, test_output
+
+    def test_dpkgdist(self):
+        '''Check for existence of *.dpkg-dist files'''
+        whitelist_dpkg = [
+                          '/tmp/sudoers.dpkg-dist',
+                          '/tmp/release-upgrades.dpkg-dist']
+
+        dpkgdist_files = subprocess.check_output(['find', '/etc', '-name', \
+            '*.dpkg-dist']).split('\n')
+        for f in dpkgdist_files:
+            if f.strip():
+                subprocess.check_call(['cp %s /tmp/' % f], shell=True)
+                conffile = f.replace('.dpkg-dist', '')
+                subprocess.check_call(['cp %s /tmp/' % conffile], shell=True)
+
+        saved_dpkgdist_files = glob.glob('/tmp/*.dpkg-dist')
+        saved_dpkgdist_files = [f for f in saved_dpkgdist_files \
+                if f not in whitelist_dpkg]
+
+        self.assertEqual(
+            len(saved_dpkgdist_files), 0,
+            "*.dpkg-dist files found after upgrade:\n  %s" %
+            "\n  ".join(saved_dpkgdist_files))
+
+if __name__ == '__main__':
+    unittest.main()

=== added directory 'post-upgrade/debconf'
=== added file 'post-upgrade/debconf/debconf_test.py'
--- post-upgrade/debconf/debconf_test.py	1970-01-01 00:00:00 +0000
+++ post-upgrade/debconf/debconf_test.py	2013-08-12 10:37:39 +0000
@@ -0,0 +1,68 @@
+#!/usr/bin/python
+"""
+Parse debconf log file and split in a file per prompt
+Exit with status 1 if there is a debconf prompt not in whitelist
+"""
+from __future__ import print_function
+
+import re, os, sys
+
+# Keep this path in sync with the corresponding setting in
+# profile/defaults.cfg.d/defaults.cfg
+DEBCONF_LOG_PATH = '/var/log/dist-upgrade/debconf.log'
+RESULT_DIR = '/tmp'
+
+# Prompts in this list won't generate a test failure
+# i.e WHITELIST = ['libraries/restart-without-asking']
+WHITELIST = [
+    'glibc/restart-services',
+    'libraries/restart-without-asking' ]
+
+def run_test(logfile, resultdir):
+    """ Run the test and slice debconf log
+
+    :param logfile: Path to debconf log
+    :param resultdir: Output directory to write log file to
+    """
+    global WHITELIST
+
+    ret = 0
+    if not os.path.exists(logfile):
+        print('Debconf logfile not present. Whitelist. Skipping!')
+        return ret
+
+    re_dsetting = re.compile('^\w')
+    inprompt = False
+    prompt = dsetting = ""
+
+    with open(logfile, 'r') as f_in:
+        for line in f_in.readlines():
+            # Only keep interesting bits of the prompt
+            if line.startswith('#####'):
+                inprompt = not inprompt
+
+                # Reached the second separator, write content to result file
+                # One per  prompt
+                if not inprompt:
+                    print("Got debconf prompt for '%s'" % dsetting)
+                    if dsetting in WHITELIST:
+                        print('    But it is in Whitelist. Skipping!')
+                        continue
+                    else:
+                        ret = 1
+
+                    with open(os.path.join(
+                        resultdir,
+                        'debconf_%s.log' % dsetting.replace('/', '_')),
+                        'w') as f_out:
+                        f_out.write(prompt)
+
+            if inprompt:
+                prompt += line
+                if re_dsetting.match(line) and '=' in line:
+                    dsetting = line.split('=')[0]
+
+    return ret
+
+if __name__ == '__main__':
+    sys.exit(run_test(DEBCONF_LOG_PATH, RESULT_DIR))

=== added file 'post-upgrade/debconf/tc_control'
--- post-upgrade/debconf/tc_control	1970-01-01 00:00:00 +0000
+++ post-upgrade/debconf/tc_control	2013-08-12 10:37:39 +0000
@@ -0,0 +1,9 @@
+description: Check if there is any unnecessary prompts during upgrade
+dependencies: none
+action: |
+  1. Test there is no unnecessary user prompts during the upgrade
+expected_results: |
+  1. There is no prompts unless user modified the files beforehand.
+type: userland
+timeout: 60 # 1 minute
+command: ./debconf_test.py

=== added directory 'post-upgrade/debsums'
=== added file 'post-upgrade/debsums/debsums_lite.py'
--- post-upgrade/debsums/debsums_lite.py	1970-01-01 00:00:00 +0000
+++ post-upgrade/debsums/debsums_lite.py	2013-08-12 10:37:39 +0000
@@ -0,0 +1,21 @@
+#!/usr/bin/python
+
+from __future__ import print_function
+
+import glob
+import os
+import subprocess
+import sys
+
+basepath = "/var/lib/dpkg/info/*.md5sums"
+ok = True
+for f in glob.glob(basepath):
+    ret = subprocess.call(["md5sum", "--quiet", "-c", 
+                           os.path.join(basepath, f)],
+                          cwd="/")
+    if ret != 0:
+        ok = False
+
+if not ok:
+    print("WARNING: at least one md5sum mismatch")
+    sys.exit(1)

=== added file 'post-upgrade/debsums/tc_control'
--- post-upgrade/debsums/tc_control	1970-01-01 00:00:00 +0000
+++ post-upgrade/debsums/tc_control	2013-08-12 10:37:39 +0000
@@ -0,0 +1,9 @@
+description: Check for package debsum mismatches
+dependencies: none
+action: |
+  1. Check if the md5sums of the installed packages match their debsums
+expected_results: |
+  1. The debsums of the packages match
+type: userland
+timeout: 60 # 1 minute
+command: ./debsums_lite.py

=== added directory 'post-upgrade/kernel'
=== added file 'post-upgrade/kernel/tc_control'
--- post-upgrade/kernel/tc_control	1970-01-01 00:00:00 +0000
+++ post-upgrade/kernel/tc_control	2013-08-12 10:37:39 +0000
@@ -0,0 +1,11 @@
+description: Check if the kernel update was proper during the upgrade
+dependencies: none
+action: |
+  1. Test if the kernel being used after the ugprade and reboot is the latest
+  2. Test if there are at-least two kernels installed (old and new)
+expected_results: |
+  1. The kernel in use is the new kernel that was installed during the upgrade
+  2. At least two kernel versions are in the system
+type: userland
+timeout: 60 # 1 minute
+command: ./test_kernel.py

=== added file 'post-upgrade/kernel/test_kernel.py'
--- post-upgrade/kernel/test_kernel.py	1970-01-01 00:00:00 +0000
+++ post-upgrade/kernel/test_kernel.py	2013-08-12 10:37:39 +0000
@@ -0,0 +1,47 @@
+#!/usr/bin/python
+#
+# This script checks for that at least 2 kernels are installed post-upgrade
+# and that the latest one is active
+#
+# (C) 2012 Canonical Ltd.
+# Author: Jean-Baptiste Lallement <[e-mail]>
+#         Based on the original version from Michael Vogt
+# License: GPL v2 or higher
+
+import unittest
+import apt_pkg
+import glob
+import os
+
+class TestKernel(unittest.TestCase):
+    def setUp(self):
+        apt_pkg.init()
+        self.current_kernelversion = os.uname()[2]
+        self.versions = set()
+        for kernel in glob.glob('/boot/vmlinuz-*'):
+            version = "-".join(kernel.split("-")[1:4])
+            self.versions.add(version)
+
+    def test_kernel_in_use(self):
+        '''Check latest kernel is in use'''
+        if os.path.exists("/run/container_type"):
+            with open("/run/container_type") as fd:
+                container = fd.read().strip()
+            print("Skipping test_kernel_in_use as in a '%s' container." % container)
+            return
+
+        for version in self.versions:
+            self.assertFalse(
+                apt_pkg.version_compare(self.current_kernelversion, version) < 0,
+                "There is a kernel version '%s' installed higher than the running kernel '%s'" %
+                (version, self.current_kernelversion))
+
+    def test_old_kernel_is_installed(self):
+        '''Check that previous kernel is still there after install'''
+        self.assertNotEqual(
+            len(self.versions), 1,
+            "Only one kernel found '%s', expected at least 2 (new + previous)" %
+            self.versions)
+
+if __name__ == '__main__':
+    unittest.main()

=== added directory 'post-upgrade/lts_upgrade_system'
=== added file 'post-upgrade/lts_upgrade_system/tc_control'
--- post-upgrade/lts_upgrade_system/tc_control	1970-01-01 00:00:00 +0000
+++ post-upgrade/lts_upgrade_system/tc_control	2013-08-12 10:37:39 +0000
@@ -0,0 +1,11 @@
+description: Check if system config settings are preserved
+dependencies: none
+action: |
+  1. Check if system wide configuration customisation is preserved
+     for an lts->lts upgrade. Skipped for anything else
+expected_results: |
+  1. System wide configuration customisation is preserved for lts->lts
+     upgrades
+type: userland
+timeout: 60 # 1 minute
+command: ./test_lts_upgrade_system.py

=== added file 'post-upgrade/lts_upgrade_system/test_lts_upgrade_system.py'
--- post-upgrade/lts_upgrade_system/test_lts_upgrade_system.py	1970-01-01 00:00:00 +0000
+++ post-upgrade/lts_upgrade_system/test_lts_upgrade_system.py	2013-08-12 10:37:39 +0000
@@ -0,0 +1,73 @@
+#!/usr/bin/python
+#
+# This script checks system-wide configuration settings after an Ubuntu 10.04
+# LTS to Ubuntu 12.04 LTS upgrade. Run this after upgrading to 12.04 or later.
+# It reads the old gdm settings and ensures that they were appropriately
+# migrated to lightdm and that lightdm is the default DM.
+# It does not need any particular privileges, it is fine to run this as any
+# user.
+#
+# (C) 2012 Canonical Ltd.
+# Author: Martin Pitt <[e-mail]>
+# License: GPL v2 or higher
+
+from __future__ import print_function
+
+import unittest
+import os, sys
+try:
+    import configparser
+    configparser  # pyflakes
+except ImportError:
+    import ConfigParser as configparser
+
+class T(unittest.TestCase):
+    @classmethod
+    def setUpClass(klass):
+        # read gdm configuration
+        klass.gdm_config = klass._read_conf('/etc/gdm/custom.conf', 'daemon')
+        klass.lightdm_config = klass._read_conf('/etc/lightdm/lightdm.conf', 'SeatDefaults')
+
+    def test_lightdm_default_dm(self):
+        '''lightdm is the default display manager'''
+
+        with open('/etc/X11/default-display-manager') as f:
+            default_dm = f.read().strip()
+
+        self.assertTrue(os.access(default_dm, os.X_OK))
+        self.assertEqual(os.path.basename(default_dm), 'lightdm')
+
+    def test_autologin_migration(self):
+        '''autologin migration from gdm to lightdm'''
+
+        if self.gdm_config.get('automaticloginenable', 'false') == 'true':
+            gdm_autologin = self.gdm_config.get('automaticlogin', '')
+        else:
+            gdm_autologin = ''
+
+        self.assertEqual(gdm_autologin, self.lightdm_config.get('autologin-user', ''))
+
+    @classmethod
+    def _read_conf(klass, filename, section):
+        '''Read section from an INI configuration file.
+
+        Return a dictionary with the configuration of the given section.
+        '''
+        p = configparser.ConfigParser()
+        p.read(filename)
+        config = {}
+        try:
+            for (key, value) in p.items(section):
+                config[key] = value
+        except configparser.NoSectionError:
+            # just keep an empty config
+            pass
+        return config
+
+# Only run on lts-ubuntu testcases
+if not os.path.exists('/upgrade-tester/prepare_lts_desktop'):
+    print("Not an Ubuntu Desktop LTS upgrade. Skipping!")
+    sys.exit(0)
+
+if __name__ == '__main__':
+    unittest.main()

=== added directory 'post-upgrade/lts_upgrade_user'
=== added file 'post-upgrade/lts_upgrade_user/tc_control'
--- post-upgrade/lts_upgrade_user/tc_control	1970-01-01 00:00:00 +0000
+++ post-upgrade/lts_upgrade_user/tc_control	2013-08-12 10:37:39 +0000
@@ -0,0 +1,10 @@
+description: Check if user config settings are preserved for lts upgrade
+dependencies: none
+action: |
+  1. Check if the user config settings are preserved
+     after an lts->lts upgrade. Skipped for anything else
+expected_results: |
+  1. User config settings are preserved for an lts->lts upgrade
+type: userland
+timeout: 60 # 1 minute
+command: ./test_lts_upgrade_user.py

=== added file 'post-upgrade/lts_upgrade_user/test_lts_upgrade_user.py'
--- post-upgrade/lts_upgrade_user/test_lts_upgrade_user.py	1970-01-01 00:00:00 +0000
+++ post-upgrade/lts_upgrade_user/test_lts_upgrade_user.py	2013-08-12 10:37:39 +0000
@@ -0,0 +1,107 @@
+#!/usr/bin/python
+#
+# This script checks user configuration settings after an Ubuntu 10.04
+# LTS to Ubuntu 12.04 LTS upgrade. Run prepare_lts_upgrade_user.sh in 10.04
+# LTS, then upgrade to 12.04 LTS (or later), and run this script to confirm
+# that settings were migrated properly. In particular this checks for gconf ->
+# gsettings migration (and sometimes changing the format of the values) for
+# popular settings, as well as custom panel/desktop launchers.
+#
+# You need to run both the prepare and this test script as the same user,
+# in a full desktop session.
+#
+# (C) 2012 Canonical Ltd.
+# Author: Martin Pitt <[e-mail]>
+# License: GPL v2 or higher
+
+from __future__ import print_function
+
+import unittest
+import os, sys
+import subprocess
+from time import sleep
+
+try:
+    from gi.repository import Gio
+except:
+    # Not a desktop
+    print("Failed to import gi.repository. Not a LTS Desktop Upgrade. Skipping!")
+    sys.exit(0)
+
+class T(unittest.TestCase):
+    def test_background(self):
+        '''background image'''
+
+        bg_settings = Gio.Settings('org.gnome.desktop.background')
+        # note: original gconf value does not have a file:// prefix, but GNOME
+        # 3.x requires this prefix
+        self.assertEqual(bg_settings.get_string('picture-uri'),
+                         'file://%s/mybackground.jpg' % os.environ['HOME'])
+
+#   Theme is not preserved on upgrade. LP: #969569
+#   Test disabled
+#    def test_gtk_theme(self):
+#        '''GTK theme'''
+#
+#        iface_settings = Gio.Settings('org.gnome.desktop.interface')
+#        self.assertEqual(iface_settings.get_string('gtk-theme'), 'Radiance')
+
+    def test_custom_launchers(self):
+        '''Custom panel/desktop launchers appear in Unity launcher'''
+
+        launcher_settings = Gio.Settings('com.canonical.Unity.Launcher')
+        favorites = launcher_settings['favorites']
+
+        # gedit was dragged from Application menu to panel, pointing to system
+        # .desktop file
+        self.assertTrue('gedit.desktop' in favorites)
+
+        # custom "echo hello" panel starter uses its own .desktop file
+        for starter in favorites:
+            if 'echo' in starter:
+                self.assertTrue(os.path.exists(starter))
+                break
+        else:
+            self.fail('custom hello starter not found')
+
+        # gucharmap was dragged from Application menu to desktop, should be
+        # converted to system .desktop file
+        self.assertTrue('gucharmap.desktop' in favorites)
+
+        # custom "bc -l" desktop starter uses its own .desktop file
+        self.assertTrue('%s/Desktop/termcalc.desktop' % os.environ['HOME'] in favorites)
+
+    def test_keyboard_layouts(self):
+        '''Custom keyboard layouts are migrated and applied'''
+
+        # verify gconf->gsettings migration
+        kbd_settings = Gio.Settings('org.gnome.libgnomekbd.keyboard')
+        self.assertEqual(kbd_settings['layouts'],
+                ['us','de\tnodeadkeys','gb','gb\tdvorak'])
+
+# NO DISPLAY IN AUTOMATED TEST
+#        # verify that they get applied to the X server correctly
+#        xprop = subprocess.Popen(['xprop', '-root', '_XKB_RULES_NAMES'],
+#                stdout=subprocess.PIPE, universal_newlines=True)
+#        out = xprop.communicate()[0]
+#        self.assertEqual(xprop.returncode, 0)
+#
+#        # chop off key name
+#        out = out.split('=', 1)[1].strip()
+#
+#        self.assertEqual(out, '"evdev", "pc105", "us,de,gb,gb", ",nodeadkeys,,dvorak", "grp:alts_toggle"')
+
+# Only run on lts-ubuntu testcases
+if not os.path.exists('/upgrade-tester/prepare_lts_desktop'):
+    print("Not an Ubuntu Desktop LTS upgrade. Skipping!")
+    sys.exit(0)
+
+if os.getuid() == 0:
+    # Root ? reexecute itself as user ubuntu
+    ret = subprocess.call('sudo -H -u ubuntu dbus-launch %s' %
+                          os.path.abspath(__file__), shell=True)
+    sys.exit(ret)
+else:
+    # Give 1 minute for the session to start, convert, ...
+    sleep(60)
+    unittest.main()

=== added directory 'post-upgrade/python_import'
=== added file 'post-upgrade/python_import/tc_control'
--- post-upgrade/python_import/tc_control	1970-01-01 00:00:00 +0000
+++ post-upgrade/python_import/tc_control	2013-08-12 10:37:39 +0000
@@ -0,0 +1,10 @@
+description: Check if python modules are importable
+dependencies: none
+action: |
+  1. Attempt to import the py modules listed under dist-packages
+     of the default version
+expected_results: |
+  1. The modules present in dist-packages are importable
+type: userland
+timeout: 60 # 1 minute
+command: ./test_python_import.py

=== added file 'post-upgrade/python_import/test_python_import.py'
--- post-upgrade/python_import/test_python_import.py	1970-01-01 00:00:00 +0000
+++ post-upgrade/python_import/test_python_import.py	2013-08-12 10:37:39 +0000
@@ -0,0 +1,131 @@
+#!/usr/bin/python
+#
+# This script checks python. Current tests:
+#   - import python modules available on the systen
+#
+# (C) 2012 Canonical Ltd.
+# Author: Jean-Baptiste Lallement <[e-mail]>
+#         Based on original version from Michael Vogt
+# License: GPL v2 or higher
+
+import unittest
+import ConfigParser
+import os
+import logging
+import subprocess
+
+logging.basicConfig(
+    filename='/tmp/%s.log' % os.path.basename(__file__)[:-3],
+    filemode='w',
+    level=logging.DEBUG)
+
+# stuff that we know does not work when doing a simple "import"
+BLACKLIST = ["speechd_config",
+             "PAMmodule.so",
+             "aomodule.so",
+             "plannerui.so",
+             "desktopcouch", # needs a KeyringDaemon
+             "ropemacs", # just hangs
+             "keyring", # needs X
+             "invest",
+             "Onboard",
+             "goocanvasmodule.so",
+             ]
+
+# If you want to test modules that require a display you'll have to install
+# xvfb in the base image
+XVFB_BIN='/usr/bin/xvfb-run'
+XVFB_OPT=[]
+
+def py_module_filter(pymodule):
+    return not (
+        pymodule.endswith(".egg-info") or
+        pymodule.endswith(".pth") or
+        pymodule.startswith("_") or
+        pymodule.endswith(".pyc") or
+        pymodule.endswith("_d.so") or
+        pymodule in BLACKLIST
+    )
+
+def get_module_from_path(path):
+    f = os.path.basename(path)
+    if path and os.path.exists(os.path.join(path, "__init__.py")):
+        return f
+    elif f.endswith(".py"):
+        return f.split(".")[0]
+    # swig uses this, calls it "foomodule.so" but the import is "foo"
+    # (eg xdelta3module.so, pqueuemodule.so)
+    elif f.endswith("module.so"):
+        return f.split("modules.so")[0]
+    elif f.endswith(".so"):
+        return f.split(".")[0]
+
+class TestPython(unittest.TestCase):
+    # total imports
+    total = 0
+    failed = []
+
+    def _try_import(self, path):
+        '''Try to import a module from a path
+
+        a simple __import__(module) does not work, the problem
+        is that module import have funny side-effects (like
+        "import uno; import pyatspi" will fail, but importing
+        them individually is fine
+        '''
+        logging.info('Importing %s', path)
+        module = get_module_from_path(path)
+        rc = True
+        if not module:
+            logging.warn("could not get module for '%s'" % path)
+            return rc
+
+        try:
+            cmd = ["python", "-c","import %s" % module]
+            self.total += 1
+            subprocess.check_call(cmd, stderr = self.stderr)
+        except subprocess.CalledProcessError:
+            try:
+                pkg = subprocess.check_output(["dpkg", "-S", os.path.realpath(path)])
+                self.failed.append((module, pkg.strip()))
+                logging.error('Import failed. Package providing this module: %s', pkg)
+            except subprocess.CalledProcessError:
+                logging.error("Import of %s failed, and no package ships this module.", path)
+            rc = False
+        return rc
+
+    def setUp(self):
+        # Read default python version installed on the system
+        config = ConfigParser.SafeConfigParser()
+        config.read('/usr/share/python/debian_defaults')
+        self.default_version = config.get('DEFAULT', 'default-version')
+        self.distpackages = '/usr/lib/%s/dist-packages/' % self.default_version
+        self.stderr = open('/tmp/%s.stderr' % os.path.basename(__file__)[:-3],'w')
+
+    def tearDown(self):
+        self.stderr.close()
+
+    def test_python_import(self):
+        '''Import python modules from /usr/lib/PYTHONVER/dist-packages/'''
+        res = True
+
+        for module in filter(py_module_filter, os.listdir(self.distpackages)):
+            res &= self._try_import(os.path.join(self.distpackages, module))
+
+        logging.info('Modules imported: %d', self.total)
+        if res:
+            logging.info('No failure')
+
+        self.assertTrue(res, '%d module(s) failed to import' % len(self.failed))
+
+if __name__ == '__main__':
+    if 'DISPLAY' in os.environ:
+        unittest.main()
+    elif os.path.exists(XVFB_BIN):
+        logging.info("'%s' found and DISPLAY not set. Re-executing myself with xvfb")
+        cmd = [ XVFB_BIN ] + XVFB_OPT + [os.path.abspath(__file__)]
+        logging.info(cmd)
+        subprocess.call(cmd)
+    else:
+        logging.warning("'%s' not found and DISPLAY not set. Executing test without a display", XVFB_BIN)
+        unittest.main()

=== added file 'post-upgrade/tslist.run'
--- post-upgrade/tslist.run	1970-01-01 00:00:00 +0000
+++ post-upgrade/tslist.run	2013-08-12 10:37:39 +0000
@@ -0,0 +1,7 @@
+- test: conffiles
+- test: debconf
+- test: kernel
+- test: lts_upgrade_system
+- test: lts_upgrade_user
+- test: python_import
+- test: xserver

=== added directory 'post-upgrade/xserver'
=== added file 'post-upgrade/xserver/tc_control'
--- post-upgrade/xserver/tc_control	1970-01-01 00:00:00 +0000
+++ post-upgrade/xserver/tc_control	2013-08-12 10:37:39 +0000
@@ -0,0 +1,9 @@
+description: Checking for Xorg after upgrade
+dependencies: none
+action: |
+  1. Check if Xorg is running for desktop upgrades. Skip the test for others
+expected_results: |
+  1. For desktop upgrades Xorg is running 
+type: userland
+timeout: 60 # 1 minute
+command: ./test_xserver.py

=== added file 'post-upgrade/xserver/test_xserver.py'
--- post-upgrade/xserver/test_xserver.py	1970-01-01 00:00:00 +0000
+++ post-upgrade/xserver/test_xserver.py	2013-08-12 10:37:39 +0000
@@ -0,0 +1,48 @@
+#!/usr/bin/python
+#
+# This script checks that xserver is running
+#
+# (C) 2012 Canonical Ltd.
+# Author: Jean-Baptiste Lallement <[e-mail]>
+#         Based on the original version from Michael Vogt
+# License: GPL v2 or higher
+
+import unittest
+import subprocess
+from time import sleep
+
+def is_process_running(procname):
+    '''Check if a process is running'''
+    proclist = subprocess.Popen(["ps","-eo","comm"], stdout=subprocess.PIPE,
+                                universal_newlines=True).communicate()[0]
+    for line in proclist.split("\n"):
+        if line == procname:
+            return True
+    return False
+
+def is_desktop_install():
+    '''Check that at least an *ubuntu-desktop package is installed'''
+    cmd = ['dpkg-query', '-Wf', '${Status}\n', '*ubuntu-desktop']
+    try:
+        output = subprocess.check_output(cmd).split('\n')
+    except:
+        return False
+
+    for line in output:
+        if line.startswith('install'):
+            return True
+    return False
+
+class TestXserver(unittest.TestCase):
+    @unittest.skipIf(not is_desktop_install(), 'Not a desktop installation.')
+    def test_xserver_running(self):
+        '''Checking for running Xorg'''
+        count = 0
+        while not is_process_running('Xorg') and count<10:
+            count += 1
+            sleep(10)
+
+        self.assertTrue(is_process_running('Xorg'), 'X Server not running')
+
+if __name__ == '__main__':
+    unittest.main()

=== modified file 'upgrade.run'
--- upgrade.run	2013-05-30 21:11:38 +0000
+++ upgrade.run	2013-08-12 10:37:39 +0000
@@ -3,3 +3,7 @@
   - name: upgrade
     fetch_method: bzr-export
     fetch_location: lp:~utah/utah/jenkins-upgradetest-setup/upgrade
+
+  - name: post-upgrade
+    fetch_method: bzr-export
+    fetch_location: lp:~utah/utah/jenkins-upgradetest-setup/post-upgrade