← Back to branch summary

~ubuntu-branches/ubuntu/trusty/swift/trusty-updates

« back to all changes in this revision

Viewing changes to test/unit/common/middleware/test_recon.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, James Page, Chuck Short
  • Date: 2013-08-13 10:37:13 UTC
  • mfrom: (1.2.21)
  • Revision ID: package-import@ubuntu.com-20130813103713-1ctbx4zifyljs2aq
Tags: 1.9.1-0ubuntu1
[ James Page ]
* d/control: Update VCS fields for new branch locations.

[ Chuck Short ]
* New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/unit/common/middleware/test_recon.py
18
18
from contextlib import contextmanager
19
19
from posix import stat_result, statvfs_result
20
20
import os
 
21
import mock
21
22
 
22
23
import swift.common.constraints
23
24
from swift import __version__ as swiftver
30
31
    def __call__(self, env, start_response):
31
32
        return "FAKE APP"
32
33
 
 
34
 
33
35
def start_response(*args):
34
36
    pass
35
37
 
 
38
 
36
39
class FakeFromCache(object):
37
40
 
38
41
    def __init__(self, out=None):
39
42
        self.fakeout = out
40
 
        self.fakeout_calls  = []
 
43
        self.fakeout_calls = []
41
44
 
42
45
    def fake_from_recon_cache(self, *args, **kwargs):
43
46
        self.fakeout_calls.append((args, kwargs))
44
47
        return self.fakeout
45
48
 
 
49
 
46
50
class OpenAndReadTester(object):
47
51
 
48
52
    def __init__(self, output_iter):
76
80
        self.open_calls.append((args, kwargs))
77
81
        yield self
78
82
 
 
83
 
79
84
class MockOS(object):
80
85
 
81
 
    def __init__(self, ls_out=None, pe_out=None, statvfs_out=None,
82
 
                 lstat_out=(1, 1, 5, 4, 5, 5, 55, 55, 55, 55)):
 
86
    def __init__(self, ls_out=None, im_out=False, statvfs_out=None):
83
87
        self.ls_output = ls_out
84
 
        self.path_exists_output = pe_out
 
88
        self.ismount_output = im_out
85
89
        self.statvfs_output = statvfs_out
86
 
        self.lstat_output_tuple = lstat_out
87
90
        self.listdir_calls = []
88
91
        self.statvfs_calls = []
89
 
        self.path_exists_calls = []
90
 
        self.lstat_calls = []
 
92
        self.ismount_calls = []
91
93
 
92
94
    def fake_listdir(self, *args, **kwargs):
93
95
        self.listdir_calls.append((args, kwargs))
94
96
        return self.ls_output
95
97
 
96
 
    def fake_path_exists(self, *args, **kwargs):
97
 
        self.path_exists_calls.append((args, kwargs))
98
 
        return self.path_exists_output
 
98
    def fake_ismount(self, *args, **kwargs):
 
99
        self.ismount_calls.append((args, kwargs))
 
100
        return self.ismount_output
99
101
 
100
102
    def fake_statvfs(self, *args, **kwargs):
101
103
        self.statvfs_calls.append((args, kwargs))
102
104
        return statvfs_result(self.statvfs_output)
103
105
 
104
 
    def fake_lstat(self, *args, **kwargs):
105
 
        self.lstat_calls.append((args, kwargs))
106
 
        return stat_result(self.lstat_output_tuple)
107
 
 
108
106
 
109
107
class FakeRecon(object):
110
108
 
175
173
    def raise_Exception(self, *args, **kwargs):
176
174
        raise Exception
177
175
 
 
176
 
178
177
class TestReconSuccess(TestCase):
179
178
 
180
179
    def setUp(self):
182
181
        self.mockos = MockOS()
183
182
        self.fakecache = FakeFromCache()
184
183
        self.real_listdir = os.listdir
185
 
        self.real_path_exists = os.path.exists
186
 
        self.real_lstat = os.lstat
 
184
        self.real_ismount = swift.common.constraints.ismount
187
185
        self.real_statvfs = os.statvfs
188
186
        os.listdir = self.mockos.fake_listdir
189
 
        os.path.exists = self.mockos.fake_path_exists
190
 
        os.lstat = self.mockos.fake_lstat
 
187
        swift.common.constraints.ismount = self.mockos.fake_ismount
191
188
        os.statvfs = self.mockos.fake_statvfs
192
189
        self.real_from_cache = self.app._from_recon_cache
193
190
        self.app._from_recon_cache = self.fakecache.fake_from_recon_cache
195
192
 
196
193
    def tearDown(self):
197
194
        os.listdir = self.real_listdir
198
 
        os.path.exists = self.real_path_exists
199
 
        os.lstat = self.real_lstat
 
195
        swift.common.constraints.ismount = self.real_ismount
200
196
        os.statvfs = self.real_statvfs
201
197
        del self.mockos
202
198
        self.app._from_recon_cache = self.real_from_cache
389
385
                                    "no_change": 2, "remote_merge": 0,
390
386
                                    "remove": 0, "rsync": 0,
391
387
                                    "start": 1333044050.855202,
392
 
                                    "success": 2, "ts_repl": 0 },
 
388
                                    "success": 2, "ts_repl": 0},
393
389
                               "replication_time": 0.2615511417388916,
394
390
                               "replication_last": 1357969645.25}
395
391
        self.fakecache.fakeout = from_cache_response
405
401
                                    "no_change": 2, "remote_merge": 0,
406
402
                                    "remove": 0, "rsync": 0,
407
403
                                    "start": 1333044050.855202,
408
 
                                    "success": 2, "ts_repl": 0 },
 
404
                                    "success": 2, "ts_repl": 0},
409
405
                                "replication_time": 0.2615511417388916,
410
406
                                "replication_last": 1357969645.25})
411
407
 
516
512
                                    "completed": 115.4512460231781,
517
513
                                    "errors": 0,
518
514
                                    "files_processed": 2310,
519
 
                                    "quarantined": 0 },
 
515
                                    "quarantined": 0},
520
516
                                "object_auditor_stats_ZBF": {
521
517
                                    "audit_time": 45.877294063568115,
522
518
                                    "bytes_processed": 0,
523
519
                                    "completed": 46.181446075439453,
524
520
                                    "errors": 0,
525
521
                                    "files_processed": 2310,
526
 
                                    "quarantined": 0 }}
 
522
                                    "quarantined": 0}}
527
523
        self.fakecache.fakeout_calls = []
528
524
        self.fakecache.fakeout = from_cache_response
529
525
        rv = self.app.get_auditor_info('object')
537
533
                                    "completed": 115.4512460231781,
538
534
                                    "errors": 0,
539
535
                                    "files_processed": 2310,
540
 
                                    "quarantined": 0 },
 
536
                                    "quarantined": 0},
541
537
                                "object_auditor_stats_ZBF": {
542
538
                                    "audit_time": 45.877294063568115,
543
539
                                    "bytes_processed": 0,
544
540
                                    "completed": 46.181446075439453,
545
541
                                    "errors": 0,
546
542
                                    "files_processed": 2310,
547
 
                                    "quarantined": 0 }})
 
543
                                    "quarantined": 0}})
548
544
 
549
545
    def test_get_unmounted(self):
550
546
 
551
 
        def fake_checkmount_true(*args):
552
 
            return True
553
 
 
554
547
        unmounted_resp = [{'device': 'fakeone', 'mounted': False},
555
548
                          {'device': 'faketwo', 'mounted': False}]
556
 
        self.mockos.ls_output=['fakeone', 'faketwo']
557
 
        self.mockos.path_exists_output=False
558
 
        real_checkmount = swift.common.constraints.check_mount
559
 
        swift.common.constraints.check_mount = fake_checkmount_true
 
549
        self.mockos.ls_output = ['fakeone', 'faketwo']
 
550
        self.mockos.ismount_output = False
560
551
        rv = self.app.get_unmounted()
561
 
        swift.common.constraints.check_mount = real_checkmount
562
552
        self.assertEquals(self.mockos.listdir_calls, [(('/srv/node/',), {})])
563
553
        self.assertEquals(rv, unmounted_resp)
564
554
 
568
558
            return True
569
559
 
570
560
        unmounted_resp = []
571
 
        self.mockos.ls_output=[]
572
 
        self.mockos.path_exists_output=False
573
 
        real_checkmount = swift.common.constraints.check_mount
574
 
        swift.common.constraints.check_mount = fake_checkmount_true
 
561
        self.mockos.ls_output = []
 
562
        self.mockos.ismount_output = False
575
563
        rv = self.app.get_unmounted()
576
 
        swift.common.constraints.check_mount = real_checkmount
577
564
        self.assertEquals(self.mockos.listdir_calls, [(('/srv/node/',), {})])
578
565
        self.assertEquals(rv, unmounted_resp)
579
566
 
580
567
    def test_get_diskusage(self):
581
568
        #posix.statvfs_result(f_bsize=4096, f_frsize=4096, f_blocks=1963185,
582
 
        #                     f_bfree=1113075, f_bavail=1013351, f_files=498736,
 
569
        #                     f_bfree=1113075, f_bavail=1013351,
 
570
        #                     f_files=498736,
583
571
        #                     f_ffree=397839, f_favail=397839, f_flag=0,
584
572
        #                     f_namemax=255)
585
 
        statvfs_content=(4096, 4096, 1963185, 1113075, 1013351, 498736, 397839,
586
 
                         397839, 0, 255)
 
573
        statvfs_content = (4096, 4096, 1963185, 1113075, 1013351, 498736,
 
574
                           397839, 397839, 0, 255)
587
575
        du_resp = [{'device': 'canhazdrive1', 'avail': 4150685696,
588
576
                    'mounted': True, 'used': 3890520064, 'size': 8041205760}]
589
 
        self.mockos.ls_output=['canhazdrive1']
590
 
        self.mockos.statvfs_output=statvfs_content
591
 
        self.mockos.path_exists_output=True
 
577
        self.mockos.ls_output = ['canhazdrive1']
 
578
        self.mockos.statvfs_output = statvfs_content
 
579
        self.mockos.ismount_output = True
592
580
        rv = self.app.get_diskusage()
593
581
        self.assertEquals(self.mockos.statvfs_calls,
594
582
                            [(('/srv/node/canhazdrive1',), {})])
597
585
    def test_get_diskusage_checkmount_fail(self):
598
586
        du_resp = [{'device': 'canhazdrive1', 'avail': '',
599
587
                    'mounted': False, 'used': '', 'size': ''}]
600
 
        self.mockos.ls_output=['canhazdrive1']
601
 
        self.mockos.path_exists_output=False
 
588
        self.mockos.ls_output = ['canhazdrive1']
 
589
        self.mockos.ismount_output = False
602
590
        rv = self.app.get_diskusage()
603
 
        self.assertEquals(self.mockos.listdir_calls,[(('/srv/node/',), {})])
604
 
        self.assertEquals(self.mockos.path_exists_calls,
 
591
        self.assertEquals(self.mockos.listdir_calls, [(('/srv/node/',), {})])
 
592
        self.assertEquals(self.mockos.ismount_calls,
605
593
                            [(('/srv/node/canhazdrive1',), {})])
606
594
        self.assertEquals(rv, du_resp)
607
595
 
608
596
    def test_get_quarantine_count(self):
609
 
        #posix.lstat_result(st_mode=1, st_ino=2, st_dev=3, st_nlink=4,
610
 
        #                   st_uid=5, st_gid=6, st_size=7, st_atime=8,
611
 
        #                   st_mtime=9, st_ctime=10)
612
 
        lstat_content = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
613
 
        self.mockos.ls_output=['sda']
614
 
        self.mockos.path_exists_output=True
615
 
        self.mockos.lstat_output=lstat_content
616
 
        rv = self.app.get_quarantine_count()
 
597
        self.mockos.ls_output = ['sda']
 
598
        self.mockos.ismount_output = True
 
599
 
 
600
        def fake_lstat(*args, **kwargs):
 
601
            #posix.lstat_result(st_mode=1, st_ino=2, st_dev=3, st_nlink=4,
 
602
            #                   st_uid=5, st_gid=6, st_size=7, st_atime=8,
 
603
            #                   st_mtime=9, st_ctime=10)
 
604
            return stat_result((1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
 
605
 
 
606
        def fake_exists(*args, **kwargs):
 
607
            return True
 
608
 
 
609
        with mock.patch("os.lstat", fake_lstat):
 
610
            with mock.patch("os.path.exists", fake_exists):
 
611
                rv = self.app.get_quarantine_count()
617
612
        self.assertEquals(rv, {'objects': 2, 'accounts': 2, 'containers': 2})
618
613
 
619
614
    def test_get_socket_info(self):
627
622
        self.assertEquals(oart.open_calls, [(('/proc/net/sockstat', 'r'), {}),
628
623
                                            (('/proc/net/sockstat6', 'r'), {})])
629
624
 
 
625
 
630
626
class TestReconMiddleware(unittest.TestCase):
631
627
 
632
628
    def setUp(self):