← Back to branch summary

~free.ekanayaka/landscape-client/ensure-version

« back to all changes in this revision

Viewing changes to landscape/package/tests/test_taskhandler.py

  • Committer: Free Ekanayaka
  • Date: 2009-10-15 07:05:36 UTC
  • mfrom: (146.2.4 fetch-many-async)
  • Revision ID: free.ekanayaka@canonical.com-20091015070536-6g8vhpcrn22uv3c3
Merge fetch-many-async [f=50629] [r=sidnei,therve]

- Add helper fetch function to retrieve a list of URLs at once.
- Factor the code to parse lsb-release in its one function

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/package/tests/test_taskhandler.py
4
4
from twisted.internet.defer import Deferred, fail
5
5
 
6
6
from landscape.lib.lock import lock_path
7
 
from landscape.lib.command import CommandError
8
7
 
9
8
from landscape.broker.remote import RemoteBroker
10
9
 
23
22
    return MATCH(lambda arg: type(arg) is match_type)
24
23
 
25
24
 
 
25
SAMPLE_LSB_RELEASE = "DISTRIB_CODENAME=codename\n"
 
26
 
 
27
 
26
28
class PackageTaskHandlerTest(LandscapeIsolatedTest):
27
29
 
28
30
    helpers = [SmartFacadeHelper, RemoteBrokerHelper]
32
34
 
33
35
        self.config = PackageTaskHandlerConfiguration()
34
36
        self.store = PackageStore(self.makeFile())
35
 
 
36
 
        self.handler = PackageTaskHandler(self.store, self.facade, self.remote, self.config)
 
37
        self.handler = PackageTaskHandler(self.store, self.facade, self.remote,
 
38
                                          self.config)
37
39
 
38
40
    def test_ensure_channels_reloaded(self):
39
41
        self.assertEquals(len(self.facade.get_packages()), 0)
60
62
        # Fake uuid, codename and arch
61
63
        message_store = self.broker_service.message_store
62
64
        message_store.set_server_uuid("uuid")
63
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
64
 
        command_mock("lsb_release -cs")
65
 
        self.mocker.result("codename")
 
65
        self.handler.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
66
66
        self.facade.set_arch("arch")
67
67
 
68
68
        # Attach the hash=>id database to our store
83
83
        message_store.set_server_uuid("uuid")
84
84
 
85
85
        # Undetermined codename
86
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
87
 
        command_mock("lsb_release -cs")
88
 
        command_error = CommandError("lsb_release -cs", 1, "error")
89
 
        self.mocker.throw(command_error)
90
 
 
91
 
        # The failure should be properly logged
92
 
        logging_mock = self.mocker.replace("logging.warning")
93
 
        logging_mock("Couldn't determine which hash=>id database to use: %s" %
94
 
                     str(command_error))
95
 
        self.mocker.result(None)
96
 
 
97
 
        # Go!
98
 
        self.mocker.replay()
99
 
        result = self.handler.use_hash_id_db()
100
 
 
 
86
        self.handler.lsb_release_filename = self.makeFile("Foo=bar")
 
87
 
 
88
        # The failure should be properly logged
 
89
        logging_mock = self.mocker.replace("logging.warning")
 
90
        logging_mock("Couldn't determine which hash=>id database to use: "
 
91
                     "missing code-name key in %s" %
 
92
                     self.handler.lsb_release_filename)
 
93
        self.mocker.result(None)
 
94
 
 
95
        # Go!
 
96
        self.mocker.replay()
 
97
        result = self.handler.use_hash_id_db()
 
98
        return result
 
99
 
 
100
    def test_use_hash_id_db_wit_non_existing_lsb_release(self):
 
101
 
 
102
        # Fake uuid
 
103
        message_store = self.broker_service.message_store
 
104
        message_store.set_server_uuid("uuid")
 
105
 
 
106
        # Undetermined codename
 
107
        self.handler.lsb_release_filename = self.makeFile()
 
108
 
 
109
        # The failure should be properly logged
 
110
        logging_mock = self.mocker.replace("logging.warning")
 
111
        logging_mock("Couldn't determine which hash=>id database to use: "
 
112
                     "[Errno 2] No such file or directory: '%s'" %
 
113
                     self.handler.lsb_release_filename)
 
114
        self.mocker.result(None)
 
115
 
 
116
        # Go!
 
117
        self.mocker.replay()
 
118
        result = self.handler.use_hash_id_db()
101
119
        return result
102
120
 
103
121
    def test_wb_determine_hash_id_db_filename_server_uuid_is_none(self):
109
127
        message_store.set_server_uuid(None)
110
128
 
111
129
        result = self.handler._determine_hash_id_db_filename()
 
130
 
112
131
        def callback(hash_id_db_filename):
113
132
            self.assertIs(hash_id_db_filename, None)
114
133
        result.addCallback(callback)
129
148
        self.mocker.replay()
130
149
 
131
150
        result = self.handler.use_hash_id_db()
 
151
 
132
152
        def callback(ignore):
133
153
            self.assertFalse(self.store.has_hash_id_db())
134
154
        result.addCallback(callback)
139
159
        # Fake uuid and codename
140
160
        message_store = self.broker_service.message_store
141
161
        message_store.set_server_uuid("uuid")
142
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
143
 
        command_mock("lsb_release -cs")
144
 
        self.mocker.result("codename")
 
162
        self.handler.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
145
163
 
146
164
        # Undetermined arch
147
165
        self.facade.set_arch(None)
166
184
        # Fake uuid, codename and arch
167
185
        message_store = self.broker_service.message_store
168
186
        message_store.set_server_uuid("uuid")
169
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
170
 
        command_mock("lsb_release -cs")
171
 
        self.mocker.result("codename")
 
187
        self.handler.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
172
188
        self.facade.set_arch("arch")
173
189
 
174
190
        # Let's try
194
210
        # Fake uuid, codename and arch
195
211
        message_store = self.broker_service.message_store
196
212
        message_store.set_server_uuid("uuid")
197
 
        command_mock = self.mocker.replace("landscape.lib.command.run_command")
198
 
        command_mock("lsb_release -cs")
199
 
        self.mocker.result("codename")
 
213
        self.handler.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
200
214
        self.facade.set_arch("arch")
201
215
 
202
216
        # The failure should be properly logged
235
249
        results = [Deferred() for i in range(3)]
236
250
 
237
251
        stash = []
 
252
 
238
253
        def handle_task(task):
239
254
            result = results[task.data]
240
255
            result.addCallback(lambda x: stash.append(task.data))
272
287
 
273
288
        self.store.add_task(queue_name, 0)
274
289
 
275
 
        class MyException(Exception): pass
 
290
        class MyException(Exception):
 
291
            pass
276
292
 
277
293
        def handle_task(task):
278
294
            result = Deferred()