← Back to branch summary

~ubuntu-branches/ubuntu/precise/landscape-client/precise

« back to all changes in this revision

Viewing changes to landscape/broker/tests/test_transport.py

  • Committer: Package Import Robot
  • Author(s): Andreas Hasenack
  • Date: 2012-03-19 09:33:34 UTC
  • mto: This revision was merged to the branch mainline in revision 41.
  • Revision ID: package-import@ubuntu.com-20120319093334-oxjttz163vvfgq8s
Tags: upstream-12.04
Import upstream version 12.04

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/broker/tests/test_transport.py
1
1
import os
2
2
 
3
3
from landscape import VERSION
4
 
from landscape.broker.transport import HTTPTransport, PayloadRecorder
 
4
from landscape.broker.transport import HTTPTransport
5
5
from landscape.lib.fetch import PyCurlError
6
 
from landscape.lib.fs import create_file, read_file
7
6
from landscape.lib import bpickle
8
7
 
9
 
from landscape.tests.helpers import (
10
 
    LandscapeTest, LogKeeperHelper, MockerTestCase)
 
8
from landscape.tests.helpers import LandscapeTest, LogKeeperHelper
11
9
 
12
10
from twisted.web import server, resource
13
11
from twisted.internet import reactor
25
23
BADPUBKEY = sibpath("badpublic.ssl")
26
24
 
27
25
 
 
26
def fake_curl(payload, param2, param3):
 
27
    """Stub out the curl network call."""
 
28
    class Curly(object):
 
29
        def getinfo(self, param1):
 
30
            return 200
 
31
    return (Curly(), bpickle.dumps("%s response" % payload))
 
32
 
 
33
 
28
34
class DataCollectingResource(resource.Resource):
29
35
    request = content = None
30
36
 
52
58
 
53
59
    def test_get_url(self):
54
60
        url = "http://example/ooga"
55
 
        transport = HTTPTransport(url)
 
61
        transport = HTTPTransport(None, url)
56
62
        self.assertEqual(transport.get_url(), url)
57
63
 
58
64
    def test_set_url(self):
59
 
        transport = HTTPTransport("http://example/ooga")
 
65
        transport = HTTPTransport(None, "http://example/ooga")
60
66
        transport.set_url("http://example/message-system")
61
67
        self.assertEqual(transport.get_url(), "http://example/message-system")
62
68
 
71
77
        port = reactor.listenTCP(0, server.Site(r), interface="127.0.0.1")
72
78
        self.ports.append(port)
73
79
        transport = HTTPTransport(
74
 
            "http://localhost:%d/" % (port.getHost().port,))
 
80
            None, "http://localhost:%d/" % (port.getHost().port,))
75
81
        result = deferToThread(transport.exchange, "HI", computer_id="34",
76
82
                               message_api="X.Y")
77
83
 
98
104
                                 interface="127.0.0.1")
99
105
        self.ports.append(port)
100
106
        transport = HTTPTransport(
101
 
            "https://localhost:%d/" % (port.getHost().port,), PUBKEY)
 
107
            None, "https://localhost:%d/" % (port.getHost().port,), PUBKEY)
102
108
        result = deferToThread(transport.exchange, "HI", computer_id="34",
103
109
                               message_api="X.Y")
104
110
 
126
132
        port = reactor.listenSSL(0, server.Site(r), context_factory,
127
133
                                 interface="127.0.0.1")
128
134
        self.ports.append(port)
129
 
        transport = HTTPTransport("https://localhost:%d/"
130
 
                                  % (port.getHost().port,),
131
 
                                  pubkey=PUBKEY)
 
135
        transport = HTTPTransport(None, "https://localhost:%d/"
 
136
                                  % (port.getHost().port,), pubkey=PUBKEY)
132
137
 
133
138
        result = deferToThread(transport.exchange, "HI", computer_id="34",
134
139
                               message_api="X.Y")
140
145
                            in self.logfile.getvalue())
141
146
        result.addCallback(got_result)
142
147
        return result
143
 
 
144
 
    def test_payload_recording_works(self):
145
 
        """
146
 
        When C{HTTPTransport} is configured with a payload recorder, exchanges
147
 
        with the server should be saved to the filesystem.
148
 
        """
149
 
        path = self.makeDir()
150
 
        recorder = PayloadRecorder(path)
151
 
 
152
 
        def static_filename():
153
 
            return "filename"
154
 
        recorder.get_payload_filename = static_filename
155
 
 
156
 
        transport = HTTPTransport("http://localhost",
157
 
                                  payload_recorder=recorder)
158
 
 
159
 
        def fake_curl(param1, param2, param3):
160
 
            """Stub out the curl network call."""
161
 
            class Curly(object):
162
 
                def getinfo(self, param1):
163
 
                    return 200
164
 
            return (Curly(), bpickle.dumps("pay load response"))
165
 
        transport._curl = fake_curl
166
 
 
167
 
        transport.exchange("pay load")
168
 
 
169
 
        file_path = os.path.join(path, static_filename())
170
 
        self.assertEqual("pay load", bpickle.loads(read_file(file_path)))
171
 
 
172
 
    def test_exchange_works_without_payload_recording(self):
173
 
        """
174
 
        When C{HTTPTransport} is configured without a payload recorder,
175
 
        exchanges with the server should still complete.
176
 
        """
177
 
        transport = HTTPTransport("http://localhost")
178
 
        self.called = False
179
 
 
180
 
        def fake_curl(param1, param2, param3):
181
 
            """Stub out the curl network call."""
182
 
            self.called = True
183
 
 
184
 
            class Curly(object):
185
 
                def getinfo(self, param1):
186
 
                    return 200
187
 
            return (Curly(), bpickle.dumps("pay load response"))
188
 
        transport._curl = fake_curl
189
 
 
190
 
        transport.exchange("pay load")
191
 
 
192
 
        self.assertTrue(self.called)
193
 
 
194
 
 
195
 
class PayloadRecorderTest(MockerTestCase):
196
 
 
197
 
    def test_get_payload_filename(self):
198
 
        """
199
 
        L{PayloadRecorder.get_payload_filename} should return a filename that
200
 
        is equal to the number of seconds since it was created.
201
 
        """
202
 
        mock = self.mocker.replace("time.time")
203
 
        mock()
204
 
        self.mocker.result(0.0)
205
 
        mock()
206
 
        self.mocker.result(12.3456)
207
 
        self.mocker.replay()
208
 
        recorder = PayloadRecorder(None)
209
 
 
210
 
        payload_name = recorder.get_payload_filename()
211
 
 
212
 
        self.assertEqual("12.346", payload_name)
213
 
 
214
 
    def test_get_payload_filename_no_duplicates(self):
215
 
        """
216
 
        L{PayloadRecorder.get_payload_filename} should not generate duplicate
217
 
        payload names.
218
 
        """
219
 
        mock = self.mocker.replace("time.time")
220
 
        mock()
221
 
        self.mocker.result(0.0)
222
 
        mock()
223
 
        self.mocker.result(12.345)
224
 
        mock()
225
 
        self.mocker.result(12.345)
226
 
        self.mocker.replay()
227
 
 
228
 
        recorder = PayloadRecorder(None)
229
 
 
230
 
        payload_name_1 = recorder.get_payload_filename()
231
 
        payload_name_2 = recorder.get_payload_filename()
232
 
 
233
 
        self.assertEqual("12.345", payload_name_1)
234
 
        self.assertEqual("12.346", payload_name_2)
235
 
 
236
 
    def test_save(self):
237
 
        """L{PayloadRecorder.save} should save the payload to the filesystem.
238
 
        """
239
 
        path = self.makeDir()
240
 
        recorder = PayloadRecorder(path)
241
 
 
242
 
        def static_filename():
243
 
            return "filename"
244
 
        recorder.get_payload_filename = static_filename
245
 
        recorder.save("payload data")
246
 
        file_path = os.path.join(path, static_filename())
247
 
        self.assertEqual("payload data", read_file(file_path))
248
 
 
249
 
    def test_create_destination_dir(self):
250
 
        """
251
 
        L{PayloadRecorder} should create the destination directory if it does
252
 
        not exist.
253
 
        """
254
 
        path = self.makeDir()
255
 
        os.rmdir(path)
256
 
        PayloadRecorder(path)
257
 
        self.assertTrue(os.path.isdir(path))
258
 
 
259
 
    def test_delete_old_payloads(self):
260
 
        """
261
 
        L{PayloadRecorder} should remove all files from the destination
262
 
        directory before writing new files.
263
 
        """
264
 
        path = self.makeDir()
265
 
        create_file(os.path.join(path, "one"), "one")
266
 
        create_file(os.path.join(path, "two"), "two")
267
 
        PayloadRecorder(path)
268
 
        self.assertEqual([], os.listdir(path))