← Back to branch summary

~ubuntu-branches/ubuntu/natty/bzr/natty-proposed

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_remote.py

  • Committer: Bazaar Package Importer
  • Author(s): Jelmer Vernooij
  • Date: 2010-08-07 00:54:52 UTC
  • mfrom: (1.4.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20100807005452-g4zb99ezl3xn44r4
Tags: 2.2.0-1
http://bugs.debian.org/473450
http://bugs.debian.org/585193
https://launchpad.net/bugs/586926
https://launchpad.net/bugs/583941
http://bugs.debian.org/577110
http://bugs.debian.org/542105
https://launchpad.net/bugs/320035
https://launchpad.net/bugs/376388
https://launchpad.net/bugs/571467
https://launchpad.net/bugs/322767
https://launchpad.net/bugs/502076
https://launchpad.net/bugs/521989
https://launchpad.net/bugs/528041
* New upstream release.
 + Adds support for setting timestamps to originating revisions.
   Closes: #473450
 + Removes remaining string exception. Closes: #585193, LP: #586926
 + Add C extension to work around Python issue 1628205. LP: #583941,
   Closes: #577110
 + Avoids showing progress bars when --quiet is used. Closes: #542105,
   LP: #320035
 + No longer creates ~/.bazaar as root when run under sudo. LP: #376388
 + 'bzr commit' now supports -p as alternative for --show-diff. LP: #571467
 + 'bzr add' no longer adds .THIS/.BASE/.THEIRS files unless
   explicitly requested. LP: #322767
 + When parsing patch files, Bazaar now supports diff lines before each
   patch. LP: #502076
 + WorkingTrees now no longer requires using signal.signal, so can
   be used in a threaded environment. LP: #521989
 + An assertion error is no longer triggered when pushing to a pre-1.6
   Bazaar server. LP: #528041
* Bump standards version to 3.9.1.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_remote.py
38
38
    remote,
39
39
    repository,
40
40
    tests,
 
41
    transport,
41
42
    treebuilder,
42
43
    urlutils,
43
44
    versionedfile,
54
55
    )
55
56
from bzrlib.repofmt import groupcompress_repo, pack_repo
56
57
from bzrlib.revision import NULL_REVISION
57
 
from bzrlib.smart import server, medium
 
58
from bzrlib.smart import medium
58
59
from bzrlib.smart.client import _SmartClient
59
60
from bzrlib.smart.repository import SmartServerRepositoryGetParentMap
60
61
from bzrlib.tests import (
61
62
    condition_isinstance,
62
63
    split_suite_by_condition,
63
64
    multiply_tests,
 
65
    test_server,
64
66
    )
65
 
from bzrlib.transport import get_transport
66
67
from bzrlib.transport.memory import MemoryTransport
67
68
from bzrlib.transport.remote import (
68
69
    RemoteTransport,
75
76
        standard_tests, condition_isinstance(BasicRemoteObjectTests))
76
77
    smart_server_version_scenarios = [
77
78
        ('HPSS-v2',
78
 
            {'transport_server': server.SmartTCPServer_for_testing_v2_only}),
 
79
         {'transport_server': test_server.SmartTCPServer_for_testing_v2_only}),
79
80
        ('HPSS-v3',
80
 
            {'transport_server': server.SmartTCPServer_for_testing})]
 
81
         {'transport_server': test_server.SmartTCPServer_for_testing})]
81
82
    return multiply_tests(to_adapt, smart_server_version_scenarios, result)
82
83
 
83
84
 
358
359
        a given client_base and transport_base.
359
360
        """
360
361
        client_medium = medium.SmartClientMedium(client_base)
361
 
        transport = get_transport(transport_base)
362
 
        result = client_medium.remote_path_from_transport(transport)
 
362
        t = transport.get_transport(transport_base)
 
363
        result = client_medium.remote_path_from_transport(t)
363
364
        self.assertEqual(expected, result)
364
365
 
365
366
    def test_remote_path_from_transport(self):
376
377
        a given transport_base and relpath of that transport.  (Note that
377
378
        HttpTransportBase is a subclass of SmartClientMedium)
378
379
        """
379
 
        base_transport = get_transport(transport_base)
 
380
        base_transport = transport.get_transport(transport_base)
380
381
        client_medium = base_transport.get_smart_medium()
381
382
        cloned_transport = base_transport.clone(relpath)
382
383
        result = client_medium.remote_path_from_transport(cloned_transport)
608
609
        # _get_tree_branch is a form of open_branch, but it should only ask for
609
610
        # branch opening, not any other network requests.
610
611
        calls = []
611
 
        def open_branch():
 
612
        def open_branch(name=None):
612
613
            calls.append("Called")
613
614
            return "a-branch"
614
615
        transport = MemoryTransport()
1617
1618
    def test_get_multi_line_branch_conf(self):
1618
1619
        # Make sure that multiple-line branch.conf files are supported
1619
1620
        #
1620
 
        # https://bugs.edge.launchpad.net/bzr/+bug/354075
 
1621
        # https://bugs.launchpad.net/bzr/+bug/354075
1621
1622
        client = FakeClient()
1622
1623
        client.add_expected_call(
1623
1624
            'Branch.get_stacked_on_url', ('memory:///',),
1651
1652
        branch.unlock()
1652
1653
        self.assertFinished(client)
1653
1654
 
 
1655
    def test_set_option_with_dict(self):
 
1656
        client = FakeClient()
 
1657
        client.add_expected_call(
 
1658
            'Branch.get_stacked_on_url', ('memory:///',),
 
1659
            'error', ('NotStacked',),)
 
1660
        client.add_expected_call(
 
1661
            'Branch.lock_write', ('memory:///', '', ''),
 
1662
            'success', ('ok', 'branch token', 'repo token'))
 
1663
        encoded_dict_value = 'd5:ascii1:a11:unicode \xe2\x8c\x9a3:\xe2\x80\xbde'
 
1664
        client.add_expected_call(
 
1665
            'Branch.set_config_option_dict', ('memory:///', 'branch token',
 
1666
            'repo token', encoded_dict_value, 'foo', ''),
 
1667
            'success', ())
 
1668
        client.add_expected_call(
 
1669
            'Branch.unlock', ('memory:///', 'branch token', 'repo token'),
 
1670
            'success', ('ok',))
 
1671
        transport = MemoryTransport()
 
1672
        branch = self.make_remote_branch(transport, client)
 
1673
        branch.lock_write()
 
1674
        config = branch._get_config()
 
1675
        config.set_option(
 
1676
            {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'},
 
1677
            'foo')
 
1678
        branch.unlock()
 
1679
        self.assertFinished(client)
 
1680
 
1654
1681
    def test_backwards_compat_set_option(self):
1655
1682
        self.setup_smart_server_with_call_log()
1656
1683
        branch = self.make_branch('.')
1663
1690
        self.assertLength(10, self.hpss_calls)
1664
1691
        self.assertEqual('value', branch._get_config().get_option('name'))
1665
1692
 
 
1693
    def test_backwards_compat_set_option_with_dict(self):
 
1694
        self.setup_smart_server_with_call_log()
 
1695
        branch = self.make_branch('.')
 
1696
        verb = 'Branch.set_config_option_dict'
 
1697
        self.disable_verb(verb)
 
1698
        branch.lock_write()
 
1699
        self.addCleanup(branch.unlock)
 
1700
        self.reset_smart_call_log()
 
1701
        config = branch._get_config()
 
1702
        value_dict = {'ascii': 'a', u'unicode \N{WATCH}': u'\N{INTERROBANG}'}
 
1703
        config.set_option(value_dict, 'name')
 
1704
        self.assertLength(10, self.hpss_calls)
 
1705
        self.assertEqual(value_dict, branch._get_config().get_option('name'))
 
1706
 
1666
1707
 
1667
1708
class TestBranchLockWrite(RemoteBranchTestCase):
1668
1709
 
2033
2074
        self.assertLength(1, self.hpss_calls)
2034
2075
 
2035
2076
    def disableExtraResults(self):
2036
 
        old_flag = SmartServerRepositoryGetParentMap.no_extra_results
2037
 
        SmartServerRepositoryGetParentMap.no_extra_results = True
2038
 
        def reset_values():
2039
 
            SmartServerRepositoryGetParentMap.no_extra_results = old_flag
2040
 
        self.addCleanup(reset_values)
 
2077
        self.overrideAttr(SmartServerRepositoryGetParentMap,
 
2078
                          'no_extra_results', True)
2041
2079
 
2042
2080
    def test_null_cached_missing_and_stop_key(self):
2043
2081
        self.setup_smart_server_with_call_log()
2102
2140
 
2103
2141
    def test_allows_new_revisions(self):
2104
2142
        """get_parent_map's results can be updated by commit."""
2105
 
        smart_server = server.SmartTCPServer_for_testing()
 
2143
        smart_server = test_server.SmartTCPServer_for_testing()
2106
2144
        self.start_server(smart_server)
2107
2145
        self.make_branch('branch')
2108
2146
        branch = Branch.open(smart_server.get_url() + '/branch')
2259
2297
        self.setup_smart_server_with_call_log()
2260
2298
        tree = self.make_branch_and_memory_tree('.')
2261
2299
        tree.lock_write()
 
2300
        tree.add('')
2262
2301
        rev1 = tree.commit('First')
2263
2302
        rev2 = tree.commit('Second')
2264
2303
        tree.unlock()
2303
2342
        transport_path = 'quack'
2304
2343
        repo, client = self.setup_fake_client_and_repository(transport_path)
2305
2344
        client.add_success_response('ok', 'a token')
2306
 
        result = repo.lock_write()
 
2345
        token = repo.lock_write().repository_token
2307
2346
        self.assertEqual(
2308
2347
            [('call', 'Repository.lock_write', ('quack/', ''))],
2309
2348
            client._calls)
2310
 
        self.assertEqual('a token', result)
 
2349
        self.assertEqual('a token', token)
2311
2350
 
2312
2351
    def test_lock_write_already_locked(self):
2313
2352
        transport_path = 'quack'
2651
2690
    """RemoteRepository.copy_content_into optimizations"""
2652
2691
 
2653
2692
    def test_copy_content_remote_to_local(self):
2654
 
        self.transport_server = server.SmartTCPServer_for_testing
 
2693
        self.transport_server = test_server.SmartTCPServer_for_testing
2655
2694
        src_repo = self.make_repository('repo1')
2656
2695
        src_repo = repository.Repository.open(self.get_url('repo1'))
2657
2696
        # At the moment the tarball-based copy_content_into can't write back
2970
3009
        stacked_branch = self.make_branch('stacked', format='1.9')
2971
3010
        stacked_branch.set_stacked_on_url('../base')
2972
3011
        # start a server looking at this
2973
 
        smart_server = server.SmartTCPServer_for_testing()
 
3012
        smart_server = test_server.SmartTCPServer_for_testing()
2974
3013
        self.start_server(smart_server)
2975
3014
        remote_bzrdir = BzrDir.open(smart_server.get_url() + '/stacked')
2976
3015
        # can get its branch and repository
3132
3171
        super(TestRemoteBranchEffort, self).setUp()
3133
3172
        # Create a smart server that publishes whatever the backing VFS server
3134
3173
        # does.
3135
 
        self.smart_server = server.SmartTCPServer_for_testing()
 
3174
        self.smart_server = test_server.SmartTCPServer_for_testing()
3136
3175
        self.start_server(self.smart_server, self.get_server())
3137
3176
        # Log all HPSS calls into self.hpss_calls.
3138
3177
        _SmartClient.hooks.install_named_hook(