Merge lp:~kyrofa/unity-scope-snappy/integration-tests_package-management into lp:~unity-api-team/unity-scope-snappy/trunk

[Kyle Fazzari]

Add integration tests for package management tasks.

Add integration tests for package management tasks.

This is the final MP for the store scope integration tests.

[Kyle Fazzari (kyrofa)]

Alright Xavi, this one is actually ready for review now as well.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:29
http://jenkins.qa.ubuntu.com/job/unity-scope-snappy-ci/121/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scope-snappy-wily-amd64-ci/77/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scope-snappy-wily-armhf-ci/75/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-scope-snappy-wily-i386-ci/75/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-scope-snappy-ci/121/rebuild

review: Needs Fixing (continuous-integration)

[Charles Kerr (charlesk)]

No complaints here. Nice to see the progress hacks start falling away, and also the incidental copyediting (e.g. improved test error messages)

review: Approve

=== modified file 'debian/control'
--- debian/control	2015-07-20 15:27:32 +0000
+++ debian/control	2015-07-20 15:27:32 +0000
@@ -12,6 +12,7 @@
                pkg-config,
                python3,
                python3-fixtures,
+               python3-requests,
                python3-scope-harness,
 Standards-Version: 3.9.6
 Homepage: https://launchpad.net/unity-scope-snappy

=== modified file 'package-management-daemon/daemon/webdm_package_manager.go'
--- package-management-daemon/daemon/webdm_package_manager.go	2015-06-23 12:12:02 +0000
+++ package-management-daemon/daemon/webdm_package_manager.go	2015-07-20 15:27:32 +0000
@@ -82,7 +82,7 @@
 	err := manager.packageManager.Install(packageId)
 	if err != nil {
 		return "", dbus.NewError("org.freedesktop.DBus.Error.Failed",
-			[]interface{}{fmt.Sprintf(`Unable to install package "%d": %s`, packageId, err)})
+			[]interface{}{fmt.Sprintf(`Unable to install package "%s": %s`, packageId, err)})
 	}
 
 	operationId := manager.newOperationId()
@@ -106,7 +106,7 @@
 	err := manager.packageManager.Uninstall(packageId)
 	if err != nil {
 		return "", dbus.NewError("org.freedesktop.DBus.Error.Failed",
-			[]interface{}{fmt.Sprintf(`Unable to uninstall package "%d": %s`, packageId, err)})
+			[]interface{}{fmt.Sprintf(`Unable to uninstall package "%s": %s`, packageId, err)})
 	}
 
 	operationId := manager.newOperationId()

=== modified file 'test/fakes/fake_webdm_server.py'
--- test/fakes/fake_webdm_server.py	2015-07-06 19:26:07 +0000
+++ test/fakes/fake_webdm_server.py	2015-07-20 15:27:32 +0000
@@ -1,33 +1,31 @@
 import http.server
+import multiprocessing
 import urllib
 import json
 
+# Local imports
+from .package import Package
+
+PACKAGE_LIST_PATH = "/api/v2/packages/"
+
+def finishOperation(status):
+	if status == "installing":
+		return "installed"
+	elif status == "uninstalling":
+		return "uninstalled"
+
+	return status
+
+def undoOperation(status):
+	if status == "installing":
+		return "uninstalled"
+	elif status == "uninstalling":
+		return "installed"
+
+	return status
+
 class FakeWebdmServerHandler(http.server.BaseHTTPRequestHandler):
-	_PACKAGE_LIST_PATH = "/api/v2/packages/"
-
-	_PACKAGE1 = {
-		"id": "package1.canonical",
-		"name": "package1",
-		"vendor": "Canonical",
-		"version": "0.1",
-		"description": "description1",
-		"icon": "http://icon1",
-		"type": "app",
-		"status": "installed",
-		"installed_size": 123456
-	}
-
-	_PACKAGE2 = {
-		"id": "package2.canonical",
-		"name": "package2",
-		"vendor": "Canonical",
-		"version": "0.2",
-		"description": "description2",
-		"icon": "http://icon2",
-		"type": "app",
-		"status": "uninstalled",
-		"download_size": 123456
-	}
+	_PROGRESS_STEP = 50
 
 	def sendJson(self, code, json):
 		self.send_response(code)
@@ -35,6 +33,36 @@
 		self.end_headers()
 		self.wfile.write(json.encode())
 
+	def sendPackages(self, packages):
+		jsonArray = []
+		for package in packages:
+			jsonArray.append(package.__dict__)
+
+		self.sendJson(200, json.dumps(jsonArray))
+
+	def findPackage(self, packageId):
+		for index, package in enumerate(self.server.PACKAGES):
+			if package.id == packageId:
+				return (package, index)
+
+		return (None, None)
+
+	def continueOperation(self, package):
+		if package.progress >= 100:
+			if package.status == "installing":
+				package.installed_size = package.download_size
+				package.download_size = 0
+			elif package.status == "uninstalling":
+				package.download_size = package.installed_size
+				package.installed_size = 0
+
+			package.status = finishOperation(package.status)
+			package.progress = 0
+		else:
+			package.progress += self._PROGRESS_STEP
+
+		return package
+
 	def do_GET(self):
 		parsedPath = urllib.parse.urlparse(self.path)
 		query = urllib.parse.parse_qs(parsedPath.query)
@@ -43,27 +71,107 @@
 		if "installed_only" in query and query["installed_only"][0] == "true":
 			installedOnly = True
 
-		if parsedPath.path.startswith(self._PACKAGE_LIST_PATH):
-			packageId = parsedPath.path[len(self._PACKAGE_LIST_PATH):]
+		if parsedPath.path.startswith(PACKAGE_LIST_PATH):
+			packageId = parsedPath.path[len(PACKAGE_LIST_PATH):]
 
 			# If no package ID was provided, list packages instead
 			if len(packageId) == 0:
+				packages = self.server.PACKAGES
+
 				if installedOnly:
-					self.sendJson(200, json.dumps([self._PACKAGE1]))
-				else:
-					self.sendJson(200, json.dumps([self._PACKAGE1, self._PACKAGE2]))
-			else:
-				if packageId == "package1.canonical":
-					self.sendJson(200, json.dumps(self._PACKAGE1))
-				elif packageId == "package2.canonical" and not installedOnly:
-					self.sendJson(200, json.dumps(self._PACKAGE2))
-				else:
-					self.send_error(404, "snappy package not found {}\n".format(packageId))
+					packages = []
+					for package in self.server.PACKAGES:
+						if package.status == "installed":
+							packages.append(package)
+
+				self.sendPackages(packages)
+			else:
+				package, index = self.findPackage(packageId)
+				if package != None:
+					if (package.status == "installing" or
+					    package.status == "uninstalling"):
+						package = self.continueOperation(package)
+						self.server.PACKAGES[index] = package
+
+					if not installedOnly or (package.status == "installed"):
+							self.sendJson(200, json.dumps(package.__dict__))
+							return
+
+				self.send_error(404, "snappy package not found {}\n".format(packageId))
+
+			return
+
+		raise NotImplementedError(self.path)
+
+	def do_PUT(self):
+		parsedPath = urllib.parse.urlparse(self.path)
+		query = urllib.parse.parse_qs(parsedPath.query)
+
+		if parsedPath.path.startswith(PACKAGE_LIST_PATH):
+			packageId = parsedPath.path[len(PACKAGE_LIST_PATH):]
+
+			if len(packageId) > 0:
+				package, index = self.findPackage(packageId)
+
+				if package != None and not self.server.ignoreRequests:
+					package.status = "installing"
+					self.server.PACKAGES[index] = package
+
+				self.sendJson(202, json.dumps("Accepted"))
+			else:
+				self.send_error(500, "PUT here makes no sense")
+
+			return
+
+		raise NotImplementedError(self.path)
+
+	def do_DELETE(self):
+		parsedPath = urllib.parse.urlparse(self.path)
+		query = urllib.parse.parse_qs(parsedPath.query)
+
+		if parsedPath.path.startswith(PACKAGE_LIST_PATH):
+			packageId = parsedPath.path[len(PACKAGE_LIST_PATH):]
+
+			if len(packageId) > 0:
+				package, index = self.findPackage(packageId)
+				if package != None and not self.server.ignoreRequests:
+					package.status = "uninstalling"
+					self.server.PACKAGES[index] = package
+
+				self.sendJson(202, json.dumps("Accepted"))
+			else:
+				self.send_error(500, "DELETE here makes no sense")
 
 			return
 
 		raise NotImplementedError(self.path)
 
 class FakeWebdmServer(http.server.HTTPServer):
-	def __init__(self, address):
+	def __init__(self, address, ignoreRequests=False):
+		self.ignoreRequests = ignoreRequests
+
+		self.PACKAGES = []
+		self.PACKAGES.append(Package(
+				id = "package1.canonical",
+				name = "package1",
+				vendor = "Canonical",
+				version = "0.1",
+				description = "description1",
+				icon = "http://icon1",
+				type = "app",
+				status = "installed",
+				installed_size = 123456
+		))
+		self.PACKAGES.append(Package(
+				id = "package2.canonical",
+				name = "package2",
+				vendor = "Canonical",
+				version = "0.2",
+				description = "description2",
+				icon = "http://icon2",
+				type = "app",
+				status = "uninstalled",
+				download_size = 123456
+		))
+
 		super().__init__(address, FakeWebdmServerHandler)

=== added file 'test/fakes/package.py'
--- test/fakes/package.py	1970-01-01 00:00:00 +0000
+++ test/fakes/package.py	2015-07-20 15:27:32 +0000
@@ -0,0 +1,13 @@
+class Package:
+	def __init__(self, id="", name="", vendor="", version="", description="", icon="", type="", status="", installed_size=0, download_size=0, progress=0):
+		self.id = id
+		self.name = name
+		self.vendor = vendor
+		self.version = version
+		self.description = description
+		self.icon = icon
+		self.type = type
+		self.status = status
+		self.installed_size = installed_size
+		self.download_size = download_size
+		self.progress = progress

=== added file 'test/fakes/test_fake_webdm_server.py'
--- test/fakes/test_fake_webdm_server.py	1970-01-01 00:00:00 +0000
+++ test/fakes/test_fake_webdm_server.py	2015-07-20 15:27:32 +0000
@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+
+import testtools
+import fixtures
+import json
+import requests
+
+# Local imports
+import test.fakes.fake_webdm_server as fake
+from test.test_fixtures import ServerFixture
+
+class TestFakeWebdmServer(testtools.TestCase, fixtures.TestWithFixtures):
+	"""Test fake WebDM server to verify that it works as expected."""
+
+	def setUp(self):
+		"""Setup the test fixtures and run the store scope using the harness.
+		"""
+
+		super().setUp()
+
+		server = ServerFixture(fake.FakeWebdmServer)
+		self.useFixture(server)
+		self.url = server.url[:-1]
+
+	def testListStorePackages(self):
+		"""Test the package list API."""
+
+		response = requests.get(self.url + fake.PACKAGE_LIST_PATH)
+		results = response.json()
+
+		self.assertEqual(len(results), 2,
+		                 "There should only be two packages")
+
+		# Order is not enforced on the list, so we need to check it this
+		# way.
+		package1Found = False
+		package2Found = False
+		for package in results:
+			if package["id"] == "package1.canonical":
+				package1Found = True
+			elif package["id"] == "package2.canonical":
+				package2Found = True
+			else:
+				self.fail("Unexpected package: {}".format(package["id"]))
+
+		if not package1Found:
+			self.fail("Expected package with ID: \"package1.canonical\"")
+
+		if not package2Found:
+			self.fail("Expected package with ID: \"package2.canonical\"")
+
+	def testListInstalledPackages(self):
+		"""Test the package list API with a filter for installed packages."""
+
+		response = requests.get(self.url + fake.PACKAGE_LIST_PATH,
+		                        params={"installed_only": "true"})
+		results = response.json()
+
+		self.assertEqual(len(results), 1,
+		                 "There should be a single result")
+
+		self.assertEqual(results[0]["id"], "package1.canonical",
+		                 "Expected the installed package to be package1")
+
+	def testQueryInstalled(self):
+		"""Test the query API with an installed package."""
+
+		response = requests.get(self.url + fake.PACKAGE_LIST_PATH +
+		                        "package1.canonical")
+		result = response.json()
+		self.assertEqual(result["id"], "package1.canonical")
+
+	def testQueryNotInstalled(self):
+		"""Test the query API with a package that is not installed."""
+
+		response = requests.get(self.url + fake.PACKAGE_LIST_PATH +
+		                        "package2.canonical")
+		result = response.json()
+		self.assertEqual(result["id"], "package2.canonical")
+
+	def testQueryInstalledAndInstalledOnly(self):
+		"""Test the query API with a filter for installed packages.
+
+		Test with an installed package.
+		"""
+
+		response = requests.get(self.url + fake.PACKAGE_LIST_PATH +
+		                        "package1.canonical",
+		                         params={"installed_only": "true"})
+		result = response.json()
+		self.assertEqual(result["id"], "package1.canonical")
+
+	def testQueryNotInstalledAndInstalledOnly(self):
+		"""Test the query API with a filter for installed packages.
+
+		Test with a package that is not installed.
+		"""
+
+		response = requests.get(self.url + fake.PACKAGE_LIST_PATH +
+		                        "package2.canonical",
+		                         params={"installed_only": "true"})
+		self.assertEqual(response.status_code, 404,
+		                 "Requesting \"package2\" while also limiting the search to installed packages should result in not found")
+
+	def testPackageInstallation(self):
+		"""Test the install API."""
+
+		self.installPackage("package2.canonical")
+
+	def testPackageUninstallation(self):
+		"""Test the uninstall API."""
+
+		self.uninstallPackage("package1.canonical")
+
+	def testPackageInstallUninstallReinstall(self):
+		"""Test a package install/uninstall/reinstall flow."""
+
+		# Install package.
+		self.installPackage("package2.canonical")
+
+		# Now uninstall the package.
+		self.uninstallPackage("package2.canonical")
+
+		# Finally, reinstall the package.
+		self.installPackage("package2.canonical")
+
+	def installPackage(self, packageId):
+		"""Install a package via the install API, making sure it succeeds.
+		"""
+
+		response = requests.put(self.url + fake.PACKAGE_LIST_PATH + packageId)
+		self.assertEqual(response.status_code, 202)
+
+		progress = 0
+		status = ""
+		while True:
+			response = requests.get(self.url + fake.PACKAGE_LIST_PATH +
+			                        packageId)
+			result = response.json()
+			if result["status"] == "installed":
+				break
+
+			newProgress = result["progress"]
+
+			if newProgress <= progress:
+				self.fail("Progress was {}, but last call it was {}. It should be increasing with each call".format(newProgress, progress))
+
+			progress = newProgress
+
+	def uninstallPackage(self, packageId):
+		"""Uninstall a package via the uninstall API, making sure it succeeds.
+		"""
+
+		response = requests.delete(self.url + fake.PACKAGE_LIST_PATH +
+		                        packageId)
+		self.assertEqual(response.status_code, 202)
+
+		progress = 0
+		status = ""
+		while True:
+			response = requests.get(self.url + fake.PACKAGE_LIST_PATH +
+			                        packageId)
+			result = response.json()
+			if result["status"] == "uninstalled":
+				break
+
+			newProgress = result["progress"]
+
+			if newProgress <= progress:
+				self.fail("Progress was {}, but last call it was {}. It should be increasing with each call".format(newProgress, progress))
+
+			progress = newProgress

=== modified file 'test/store/package_management_tasks.py'
--- test/store/package_management_tasks.py	2015-07-20 15:27:32 +0000
+++ test/store/package_management_tasks.py	2015-07-20 15:27:32 +0000
@@ -1,10 +1,95 @@
 #!/usr/bin/env python3
 
 from scope_harness import (ScopeHarness,
+                           Parameters,
+                           PreviewView,
                            PreviewColumnMatcher,
                            PreviewMatcher,
                            PreviewWidgetMatcher)
 
+def installPackage(test, categoryId, packageId):
+	"""Install a package via the scope.
+
+	This involves communicating with the DBus daemon, which will begin
+	the package installation and report progress back.
+	"""
+
+	test.view.browse_department("")
+
+	# Go to the preview of the package.
+	preview = test.view.category(categoryId).result("snappy:"+packageId).tap()
+	test.assertIsInstance(preview, PreviewView)
+
+	# Begin the installation.
+	widgetFound = False
+	for columnWidgets in preview.widgets:
+		for widget in columnWidgets:
+			if widget.type == "actions":
+				preview = widget.trigger("install", "")
+				widgetFound = True
+
+	test.assertTrue(widgetFound, "Expected preview to include Install action.")
+
+	return preview
+
+def uninstallPackage(test, categoryId, packageId):
+	"""Uninstall a package via the scope.
+
+	This involves communicating with the DBus daemon, which will begin
+	the package uninstallation and report progress back.
+	"""
+
+	test.view.browse_department("")
+
+	# Go to the preview of the package.
+	preview = test.view.category(categoryId).result("snappy:"+packageId).tap()
+	test.assertIsInstance(preview, PreviewView)
+
+	# Request the uninstallation (it will need to be confirmed)
+	widgetFound = False
+	for columnWidgets in preview.widgets:
+		for widget in columnWidgets:
+			if widget.type == "actions":
+				preview = widget.trigger("uninstall", "")
+				widgetFound = True
+
+	test.assertTrue(widgetFound,
+	                "Expected preview to include Uninstall action.")
+
+	return preview
+
+def confirmUninstallPackage(test, preview):
+	"""Confirm uninstallation request."""
+
+	# Begin the uninstallation.
+	widgetFound = False
+	for columnWidgets in preview.widgets:
+		for widget in columnWidgets:
+			if widget.type == "actions":
+				preview = widget.trigger("uninstall_confirm", "")
+				widgetFound = True
+
+	test.assertTrue(widgetFound,
+	                "Expected preview to include Uninstall action.")
+
+	return preview
+
+def cancelUninstallPackage(test, preview):
+	"""Cancel uninstallation request."""
+
+	# Cancel the uninstallation.
+	widgetFound = False
+	for columnWidgets in preview.widgets:
+		for widget in columnWidgets:
+			if widget.type == "actions":
+				preview = widget.trigger("uninstall_cancel", "")
+				widgetFound = True
+
+	test.assertTrue(widgetFound, "Expected preview to include Cancel action.")
+
+	return preview
+
+
 def verifyInstalledPreview(test, preview, title, subtitle, mascot,
                            description, version, size):
 	"""Verify the preview for an installed package."""
@@ -52,6 +137,47 @@
 				})))
 		.match(preview.widgets))
 
+def verifyInstallingPreview(test, preview, title, subtitle, mascot,
+                            description, version, size, operationNumber=1):
+	"""Verify the preview for an installing package."""
+
+	test.assertMatchResult(PreviewColumnMatcher()
+		.column(PreviewMatcher()
+			.widget(PreviewWidgetMatcher("header")
+				.type("header")
+				.data({
+					"title": title,
+					"subtitle": subtitle,
+					"mascot": mascot,
+					"attributes": [
+						{"value": "FREE"}
+					]
+				}))
+			.widget(PreviewWidgetMatcher("install")
+				.type("progress")
+				.data({
+					"source": {
+						"dbus-name": "com.canonical.applications.WebdmPackageManager",
+						"dbus-object": "/com/canonical/applications/WebdmPackageManager/operation/{}".format(operationNumber)
+					}
+				}))
+			.widget(PreviewWidgetMatcher("summary")
+				.type("text")
+				.data({
+					"title": "Info",
+					"text": description
+				}))
+			.widget(PreviewWidgetMatcher("updates_table")
+				.type("table")
+				.data({
+					"title": "Updates",
+					"values": [
+						["Version number", version],
+						["Size", size]
+					]
+				})))
+		.match(preview.widgets))
+
 def verifyStorePreview(test, preview, title, subtitle, mascot,
                        description, version, size):
 	"""Verify the preview for an in-store package (i.e. not installed)."""
@@ -94,3 +220,70 @@
 					]
 				})))
 		.match(preview.widgets))
+
+def verifyUninstallingPreview(test, preview, title, subtitle, mascot,
+                           description, version, size, operationNumber=1):
+	"""Verify the preview for an uninstalling package."""
+
+	test.assertMatchResult(PreviewColumnMatcher()
+		.column(PreviewMatcher()
+			.widget(PreviewWidgetMatcher("header")
+				.type("header")
+				.data({
+					"title": title,
+					"subtitle": subtitle,
+					"mascot": mascot,
+					"attributes": [
+						{"value": "✓ Installed"}
+					]
+				}))
+			.widget(PreviewWidgetMatcher("uninstall")
+				.type("progress")
+				.data({
+					"source": {
+						"dbus-name": "com.canonical.applications.WebdmPackageManager",
+						"dbus-object": "/com/canonical/applications/WebdmPackageManager/operation/{}".format(operationNumber)
+					}
+				}))
+			.widget(PreviewWidgetMatcher("summary")
+				.type("text")
+				.data({
+					"title": "Info",
+					"text": description
+				}))
+			.widget(PreviewWidgetMatcher("updates_table")
+				.type("table")
+				.data({
+					"title": "Updates",
+					"values": [
+						["Version number", version],
+						["Size", size]
+					]
+				})))
+		.match(preview.widgets))
+
+def verifyConfirmUninstallPreview(test, preview, name):
+	"""Verify the preview to confirm request to uninstall a package."""
+
+	test.assertMatchResult(PreviewColumnMatcher()
+		.column(PreviewMatcher()
+			.widget(PreviewWidgetMatcher("confirm")
+				.type("text")
+				.data({
+					"text": "Are you sure you want to uninstall {}?".format(name)
+				}))
+			.widget(PreviewWidgetMatcher("confirmation")
+				.type("actions")
+				.data({
+					"actions": [
+						{
+							"id": "uninstall_confirm",
+							"label": "Uninstall"
+						},
+						{
+							"id": "uninstall_cancel",
+							"label": "Cancel"
+						}
+					]
+				})))
+		.match(preview.widgets))

=== added file 'test/store/test_package_management.py'
--- test/store/test_package_management.py	1970-01-01 00:00:00 +0000
+++ test/store/test_package_management.py	2015-07-20 15:27:32 +0000
@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import subprocess
+import unittest
+import fixtures
+
+from scope_harness.testing import ScopeHarnessTestCase
+from scope_harness import (ScopeHarness,
+                           Parameters,
+                           PreviewView,
+                           PreviewColumnMatcher,
+                           PreviewMatcher,
+                           PreviewWidgetMatcher)
+
+# Local imports
+from test.fakes import FakeWebdmServer
+from test.test_fixtures import ServerFixture
+import test.store.package_management_tasks as tasks
+
+THIS_FILE_PATH = os.path.dirname(os.path.realpath(__file__))
+
+class TestPackageManagement(ScopeHarnessTestCase, fixtures.TestWithFixtures):
+	"""Test package installation/uninstallation via the scope.
+	"""
+
+	def setUp(self):
+		"""Setup the test fixtures, run the store scope, and fire up the daemon.
+		"""
+
+		server = ServerFixture(FakeWebdmServer)
+		self.useFixture(server)
+
+		# Run the package management daemon to communicate with our fake server
+		self.daemon = subprocess.Popen(["package-management-daemon",
+		                                "-webdm={}".format(server.url)])
+
+		os.environ["WEBDM_URL"] = server.url
+
+		self.harness = ScopeHarness.new_from_scope_list(Parameters([
+			"{}/../../store/snappy-store.ini".format(THIS_FILE_PATH)
+		]))
+		self.view = self.harness.results_view
+		self.view.active_scope = "snappy-store"
+		self.view.search_query = ""
+
+	def tearDown(self):
+		"""Terminate the daemon and make sure it exits cleanly."""
+
+		self.daemon.terminate()
+
+		# Make sure the daemon exits cleanly
+		self.assertEqual(self.daemon.wait(), 0)
+
+	def testPackageInstallation(self):
+		"""Test installing a package via the scope."""
+
+		self.installPackage("store_packages", "package2.canonical", "package2",
+		                    "Canonical", "http://icon2", "description2", "0.2",
+		                    "124 kB")
+
+	def testPackageUninstallation(self):
+		"""Test uninstalling a package via the scope."""
+
+		self.uninstallPackage("store_packages", "package1.canonical",
+		                      "package1", "Canonical", "http://icon1",
+		                      "description1", "0.1", "124 kB")
+
+	def testPackageInstallUninstallReinstall(self):
+		"""Test handling of package install/uninstall/reinstall flow."""
+
+		# Install the package
+		self.installPackage("store_packages", "package2.canonical", "package2",
+		                    "Canonical", "http://icon2", "description2", "0.2",
+		                    "124 kB")
+
+		# Now unstall the package
+		self.uninstallPackage("store_packages", "package2.canonical",
+		                      "package2", "Canonical", "http://icon2",
+		                      "description2", "0.2", "124 kB", 2)
+
+		# Finally, re-install the package
+		self.installPackage("store_packages", "package2.canonical", "package2",
+		                    "Canonical", "http://icon2", "description2", "0.2",
+		                    "124 kB", 3)
+
+	def installPackage(self, categoryId, packageId, title, subtitle, mascot,
+	                   description, version, size, operationNumber=1):
+		"""Install and verify package installation via scope."""
+
+		preview = tasks.installPackage(self, categoryId, packageId)
+		self.assertIsInstance(preview, PreviewView)
+
+		tasks.verifyInstallingPreview(self, preview, title, subtitle, mascot,
+		                              description, version, size,
+		                              operationNumber)
+
+		# Force the installation to succeed
+		widgetFound = False
+		for columnWidgets in preview.widgets:
+			for widget in columnWidgets:
+				if widget.type == "progress":
+					preview = widget.trigger("finished", "")
+					widgetFound = True
+
+		self.assertTrue(widgetFound,
+		                "Expected progress widget to be in preview.")
+
+		tasks.verifyInstalledPreview(self, preview, title, subtitle, mascot,
+		                             description, version, size)
+
+	def uninstallPackage(self, categoryId, packageId, title, subtitle, mascot,
+	                     description, version, size, operationNumber=1):
+		"""Uninstall and verify package uninstallation via scope."""
+
+		preview = tasks.uninstallPackage(self, categoryId, packageId)
+		self.assertIsInstance(preview, PreviewView)
+
+		tasks.verifyConfirmUninstallPreview(self, preview, title)
+
+		preview = tasks.confirmUninstallPackage(self, preview)
+		self.assertIsInstance(preview, PreviewView)
+
+		tasks.verifyUninstallingPreview(self, preview, title, subtitle, mascot,
+		                                description, version, size,
+		                                operationNumber)
+
+		# Force the uninstallation to succeed
+		widgetFound = False
+		for columnWidgets in preview.widgets:
+			for widget in columnWidgets:
+				if widget.type == "progress":
+					preview = widget.trigger("finished", "")
+					widgetFound = True
+
+		self.assertTrue(widgetFound,
+		                "Expected progress widget to be in preview.")
+
+		tasks.verifyStorePreview(self, preview, title, subtitle, mascot,
+		                         description, version, size)

=== added file 'test/store/test_package_management_failures.py'
--- test/store/test_package_management_failures.py	1970-01-01 00:00:00 +0000
+++ test/store/test_package_management_failures.py	2015-07-20 15:27:32 +0000
@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import subprocess
+import unittest
+import fixtures
+
+from scope_harness.testing import ScopeHarnessTestCase
+from scope_harness import (ScopeHarness,
+                           Parameters,
+                           PreviewView,
+                           PreviewColumnMatcher,
+                           PreviewMatcher,
+                           PreviewWidgetMatcher)
+
+# Local imports
+from test.fakes import FakeWebdmServer
+from test.test_fixtures import ServerFixture
+import test.store.package_management_tasks as tasks
+
+THIS_FILE_PATH = os.path.dirname(os.path.realpath(__file__))
+
+class TestPackageManagementFailures(ScopeHarnessTestCase, fixtures.TestWithFixtures):
+	"""Test package installation/uninstallation failures in the scope.
+	"""
+
+	def setUp(self):
+		"""Setup the test fixtures, run the store scope, and fire up the daemon.
+		"""
+
+		server = ServerFixture(FakeWebdmServer, True)
+		self.useFixture(server)
+
+		# Run the package management daemon to communicate with our fake server
+		self.daemon = subprocess.Popen(["package-management-daemon",
+		                                "-webdm={}".format(server.url)])
+
+		os.environ["WEBDM_URL"] = server.url
+
+		self.harness = ScopeHarness.new_from_scope_list(Parameters([
+			"{}/../../store/snappy-store.ini".format(THIS_FILE_PATH)
+		]))
+		self.view = self.harness.results_view
+		self.view.active_scope = "snappy-store"
+		self.view.search_query = ""
+
+	def tearDown(self):
+		"""Terminate the daemon and make sure it exits cleanly."""
+
+		self.daemon.terminate()
+
+		# Make sure the daemon exits cleanly
+		self.assertEqual(self.daemon.wait(), 0)
+
+	def testPackageInstallationFailure(self):
+		"""Test failure handling from the progress widget while installing."""
+
+		preview = tasks.installPackage(self, "store_packages", "package2.canonical")
+		self.assertIsInstance(preview, PreviewView)
+
+		# Force the installation to fail
+		widgetFound = False
+		for columnWidgets in preview.widgets:
+			for widget in columnWidgets:
+				if widget.type == "progress":
+					preview = widget.trigger("failed", "")
+					widgetFound = True
+
+		self.assertTrue(widgetFound,
+		                "Expected progress widget to be in preview.")
+
+		# Verify that the package still shows the package as not installed.
+		tasks.verifyStorePreview(self, preview, "package2", "Canonical",
+		                        "http://icon2", "description2", "0.2", "124 kB")
+
+	def testPackageUninstallationFailure(self):
+		"""Test failure handling from the progress widget while uninstalling."""
+
+		preview = tasks.uninstallPackage(self, "store_packages", "package1.canonical")
+		self.assertIsInstance(preview, PreviewView)
+
+		tasks.verifyConfirmUninstallPreview(self, preview, "package1")
+
+		preview = tasks.confirmUninstallPackage(self, preview)
+		self.assertIsInstance(preview, PreviewView)
+
+		# Force the uninstallation to fail
+		widgetFound = False
+		for columnWidgets in preview.widgets:
+			for widget in columnWidgets:
+				if widget.type == "progress":
+					preview = widget.trigger("failed", "")
+					widgetFound = True
+
+		self.assertTrue(widgetFound,
+		                "Expected progress widget to be in preview.")
+
+		# Verify that the preview still shows the package as installed.
+		tasks.verifyInstalledPreview(self, preview, "package1", "Canonical",
+		                             "http://icon1", "description1", "0.1",
+		                             "124 kB")