← Back to branch summary

~sil/u1db/cors-headers-and-web-admin

« back to all changes in this revision

Viewing changes to u1db/tests/test_vectorclock.py

  • Committer: John Arbash Meinel
  • Date: 2012-01-23 14:52:01 UTC
  • mfrom: (160.1.25 c-layout)
  • Revision ID: john@arbash-meinel.com-20120123145201-l1xzif2qe1kt1wb5
Land the initial C implementation of u1db.

Show diffs side-by-side

added added

removed removed

Lines of Context:
u1db/tests/test_vectorclock.py
18
18
 
19
19
from u1db import tests, vectorclock
20
20
 
 
21
try:
 
22
    from u1db.tests import c_backend_wrapper
 
23
except ImportError:
 
24
    c_backend_wrapper = None
 
25
 
 
26
 
 
27
c_vectorclock_scenarios = []
 
28
if c_backend_wrapper is not None:
 
29
    c_vectorclock_scenarios.append(
 
30
        ('c', {'create_vcr': c_backend_wrapper.VectorClockRev}))
 
31
 
21
32
 
22
33
class TestVectorClockRev(tests.TestCase):
23
34
 
 
35
    scenarios = [('py', {'create_vcr': vectorclock.VectorClockRev})
 
36
            ] + c_vectorclock_scenarios
 
37
 
24
38
    def assertIsNewer(self, newer_rev, older_rev):
25
 
        new_vcr = vectorclock.VectorClockRev(newer_rev)
26
 
        old_vcr = vectorclock.VectorClockRev(older_rev)
 
39
        new_vcr = self.create_vcr(newer_rev)
 
40
        old_vcr = self.create_vcr(older_rev)
27
41
        self.assertTrue(new_vcr.is_newer(old_vcr))
28
42
        self.assertFalse(old_vcr.is_newer(new_vcr))
29
43
 
30
44
    def assertIsConflicted(self, rev_a, rev_b):
31
 
        vcr_a = vectorclock.VectorClockRev(rev_a)
32
 
        vcr_b = vectorclock.VectorClockRev(rev_b)
 
45
        vcr_a = self.create_vcr(rev_a)
 
46
        vcr_b = self.create_vcr(rev_b)
33
47
        self.assertFalse(vcr_a.is_newer(vcr_b))
34
48
        self.assertFalse(vcr_b.is_newer(vcr_a))
35
49
 
36
50
    def test__is_newer_doc_rev(self):
37
51
        self.assertIsNewer('test:1', None)
38
52
        self.assertIsNewer('test:2', 'test:1')
39
 
        self.assertIsNewer('test:1|other:2', 'test:1|other:1')
40
 
        self.assertIsNewer('test:1|other:1', 'other:1')
41
 
        self.assertIsConflicted('test:1|other:2', 'test:2|other:1')
42
 
        self.assertIsConflicted('test:1|other:1', 'other:2')
 
53
        self.assertIsNewer('other:2|test:1', 'other:1|test:1')
 
54
        self.assertIsNewer('other:1|test:1', 'other:1')
 
55
        self.assertIsConflicted('other:2|test:1', 'other:1|test:2')
 
56
        self.assertIsConflicted('other:1|test:1', 'other:2')
43
57
        self.assertIsConflicted('test:1', 'test:1')
44
58
 
45
59
    def test_None(self):
46
 
        vcr = vectorclock.VectorClockRev(None)
 
60
        vcr = self.create_vcr(None)
47
61
        self.assertEqual('', vcr.as_str())
48
62
 
49
63
    def assertIncrement(self, original, replica_uid, after_increment):
50
 
        vcr = vectorclock.VectorClockRev(original)
 
64
        vcr = self.create_vcr(original)
51
65
        vcr.increment(replica_uid)
52
66
        self.assertEqual(after_increment, vcr.as_str())
53
67
 
54
68
    def test_increment(self):
55
69
        self.assertIncrement(None, 'test', 'test:1')
56
70
        self.assertIncrement('test:1', 'test', 'test:2')
 
71
 
 
72
    def test_increment_adds_uid(self):
57
73
        self.assertIncrement('other:1', 'test', 'other:1|test:1')
 
74
        self.assertIncrement('a:1|ab:2', 'aa', 'a:1|aa:1|ab:2')
 
75
 
 
76
    def test_increment_update_partial(self):
 
77
        self.assertIncrement('a:1|ab:2', 'a', 'a:2|ab:2')
 
78
        self.assertIncrement('a:2|ab:2', 'ab', 'a:2|ab:3')
 
79
 
 
80
    def test_increment_appends_uid(self):
 
81
        self.assertIncrement('b:2', 'c', 'b:2|c:1')
58
82
 
59
83
    def assertMaximize(self, rev1, rev2, maximized):
60
 
        vcr1 = vectorclock.VectorClockRev(rev1)
61
 
        vcr2 = vectorclock.VectorClockRev(rev2)
 
84
        vcr1 = self.create_vcr(rev1)
 
85
        vcr2 = self.create_vcr(rev2)
62
86
        vcr1.maximize(vcr2)
63
87
        self.assertEqual(maximized, vcr1.as_str())
64
88
        # reset vcr1 to maximize the other way
65
 
        vcr1 = vectorclock.VectorClockRev(rev1)
 
89
        vcr1 = self.create_vcr(rev1)
66
90
        vcr2.maximize(vcr1)
67
91
        self.assertEqual(maximized, vcr2.as_str())
68
92
 
72
96
        self.assertMaximize('x:1', 'y:1', 'x:1|y:1')
73
97
        self.assertMaximize('x:2', 'x:1', 'x:2')
74
98
        self.assertMaximize('x:2', 'x:1|y:2', 'x:2|y:2')
 
99
        self.assertMaximize('a:1|c:2|e:3', 'b:3|d:4|f:5',
 
100
                            'a:1|b:3|c:2|d:4|e:3|f:5')
 
101
 
 
102
load_tests = tests.load_with_scenarios