~dobey/ubuntuone-control-panel/remove-gtk

« back to all changes in this revision

Viewing changes to ubuntuone/controlpanel/gui/gtk/tests/test_package_manager.py

  • Committer: Rodney Dawes
  • Date: 2012-02-29 19:49:44 UTC
  • Revision ID: rodney.dawes@canonical.com-20120229194944-gmbmwfmccjp3g7o3
Remove the GTK+ 2.x control panel

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# -*- coding: utf-8 -*-
2
 
 
3
 
# Authors: Natalia B. Bidart <nataliabidart@canonical.com>
4
 
#
5
 
# Copyright 2010 Canonical Ltd.
6
 
#
7
 
# This program is free software: you can redistribute it and/or modify it
8
 
# under the terms of the GNU General Public License version 3, as published
9
 
# by the Free Software Foundation.
10
 
#
11
 
# This program is distributed in the hope that it will be useful, but
12
 
# WITHOUT ANY WARRANTY; without even the implied warranties of
13
 
# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
14
 
# PURPOSE.  See the GNU General Public License for more details.
15
 
#
16
 
# You should have received a copy of the GNU General Public License along
17
 
# with this program.  If not, see <http://www.gnu.org/licenses/>.
18
 
 
19
 
"""Tests for the package manager service."""
20
 
 
21
 
import collections
22
 
 
23
 
try:
24
 
    # Unable to import 'defer', pylint: disable=F0401,E0611,W0404
25
 
    from aptdaemon import defer
26
 
except ImportError:
27
 
    # Unable to import 'defer', pylint: disable=F0401,E0611,W0404
28
 
    import defer
29
 
 
30
 
from twisted.internet.defer import inlineCallbacks
31
 
 
32
 
from ubuntuone.controlpanel.gui.gtk import package_manager
33
 
from ubuntuone.controlpanel.tests import TestCase
34
 
 
35
 
 
36
 
FAKED_CACHE = {}
37
 
SUCCESS = package_manager.aptdaemon.enums.EXIT_SUCCESS
38
 
FAILURE = package_manager.aptdaemon.enums.EXIT_FAILED
39
 
 
40
 
 
41
 
class FakedPackage(object):
42
 
    """Fake a package."""
43
 
 
44
 
    def __init__(self, name=None, is_installed=False):
45
 
        self.name = name
46
 
        self.is_installed = is_installed
47
 
 
48
 
 
49
 
class FakedTransaction(object):
50
 
    """Fake a transaction."""
51
 
 
52
 
    failure = None
53
 
 
54
 
    def __init__(self, packages, cache=None):
55
 
        self._signals = collections.defaultdict(list)
56
 
        self._cache = cache
57
 
        self.was_run = False
58
 
        self.packages = packages
59
 
        self.connect = lambda sig, f: self._signals[sig].append(f)
60
 
 
61
 
    def run(self):
62
 
        """Run!"""
63
 
        self.was_run = True
64
 
 
65
 
        if self._cache is not None:
66
 
            for package in self.packages:
67
 
                FAKED_CACHE[package].is_installed = True
68
 
 
69
 
        if self.failure is None:
70
 
            code = SUCCESS
71
 
        else:
72
 
            code = FAILURE
73
 
 
74
 
        for listener in self._signals['finished']:
75
 
            listener(self, code)
76
 
 
77
 
        d = defer.Deferred()
78
 
        d.callback(code)
79
 
        return d
80
 
 
81
 
 
82
 
class FakedClient(object):
83
 
    """Fake an apt client."""
84
 
 
85
 
    def install_packages(self, packages_names, **kwargs):
86
 
        """Install packages listed in 'package_names'.
87
 
 
88
 
        package_names - a list of package names
89
 
        wait - if True run the transaction immediately and return its exit
90
 
            state instead of the transaction itself.
91
 
        reply_handler - callback function. If specified in combination with
92
 
            error_handler the method will be called asynchrounsouly.
93
 
        error_handler - in case of an error the given callback gets the
94
 
            corresponding DBus exception instance
95
 
 
96
 
        """
97
 
        if kwargs.get('wait', False):
98
 
            return package_manager.aptdaemon.enums.EXIT_FAILED
99
 
        d = defer.Deferred()
100
 
        d.callback(FakedTransaction(packages_names, cache=FAKED_CACHE))
101
 
        return d
102
 
 
103
 
 
104
 
class PackageManagerTestCase(TestCase):
105
 
    """Test for the package manager."""
106
 
 
107
 
    timeout = 2
108
 
 
109
 
    @inlineCallbacks
110
 
    def setUp(self):
111
 
        yield super(PackageManagerTestCase, self).setUp()
112
 
        FAKED_CACHE.clear()  # clean cache
113
 
        self.patch(package_manager.apt, 'Cache', lambda: FAKED_CACHE)
114
 
        self.patch(package_manager.aptdaemon.client, 'AptClient', FakedClient)
115
 
        self.obj = package_manager.PackageManager()
116
 
 
117
 
    def test_is_installed(self):
118
 
        """Check that a package is installed."""
119
 
        name = 'test'
120
 
        FAKED_CACHE[name] = FakedPackage(name, is_installed=True)
121
 
 
122
 
        result = self.obj.is_installed(name)
123
 
 
124
 
        self.assertTrue(result, 'must be installed')
125
 
 
126
 
    def test_is_not_installed(self):
127
 
        """Check if a package is installed."""
128
 
        name = 'test'
129
 
        FAKED_CACHE[name] = FakedPackage(name)  # not installed by default
130
 
 
131
 
        result = self.obj.is_installed(name)
132
 
 
133
 
        self.assertFalse(result, 'must not be installed')
134
 
 
135
 
    def test_is_not_installed_if_key_error(self):
136
 
        """Check if a package is installed when cache raises KeyError."""
137
 
        name = 'test'  # is not in the cache
138
 
        result = self.obj.is_installed(name)
139
 
 
140
 
        self.assertFalse(result, 'must not be installed')
141
 
 
142
 
    def test_progress_bar(self):
143
 
        """The progress bar class is correct."""
144
 
        self.assertIsInstance(package_manager.PackageManagerProgressBar(),
145
 
                              package_manager.AptProgressBar)
146
 
 
147
 
    @package_manager.inline_callbacks
148
 
    def test_install(self):
149
 
        """Install is correct."""
150
 
        name = 'test'
151
 
        FAKED_CACHE[name] = FakedPackage(name)  # not installed by default
152
 
 
153
 
        result = yield self.obj.install(name)
154
 
 
155
 
        self.assertIsInstance(result, FakedTransaction)
156
 
        self.assertFalse(result.was_run, 'transaction must not be run')
157
 
 
158
 
    @package_manager.inline_callbacks
159
 
    def test_transaction_install(self):
160
 
        """Install is correct."""
161
 
        name = 'test'
162
 
        FAKED_CACHE[name] = FakedPackage(name)  # not installed by default
163
 
 
164
 
        trans = yield self.obj.install(name)
165
 
 
166
 
        trans.connect('finished', self._set_called)
167
 
        trans.run()
168
 
 
169
 
        self.assertEqual(self._called, ((trans, SUCCESS), {}))
170
 
        self.assertTrue(trans.was_run, 'transaction must be run')
171
 
        self.assertTrue(self.obj.is_installed(name))
172
 
 
173
 
    @package_manager.inline_callbacks
174
 
    def test_install_if_installed(self):
175
 
        """Install does nothing is package is already installed."""
176
 
        name = 'test'
177
 
        FAKED_CACHE[name] = FakedPackage(name, is_installed=True)
178
 
 
179
 
        result = yield self.obj.install(name)
180
 
 
181
 
        self.assertEqual(result, SUCCESS)