~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_config.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-05-31 19:43:27 UTC
  • mfrom: (5743.10.13 config-lock-remote)
  • Revision ID: pqm@pqm.ubuntu.com-20110531194327-pjelx43boom8r26y
(vila) Support config remote branch config file. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
41
41
    trace,
42
42
    transport,
43
43
    )
 
44
from bzrlib.transport import remote
44
45
from bzrlib.tests import (
45
46
    features,
46
47
    TestSkipped,
72
73
config.test_store_builder_registry.register(
73
74
    'location', lambda test: config.LocationStore())
74
75
 
 
76
 
 
77
def build_backing_branch(test, relpath,
 
78
                         transport_class=None, server_class=None):
 
79
    """Test helper to create a backing branch only once.
 
80
 
 
81
    Some tests needs multiple stores/stacks to check concurrent update
 
82
    behaviours. As such, they need to build different branch *objects* even if
 
83
    they share the branch on disk.
 
84
 
 
85
    :param relpath: The relative path to the branch. (Note that the helper
 
86
        should always specify the same relpath).
 
87
 
 
88
    :param transport_class: The Transport class the test needs to use.
 
89
 
 
90
    :param server_class: The server associated with the ``transport_class``
 
91
        above.
 
92
 
 
93
    Either both or neither of ``transport_class`` and ``server_class`` should
 
94
    be specified.
 
95
    """
 
96
    if transport_class is not None and server_class is not None:
 
97
        test.transport_class = transport_class
 
98
        test.transport_server = server_class
 
99
    elif not (transport_class is None and server_class is None):
 
100
        raise AssertionError('Specify both ``transport_class`` and '
 
101
                             '``server_class`` or neither of them')
 
102
    if getattr(test, 'backing_branch', None) is None:
 
103
        # First call, let's build the branch on disk
 
104
        test.backing_branch = test.make_branch(relpath)
 
105
 
 
106
 
 
107
def keep_branch_alive(test, b):
 
108
    """Keep a branch alive for the duration of a test.
 
109
 
 
110
    :param tests: the test that should hold the branch alive.
 
111
 
 
112
    :param b: the branch that should be kept alive.
 
113
 
 
114
    Several tests need to keep a reference to a branch object as they are
 
115
    testing a Store which uses a weak reference. This is achieved by embedding
 
116
    a reference to the branch object in a lambda passed to a cleanup. When the
 
117
    test finish the cleanup method is deleted and so does the reference to the
 
118
    branch.
 
119
    """
 
120
    test.addCleanup(lambda : b)
 
121
 
 
122
 
75
123
def build_branch_store(test):
76
 
    if getattr(test, 'branch', None) is None:
77
 
        test.branch = test.make_branch('branch')
78
 
    # Since we can be called to create different stores, we need to build them
79
 
    # from different branch *objects*, even if they point to the same branch on
80
 
    # disk, otherwise tests about conccurent updates won't be able to trigger
81
 
    # LockContention
82
 
    return config.BranchStore(branch.Branch.open('branch'))
 
124
    build_backing_branch(test, 'branch')
 
125
    b = branch.Branch.open('branch')
 
126
    keep_branch_alive(test, b)
 
127
    return config.BranchStore(b)
83
128
config.test_store_builder_registry.register('branch', build_branch_store)
84
129
 
85
130
 
 
131
def build_remote_branch_store(test):
 
132
    # There is only one permutation (but we won't be able to handle more with
 
133
    # this design anyway)
 
134
    (transport_class, server_class) = remote.get_test_permutations()[0]
 
135
    build_backing_branch(test, 'branch', transport_class, server_class)
 
136
    b = branch.Branch.open(test.get_url('branch'))
 
137
    keep_branch_alive(test, b)
 
138
    return config.BranchStore(b)
 
139
config.test_store_builder_registry.register('remote_branch',
 
140
                                            build_remote_branch_store)
 
141
 
 
142
 
86
143
config.test_stack_builder_registry.register(
87
144
    'bazaar', lambda test: config.GlobalStack())
88
145
config.test_stack_builder_registry.register(
89
146
    'location', lambda test: config.LocationStack('.'))
90
147
 
 
148
 
91
149
def build_branch_stack(test):
92
 
    if getattr(test, 'branch', None) is None:
93
 
        test.branch = test.make_branch('branch')
94
 
    # Since we can be called to create different stacks, we need to build them
95
 
    # from different branch *objects*, even if they point to the same branch on
96
 
    # disk, otherwise tests about conccurent updates won't be able to trigger
97
 
    # LockContention
98
 
    return config.BranchStack(branch.Branch.open('branch'))
 
150
    build_backing_branch(test, 'branch')
 
151
    b = branch.Branch.open('branch')
 
152
    keep_branch_alive(test, b)
 
153
    return config.BranchStack(b)
99
154
config.test_stack_builder_registry.register('branch', build_branch_stack)
100
155
 
101
156
 
 
157
def build_remote_branch_stack(test):
 
158
    # There is only one permutation (but we won't be able to handle more with
 
159
    # this design anyway)
 
160
    (transport_class, server_class) = remote.get_test_permutations()[0]
 
161
    build_backing_branch(test, 'branch', transport_class, server_class)
 
162
    b = branch.Branch.open(test.get_url('branch'))
 
163
    keep_branch_alive(test, b)
 
164
    return config.BranchStack(b)
 
165
config.test_stack_builder_registry.register('remote_branch',
 
166
                                            build_remote_branch_stack)
 
167
 
 
168
 
102
169
sample_long_alias="log -r-15..-1 --line"
103
170
sample_config_text = u"""
104
171
[DEFAULT]
642
709
    def test_default_is_True(self):
643
710
        self.config = self.get_config(True)
644
711
        self.assertExpandIs(True)
645
 
        
 
712
 
646
713
    def test_default_is_False(self):
647
714
        self.config = self.get_config(False)
648
715
        self.assertExpandIs(False)
649
 
        
 
716
 
650
717
 
651
718
class TestIniConfigOptionExpansion(tests.TestCase):
652
719
    """Test option expansion from the IniConfig level.
1940
2007
 
1941
2008
    def setUp(self):
1942
2009
        super(TestReadonlyStore, self).setUp()
1943
 
        self.branch = self.make_branch('branch')
1944
2010
 
1945
2011
    def test_building_delays_load(self):
1946
2012
        store = self.get_store(self)
1988
2054
        return self.transport.has(store_basename)
1989
2055
 
1990
2056
    def test_save_empty_creates_no_file(self):
1991
 
        if self.store_id == 'branch':
 
2057
        # FIXME: There should be a better way than relying on the test
 
2058
        # parametrization to identify branch.conf -- vila 2011-0526
 
2059
        if self.store_id in ('branch', 'remote_branch'):
1992
2060
            raise tests.TestNotApplicable(
1993
2061
                'branch.conf is *always* created when a branch is initialized')
1994
2062
        store = self.get_store(self)
2007
2075
        self.assertLength(0, sections)
2008
2076
 
2009
2077
    def test_save_with_content_succeeds(self):
2010
 
        if self.store_id == 'branch':
 
2078
        # FIXME: There should be a better way than relying on the test
 
2079
        # parametrization to identify branch.conf -- vila 2011-0526
 
2080
        if self.store_id in ('branch', 'remote_branch'):
2011
2081
            raise tests.TestNotApplicable(
2012
2082
                'branch.conf is *always* created when a branch is initialized')
2013
2083
        store = self.get_store(self)
2114
2184
        self.assertPathExists('dir/subdir')
2115
2185
 
2116
2186
 
 
2187
class TestBranchStore(TestStore):
 
2188
 
 
2189
    def test_dead_branch(self):
 
2190
        build_backing_branch(self, 'branch')
 
2191
        b = branch.Branch.open('branch')
 
2192
        store = config.BranchStore(b)
 
2193
        del b
 
2194
        # The only reliable way to trigger the error is to explicitly call the
 
2195
        # garbage collector.
 
2196
        import gc
 
2197
        gc.collect()
 
2198
        store.get_mutable_section(None).set('foo', 'bar')
 
2199
        self.assertRaises(AssertionError, store.save)
 
2200
 
 
2201
 
2117
2202
class TestConcurrentStoreUpdates(TestStore):
 
2203
    """Test that Stores properly handle conccurent updates.
 
2204
 
 
2205
    New Store implementation may fail some of these tests but until such
 
2206
    implementations exist it's hard to properly filter them from the scenarios
 
2207
    applied here. If you encounter such a case, contact the bzr devs.
 
2208
    """
2118
2209
 
2119
2210
    scenarios = [(key, {'get_stack': builder}) for key, builder
2120
2211
                 in config.test_stack_builder_registry.iteritems()]