← Back to branch summary

~ubuntu-branches/ubuntu/saucy/swift/saucy-security

« back to all changes in this revision

Viewing changes to test/unit/__init__.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2013-04-02 09:06:48 UTC
  • mfrom: (1.2.18)
  • Revision ID: package-import@ubuntu.com-20130402090648-dq5fc3iy8hfoq9fq
Tags: 1.8.0~rc2-0ubuntu1
New usptream release candidate for grizzly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/unit/__init__.py
16
16
from StringIO import StringIO
17
17
from swift.common.utils import readconf, config_true_value
18
18
from logging import Handler
 
19
from hashlib import md5
 
20
from eventlet import sleep, spawn, Timeout
19
21
import logging.handlers
20
22
 
21
23
 
267
269
        setattr(module, attr, value)
268
270
    for module, attr in deletes:
269
271
        delattr(module, attr)
 
272
 
 
273
 
 
274
def fake_http_connect(*code_iter, **kwargs):
 
275
 
 
276
    class FakeConn(object):
 
277
 
 
278
        def __init__(self, status, etag=None, body='', timestamp='1',
 
279
                     expect_status=None):
 
280
            self.status = status
 
281
            if expect_status is None:
 
282
                self.expect_status = self.status
 
283
            else:
 
284
                self.expect_status = expect_status
 
285
            self.reason = 'Fake'
 
286
            self.host = '1.2.3.4'
 
287
            self.port = '1234'
 
288
            self.sent = 0
 
289
            self.received = 0
 
290
            self.etag = etag
 
291
            self.body = body
 
292
            self.timestamp = timestamp
 
293
 
 
294
        def getresponse(self):
 
295
            if kwargs.get('raise_exc'):
 
296
                raise Exception('test')
 
297
            if kwargs.get('raise_timeout_exc'):
 
298
                raise Timeout()
 
299
            return self
 
300
 
 
301
        def getexpect(self):
 
302
            if self.expect_status == -2:
 
303
                raise HTTPException()
 
304
            if self.expect_status == -3:
 
305
                return FakeConn(507)
 
306
            if self.expect_status == -4:
 
307
                return FakeConn(201)
 
308
            return FakeConn(100)
 
309
 
 
310
        def getheaders(self):
 
311
            etag = self.etag
 
312
            if not etag:
 
313
                if isinstance(self.body, str):
 
314
                    etag = '"' + md5(self.body).hexdigest() + '"'
 
315
                else:
 
316
                    etag = '"68b329da9893e34099c7d8ad5cb9c940"'
 
317
 
 
318
            headers = {'content-length': len(self.body),
 
319
                       'content-type': 'x-application/test',
 
320
                       'x-timestamp': self.timestamp,
 
321
                       'last-modified': self.timestamp,
 
322
                       'x-object-meta-test': 'testing',
 
323
                       'etag': etag,
 
324
                       'x-works': 'yes',
 
325
                       'x-account-container-count': kwargs.get('count', 12345)}
 
326
            if not self.timestamp:
 
327
                del headers['x-timestamp']
 
328
            try:
 
329
                if container_ts_iter.next() is False:
 
330
                    headers['x-container-timestamp'] = '1'
 
331
            except StopIteration:
 
332
                pass
 
333
            if 'slow' in kwargs:
 
334
                headers['content-length'] = '4'
 
335
            if 'headers' in kwargs:
 
336
                headers.update(kwargs['headers'])
 
337
            return headers.items()
 
338
 
 
339
        def read(self, amt=None):
 
340
            if 'slow' in kwargs:
 
341
                if self.sent < 4:
 
342
                    self.sent += 1
 
343
                    sleep(0.1)
 
344
                    return ' '
 
345
            rv = self.body[:amt]
 
346
            self.body = self.body[amt:]
 
347
            return rv
 
348
 
 
349
        def send(self, amt=None):
 
350
            if 'slow' in kwargs:
 
351
                if self.received < 4:
 
352
                    self.received += 1
 
353
                    sleep(0.1)
 
354
 
 
355
        def getheader(self, name, default=None):
 
356
            return dict(self.getheaders()).get(name.lower(), default)
 
357
 
 
358
    timestamps_iter = iter(kwargs.get('timestamps') or ['1'] * len(code_iter))
 
359
    etag_iter = iter(kwargs.get('etags') or [None] * len(code_iter))
 
360
    x = kwargs.get('missing_container', [False] * len(code_iter))
 
361
    if not isinstance(x, (tuple, list)):
 
362
        x = [x] * len(code_iter)
 
363
    container_ts_iter = iter(x)
 
364
    code_iter = iter(code_iter)
 
365
    static_body = kwargs.get('body', None)
 
366
    body_iter = kwargs.get('body_iter', None)
 
367
    if body_iter:
 
368
        body_iter = iter(body_iter)
 
369
 
 
370
    def connect(*args, **ckwargs):
 
371
        if 'give_content_type' in kwargs:
 
372
            if len(args) >= 7 and 'Content-Type' in args[6]:
 
373
                kwargs['give_content_type'](args[6]['Content-Type'])
 
374
            else:
 
375
                kwargs['give_content_type']('')
 
376
        if 'give_connect' in kwargs:
 
377
            kwargs['give_connect'](*args, **ckwargs)
 
378
        status = code_iter.next()
 
379
        if isinstance(status, tuple):
 
380
            status, expect_status = status
 
381
        else:
 
382
            expect_status = status
 
383
        etag = etag_iter.next()
 
384
        timestamp = timestamps_iter.next()
 
385
 
 
386
        if status <= 0:
 
387
            raise HTTPException()
 
388
        if body_iter is None:
 
389
            body = static_body or ''
 
390
        else:
 
391
            body = body_iter.next()
 
392
        return FakeConn(status, etag, body=body, timestamp=timestamp,
 
393
                        expect_status=expect_status)
 
394
 
 
395
    return connect