/brz/remove-bazaar

# Copyright (C) 2006, 2007 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""Tests for remote bzrdir/branch/repo/etc

These are proxy objects which act on remote objects by sending messages

through a smart client.  The proxies are to be created when attempting to open

the object given a transport that supports smartserver rpc operations. 

These tests correspond to tests.test_smart, which exercises the server side.

"""

import bz2

from cStringIO import StringIO

from bzrlib import (

    errors,

    graph,

    pack,

    remote,

    repository,

    tests,

    )

from bzrlib.branch import Branch

from bzrlib.bzrdir import BzrDir, BzrDirFormat

from bzrlib.remote import (

    RemoteBranch,

    RemoteBzrDir,

    RemoteBzrDirFormat,

    RemoteRepository,

    )

from bzrlib.revision import NULL_REVISION

from bzrlib.smart import server, medium

from bzrlib.smart.client import _SmartClient

from bzrlib.transport.memory import MemoryTransport

from bzrlib.transport.remote import RemoteTransport

class BasicRemoteObjectTests(tests.TestCaseWithTransport):

    def setUp(self):

        self.transport_server = server.SmartTCPServer_for_testing

        super(BasicRemoteObjectTests, self).setUp()

        self.transport = self.get_transport()

        # make a branch that can be opened over the smart transport

        self.local_wt = BzrDir.create_standalone_workingtree('.')

    def tearDown(self):

        self.transport.disconnect()

        tests.TestCaseWithTransport.tearDown(self)

    def test_create_remote_bzrdir(self):

        b = remote.RemoteBzrDir(self.transport)

        self.assertIsInstance(b, BzrDir)

    def test_open_remote_branch(self):

        # open a standalone branch in the working directory

        b = remote.RemoteBzrDir(self.transport)

        branch = b.open_branch()

        self.assertIsInstance(branch, Branch)

    def test_remote_repository(self):

        b = BzrDir.open_from_transport(self.transport)

        repo = b.open_repository()

        revid = u'\xc823123123'.encode('utf8')

        self.assertFalse(repo.has_revision(revid))

        self.local_wt.commit(message='test commit', rev_id=revid)

        self.assertTrue(repo.has_revision(revid))

    def test_remote_branch_revision_history(self):

        b = BzrDir.open_from_transport(self.transport).open_branch()

        self.assertEqual([], b.revision_history())

        r1 = self.local_wt.commit('1st commit')

        r2 = self.local_wt.commit('1st commit', rev_id=u'\xc8'.encode('utf8'))

        self.assertEqual([r1, r2], b.revision_history())

    def test_find_correct_format(self):

        """Should open a RemoteBzrDir over a RemoteTransport"""

        fmt = BzrDirFormat.find_format(self.transport)

        self.assertTrue(RemoteBzrDirFormat

                        in BzrDirFormat._control_server_formats)

        self.assertIsInstance(fmt, remote.RemoteBzrDirFormat)

    def test_open_detected_smart_format(self):

        fmt = BzrDirFormat.find_format(self.transport)

        d = fmt.open(self.transport)

        self.assertIsInstance(d, BzrDir)

    def test_remote_branch_repr(self):

        b = BzrDir.open_from_transport(self.transport).open_branch()

        self.assertStartsWith(str(b), 'RemoteBranch(')

class FakeProtocol(object):

    """Lookalike SmartClientRequestProtocolOne allowing body reading tests."""

    def __init__(self, body, fake_client):

        self.body = body

        self._body_buffer = None

        self._fake_client = fake_client

    def read_body_bytes(self, count=-1):

        if self._body_buffer is None:

            self._body_buffer = StringIO(self.body)

        bytes = self._body_buffer.read(count)

        if self._body_buffer.tell() == len(self._body_buffer.getvalue()):

            self._fake_client.expecting_body = False

        return bytes

    def cancel_read_body(self):

        self._fake_client.expecting_body = False

    def read_streamed_body(self):

        return self.body

class FakeClient(_SmartClient):

    """Lookalike for _SmartClient allowing testing."""

    def __init__(self, responses, fake_medium_base='fake base'):

        """Create a FakeClient.

        :param responses: A list of response-tuple, body-data pairs to be sent

            back to callers.

        """

        self.responses = responses

        self._calls = []

        self.expecting_body = False

        _SmartClient.__init__(self, FakeMedium(fake_medium_base, self._calls))

    def call(self, method, *args):

        self._calls.append(('call', method, args))

        return self.responses.pop(0)[0]

    def call_expecting_body(self, method, *args):

        self._calls.append(('call_expecting_body', method, args))

        result = self.responses.pop(0)

        self.expecting_body = True

        return result[0], FakeProtocol(result[1], self)

    def call_with_body_bytes_expecting_body(self, method, args, body):

        self._calls.append(('call_with_body_bytes_expecting_body', method,

            args, body))

        result = self.responses.pop(0)

        self.expecting_body = True

        return result[0], FakeProtocol(result[1], self)

class FakeMedium(object):

    def __init__(self, base, client_calls):

        self.base = base

        self.connection = FakeConnection(client_calls)

        self._client_calls = client_calls

class FakeConnection(object):

    def __init__(self, client_calls):

        self._remote_is_at_least_1_2 = True

        self._client_calls = client_calls

    def disconnect(self):

        self._client_calls.append(('disconnect medium',))

class TestVfsHas(tests.TestCase):

    def test_unicode_path(self):

        client = FakeClient([(('yes',), )], '/')

        transport = RemoteTransport('bzr://localhost/', _client=client)

        filename = u'/hell\u00d8'.encode('utf8')

        result = transport.has(filename)

        self.assertEqual(

            [('call', 'has', (filename,))],

            client._calls)

        self.assertTrue(result)

class TestBzrDirOpenBranch(tests.TestCase):

    def test_branch_present(self):

        transport = MemoryTransport()

        transport.mkdir('quack')

        transport = transport.clone('quack')

        client = FakeClient([(('ok', ''), ), (('ok', '', 'no', 'no', 'no'), )],

                            transport.base)

        bzrdir = RemoteBzrDir(transport, _client=client)

        result = bzrdir.open_branch()

        self.assertEqual(

            [('call', 'BzrDir.open_branch', ('quack/',)),

             ('call', 'BzrDir.find_repositoryV2', ('quack/',))],

            client._calls)

        self.assertIsInstance(result, RemoteBranch)

        self.assertEqual(bzrdir, result.bzrdir)

    def test_branch_missing(self):

        transport = MemoryTransport()

        transport.mkdir('quack')

        transport = transport.clone('quack')

        client = FakeClient([(('nobranch',), )], transport.base)

        bzrdir = RemoteBzrDir(transport, _client=client)

        self.assertRaises(errors.NotBranchError, bzrdir.open_branch)

        self.assertEqual(

            [('call', 'BzrDir.open_branch', ('quack/',))],

            client._calls)

    def test__get_tree_branch(self):

        # _get_tree_branch is a form of open_branch, but it should only ask for

        # branch opening, not any other network requests.

        calls = []

        def open_branch():

            calls.append("Called")

            return "a-branch"

        transport = MemoryTransport()

        # no requests on the network - catches other api calls being made.

        client = FakeClient([], transport.base)

        bzrdir = RemoteBzrDir(transport, _client=client)

        # patch the open_branch call to record that it was called.

        bzrdir.open_branch = open_branch

        self.assertEqual((None, "a-branch"), bzrdir._get_tree_branch())

        self.assertEqual(["Called"], calls)

        self.assertEqual([], client._calls)

    def test_url_quoting_of_path(self):

        # Relpaths on the wire should not be URL-escaped.  So "~" should be

        # transmitted as "~", not "%7E".

        transport = RemoteTransport('bzr://localhost/~hello/')

        client = FakeClient([(('ok', ''), ), (('ok', '', 'no', 'no', 'no'), )],

                            transport.base)

        bzrdir = RemoteBzrDir(transport, _client=client)

        result = bzrdir.open_branch()

        self.assertEqual(

            [('call', 'BzrDir.open_branch', ('~hello/',)),

             ('call', 'BzrDir.find_repositoryV2', ('~hello/',))],

            client._calls)

    def check_open_repository(self, rich_root, subtrees, external_lookup='no'):

        transport = MemoryTransport()

        transport.mkdir('quack')

        transport = transport.clone('quack')

        if rich_root:

            rich_response = 'yes'

        else:

            rich_response = 'no'

        if subtrees:

            subtree_response = 'yes'

        else:

            subtree_response = 'no'

        client = FakeClient(

            [(('ok', '', rich_response, subtree_response, external_lookup), ),],

            transport.base)

        bzrdir = RemoteBzrDir(transport, _client=client)

        result = bzrdir.open_repository()

        self.assertEqual(

            [('call', 'BzrDir.find_repositoryV2', ('quack/',))],

            client._calls)

        self.assertIsInstance(result, RemoteRepository)

        self.assertEqual(bzrdir, result.bzrdir)

        self.assertEqual(rich_root, result._format.rich_root_data)

        self.assertEqual(subtrees, result._format.supports_tree_reference)

    def test_open_repository_sets_format_attributes(self):

        self.check_open_repository(True, True)

        self.check_open_repository(False, True)

        self.check_open_repository(True, False)

        self.check_open_repository(False, False)

        self.check_open_repository(False, False, 'yes')

    def test_old_server(self):

        """RemoteBzrDirFormat should fail to probe if the server version is too

        old.

        """

        self.assertRaises(errors.NotBranchError,

            RemoteBzrDirFormat.probe_transport, OldServerTransport())

class OldSmartClient(object):

    """A fake smart client for test_old_version that just returns a version one

    response to the 'hello' (query version) command.

    """

    def get_request(self):

        input_file = StringIO('ok\x011\n')

        output_file = StringIO()

        client_medium = medium.SmartSimplePipesClientMedium(

            input_file, output_file)

        return medium.SmartClientStreamMediumRequest(client_medium)

    def protocol_version(self):

        return 1

class OldServerTransport(object):

    """A fake transport for test_old_server that reports it's smart server

    protocol version as version one.

    """

    def __init__(self):

        self.base = 'fake:'

    def get_smart_client(self):

        return OldSmartClient()

class TestBranchLastRevisionInfo(tests.TestCase):

    def test_empty_branch(self):

        # in an empty branch we decode the response properly

        transport = MemoryTransport()

        client = FakeClient([(('ok', '0', 'null:'), )], transport.base)

        transport.mkdir('quack')

        transport = transport.clone('quack')

        # we do not want bzrdir to make any remote calls

        bzrdir = RemoteBzrDir(transport, _client=False)

        branch = RemoteBranch(bzrdir, None, _client=client)

        result = branch.last_revision_info()

        self.assertEqual(

            [('call', 'Branch.last_revision_info', ('quack/',))],

            client._calls)

        self.assertEqual((0, NULL_REVISION), result)

    def test_non_empty_branch(self):

        # in a non-empty branch we also decode the response properly

        revid = u'\xc8'.encode('utf8')

        transport = MemoryTransport()

        client = FakeClient([(('ok', '2', revid), )], transport.base)

        transport.mkdir('kwaak')

        transport = transport.clone('kwaak')

        # we do not want bzrdir to make any remote calls

        bzrdir = RemoteBzrDir(transport, _client=False)

        branch = RemoteBranch(bzrdir, None, _client=client)

        result = branch.last_revision_info()

        self.assertEqual(

            [('call', 'Branch.last_revision_info', ('kwaak/',))],

            client._calls)

        self.assertEqual((2, revid), result)

class TestBranchSetLastRevision(tests.TestCase):

    def test_set_empty(self):

        # set_revision_history([]) is translated to calling

        # Branch.set_last_revision(path, '') on the wire.

        transport = MemoryTransport()

        transport.mkdir('branch')

        transport = transport.clone('branch')

        client = FakeClient([

            # lock_write

            (('ok', 'branch token', 'repo token'), ),

            # set_last_revision

            (('ok',), ),

            # unlock

            (('ok',), )],

            transport.base)

        bzrdir = RemoteBzrDir(transport, _client=False)

        branch = RemoteBranch(bzrdir, None, _client=client)

        # This is a hack to work around the problem that RemoteBranch currently

        # unnecessarily invokes _ensure_real upon a call to lock_write.

        branch._ensure_real = lambda: None

        branch.lock_write()

        client._calls = []

        result = branch.set_revision_history([])

        self.assertEqual(

            [('call', 'Branch.set_last_revision',

                ('branch/', 'branch token', 'repo token', 'null:'))],

            client._calls)

        branch.unlock()

        self.assertEqual(None, result)

    def test_set_nonempty(self):

        # set_revision_history([rev-id1, ..., rev-idN]) is translated to calling

        # Branch.set_last_revision(path, rev-idN) on the wire.

        transport = MemoryTransport()

        transport.mkdir('branch')

        transport = transport.clone('branch')

        client = FakeClient([

            # lock_write

            (('ok', 'branch token', 'repo token'), ),

            # set_last_revision

            (('ok',), ),

            # unlock

            (('ok',), )],

            transport.base)

        bzrdir = RemoteBzrDir(transport, _client=False)

        branch = RemoteBranch(bzrdir, None, _client=client)

        # This is a hack to work around the problem that RemoteBranch currently

        # unnecessarily invokes _ensure_real upon a call to lock_write.

        branch._ensure_real = lambda: None

        # Lock the branch, reset the record of remote calls.

        branch.lock_write()

        client._calls = []

        result = branch.set_revision_history(['rev-id1', 'rev-id2'])

        self.assertEqual(

            [('call', 'Branch.set_last_revision',

                ('branch/', 'branch token', 'repo token', 'rev-id2'))],

            client._calls)

        branch.unlock()

        self.assertEqual(None, result)

    def test_no_such_revision(self):

        # A response of 'NoSuchRevision' is translated into an exception.

        client = FakeClient([

            # lock_write

            (('ok', 'branch token', 'repo token'), ),

            # set_last_revision

            (('NoSuchRevision', 'rev-id'), ),

            # unlock

            (('ok',), )])

        transport = MemoryTransport()

        transport.mkdir('branch')

        transport = transport.clone('branch')

        bzrdir = RemoteBzrDir(transport, _client=False)

        branch = RemoteBranch(bzrdir, None, _client=client)

        branch._ensure_real = lambda: None

        branch.lock_write()

        client._calls = []

        self.assertRaises(

            errors.NoSuchRevision, branch.set_revision_history, ['rev-id'])

        branch.unlock()

class TestBranchControlGetBranchConf(tests.TestCaseWithMemoryTransport):

    """Test branch.control_files api munging...

    We special case RemoteBranch.control_files.get('branch.conf') to

    call a specific API so that RemoteBranch's can intercept configuration

    file reading, allowing them to signal to the client about things like

    'email is configured for commits'.

    """

    def test_get_branch_conf(self):

        # in an empty branch we decode the response properly

        client = FakeClient([(('ok', ), 'config file body')], self.get_url())

        # we need to make a real branch because the remote_branch.control_files

        # will trigger _ensure_real.

        branch = self.make_branch('quack')

        transport = branch.bzrdir.root_transport

        # we do not want bzrdir to make any remote calls

        bzrdir = RemoteBzrDir(transport, _client=False)

        branch = RemoteBranch(bzrdir, None, _client=client)

        result = branch.control_files.get('branch.conf')

        self.assertEqual(

            [('call_expecting_body', 'Branch.get_config_file', ('quack/',))],

            client._calls)

        self.assertEqual('config file body', result.read())

class TestBranchLockWrite(tests.TestCase):

    def test_lock_write_unlockable(self):

        transport = MemoryTransport()

        client = FakeClient([(('UnlockableTransport', ), '')], transport.base)

        transport.mkdir('quack')

        transport = transport.clone('quack')

        # we do not want bzrdir to make any remote calls

        bzrdir = RemoteBzrDir(transport, _client=False)

        branch = RemoteBranch(bzrdir, None, _client=client)

        self.assertRaises(errors.UnlockableTransport, branch.lock_write)

        self.assertEqual(

            [('call', 'Branch.lock_write', ('quack/', '', ''))],

            client._calls)

class TestTransportIsReadonly(tests.TestCase):

    def test_true(self):

        client = FakeClient([(('yes',), '')])

        transport = RemoteTransport('bzr://example.com/', medium=False,

                                    _client=client)

        self.assertEqual(True, transport.is_readonly())

        self.assertEqual(

            [('call', 'Transport.is_readonly', ())],

            client._calls)

    def test_false(self):

        client = FakeClient([(('no',), '')])

        transport = RemoteTransport('bzr://example.com/', medium=False,

                                    _client=client)

        self.assertEqual(False, transport.is_readonly())

        self.assertEqual(

            [('call', 'Transport.is_readonly', ())],

            client._calls)

    def test_error_from_old_server(self):

        """bzr 0.15 and earlier servers don't recognise the is_readonly verb.

        Clients should treat it as a "no" response, because is_readonly is only

        advisory anyway (a transport could be read-write, but then the

        underlying filesystem could be readonly anyway).

        """

        client = FakeClient([(

            ('error', "Generic bzr smart protocol error: "

                      "bad request 'Transport.is_readonly'"), '')])

        transport = RemoteTransport('bzr://example.com/', medium=False,

                                    _client=client)

        self.assertEqual(False, transport.is_readonly())

        self.assertEqual(

            [('call', 'Transport.is_readonly', ())],

            client._calls)

    def test_error_from_old_0_11_server(self):

        """Same as test_error_from_old_server, but with the slightly different

        error message from bzr 0.11 servers.

        """

        client = FakeClient([(

            ('error', "Generic bzr smart protocol error: "

                      "bad request u'Transport.is_readonly'"), '')])

        transport = RemoteTransport('bzr://example.com/', medium=False,

                                    _client=client)

        self.assertEqual(False, transport.is_readonly())

        self.assertEqual(

            [('call', 'Transport.is_readonly', ())],

            client._calls)

class TestRemoteRepository(tests.TestCase):

    """Base for testing RemoteRepository protocol usage.

    These tests contain frozen requests and responses.  We want any changes to 

    what is sent or expected to be require a thoughtful update to these tests

    because they might break compatibility with different-versioned servers.

    """

    def setup_fake_client_and_repository(self, responses, transport_path):

        """Create the fake client and repository for testing with.

        There's no real server here; we just have canned responses sent

        back one by one.

        :param transport_path: Path below the root of the MemoryTransport

            where the repository will be created.

        """

        transport = MemoryTransport()

        transport.mkdir(transport_path)

        client = FakeClient(responses, transport.base)

        transport = transport.clone(transport_path)

        # we do not want bzrdir to make any remote calls

        bzrdir = RemoteBzrDir(transport, _client=False)

        repo = RemoteRepository(bzrdir, None, _client=client)

        return repo, client

class TestRepositoryGatherStats(TestRemoteRepository):

    def test_revid_none(self):

        # ('ok',), body with revisions and size

        responses = [(('ok', ), 'revisions: 2\nsize: 18\n')]

        transport_path = 'quack'

        repo, client = self.setup_fake_client_and_repository(

            responses, transport_path)

        result = repo.gather_stats(None)

        self.assertEqual(

            [('call_expecting_body', 'Repository.gather_stats',

             ('quack/','','no'))],

            client._calls)

        self.assertEqual({'revisions': 2, 'size': 18}, result)

    def test_revid_no_committers(self):

        # ('ok',), body without committers

        responses = [(('ok', ),

                      'firstrev: 123456.300 3600\n'

                      'latestrev: 654231.400 0\n'

                      'revisions: 2\n'

                      'size: 18\n')]

        transport_path = 'quick'

        revid = u'\xc8'.encode('utf8')

        repo, client = self.setup_fake_client_and_repository(

            responses, transport_path)

        result = repo.gather_stats(revid)

        self.assertEqual(

            [('call_expecting_body', 'Repository.gather_stats',

              ('quick/', revid, 'no'))],

            client._calls)

        self.assertEqual({'revisions': 2, 'size': 18,

                          'firstrev': (123456.300, 3600),

                          'latestrev': (654231.400, 0),},

                         result)

    def test_revid_with_committers(self):

        # ('ok',), body with committers

        responses = [(('ok', ),

                      'committers: 128\n'

                      'firstrev: 123456.300 3600\n'

                      'latestrev: 654231.400 0\n'

                      'revisions: 2\n'

                      'size: 18\n')]

        transport_path = 'buick'

        revid = u'\xc8'.encode('utf8')

        repo, client = self.setup_fake_client_and_repository(

            responses, transport_path)

        result = repo.gather_stats(revid, True)

        self.assertEqual(

            [('call_expecting_body', 'Repository.gather_stats',

              ('buick/', revid, 'yes'))],

            client._calls)

        self.assertEqual({'revisions': 2, 'size': 18,

                          'committers': 128,

                          'firstrev': (123456.300, 3600),

                          'latestrev': (654231.400, 0),},

                         result)

class TestRepositoryGetGraph(TestRemoteRepository):

    def test_get_graph(self):

        # get_graph returns a graph with the repository as the

        # parents_provider.

        responses = []

        transport_path = 'quack'

        repo, client = self.setup_fake_client_and_repository(

            responses, transport_path)

        graph = repo.get_graph()

        self.assertEqual(graph._parents_provider, repo)

class TestRepositoryGetParentMap(TestRemoteRepository):

    def test_get_parent_map_caching(self):

        # get_parent_map returns from cache until unlock()

        # setup a reponse with two revisions

        r1 = u'\u0e33'.encode('utf8')

        r2 = u'\u0dab'.encode('utf8')

        lines = [' '.join([r2, r1]), r1]