/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_read_bundle.py

  • Committer: John Arbash Meinel
  • Date: 2008-07-09 21:42:24 UTC
  • mto: This revision was merged to the branch mainline in revision 3543.
  • Revision ID: john@arbash-meinel.com-20080709214224-r75k87r6a01pfc3h
Restore a real weave merge to 'bzr merge --weave'.

To do so efficiently, we only add the simple LCAs to the final weave
object, unless we run into complexities with the merge graph.
This gives the same effective result as adding all the texts,
with the advantage of not having to extract all of them.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_read_bundle.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Test read_bundle works properly across various transports."""
18
18
 
23
23
from bzrlib.bundle.serializer import write_bundle
24
24
import bzrlib.bzrdir
25
25
import bzrlib.errors as errors
26
 
from bzrlib.symbol_versioning import deprecated_in
27
26
from bzrlib import tests
28
27
from bzrlib.tests.test_transport import TestTransportImplementation
29
 
from bzrlib.tests.per_transport import transport_test_permutations
 
28
from bzrlib.tests.test_transport_implementations import TransportTestProviderAdapter
30
29
import bzrlib.transport
31
30
from bzrlib.transport.memory import MemoryTransport
32
31
import bzrlib.urlutils
34
33
 
35
34
def load_tests(standard_tests, module, loader):
36
35
    """Multiply tests for tranport implementations."""
37
 
    transport_tests, remaining_tests = tests.split_suite_by_condition(
38
 
        standard_tests, tests.condition_isinstance(TestReadBundleFromURL))
39
 
    return tests.multiply_tests(transport_tests, transport_test_permutations(),
40
 
        remaining_tests)
 
36
    result = loader.suiteClass()
 
37
    adapter = TransportTestProviderAdapter()
 
38
    for test in tests.iter_suite_tests(standard_tests):
 
39
        result.addTests(adapter.adapt(test))
 
40
    return result
41
41
 
42
42
 
43
43
def create_bundle_file(test_case):
60
60
    return out, wt
61
61
 
62
62
 
63
 
class TestDeprecations(tests.TestCaseInTempDir):
64
 
 
65
 
    def create_test_bundle(self):
66
 
        out, wt = create_bundle_file(self)
67
 
        f = open('test_bundle', 'wb')
68
 
        try:
69
 
            f.write(out.getvalue())
70
 
        finally:
71
 
            f.close()
72
 
        return wt
73
 
 
74
 
    def test_read_bundle_from_url_deprecated(self):
75
 
        wt = self.create_test_bundle()
76
 
        t = bzrlib.transport.get_transport(self.test_dir)
77
 
        url = t.abspath('test_bundle')
78
 
        self.callDeprecated([deprecated_in((1, 12, 0))
79
 
                             % 'bzrlib.bundle.read_bundle_from_url'],
80
 
                            bzrlib.bundle.read_bundle_from_url,
81
 
                            url)
82
 
 
83
 
 
84
63
class TestReadBundleFromURL(TestTransportImplementation):
85
64
    """Test that read_bundle works properly across multiple transports"""
86
65
 
87
 
    def setUp(self):
88
 
        super(TestReadBundleFromURL, self).setUp()
89
 
        self.bundle_name = 'test_bundle'
90
 
        # read_mergeable_from_url will invoke get_transport which may *not*
91
 
        # respect self._transport (i.e. returns a transport that is different
92
 
        # from the one we want to test, so we must inject a correct transport
93
 
        # into possible_transports first).
94
 
        self.possible_transports = [self.get_transport(self.bundle_name)]
95
 
        self._captureVar('BZR_NO_SMART_VFS', None)
96
 
        wt = self.create_test_bundle()
97
 
 
98
 
    def read_mergeable_from_url(self, url):
99
 
        return bzrlib.bundle.read_mergeable_from_url(
100
 
            url, possible_transports=self.possible_transports)
101
 
 
102
66
    def get_url(self, relpath=''):
103
67
        return bzrlib.urlutils.join(self._server.get_url(), relpath)
104
68
 
105
69
    def create_test_bundle(self):
106
70
        out, wt = create_bundle_file(self)
107
71
        if self.get_transport().is_readonly():
108
 
            self.build_tree_contents([(self.bundle_name, out.getvalue())])
 
72
            f = open('test_bundle', 'wb')
 
73
            f.write(out.getvalue())
 
74
            f.close()
109
75
        else:
110
 
            self.get_transport().put_file(self.bundle_name, out)
111
 
            self.log('Put to: %s', self.get_url(self.bundle_name))
 
76
            self.get_transport().put_file('test_bundle', out)
 
77
            self.log('Put to: %s', self.get_url('test_bundle'))
112
78
        return wt
113
79
 
114
 
    def test_read_mergeable_from_url(self):
115
 
        info = self.read_mergeable_from_url(
116
 
            unicode(self.get_url(self.bundle_name)))
 
80
    def test_read_bundle_from_url(self):
 
81
        self._captureVar('BZR_NO_SMART_VFS', None)
 
82
        wt = self.create_test_bundle()
 
83
        if wt is None:
 
84
            return
 
85
        info = bzrlib.bundle.read_bundle_from_url(
 
86
                    unicode(self.get_url('test_bundle')))
117
87
        revision = info.real_revisions[-1]
118
88
        self.assertEqual('commit-1', revision.revision_id)
119
89
 
120
90
    def test_read_fail(self):
121
91
        # Trying to read from a directory, or non-bundle file
122
92
        # should fail with NotABundle
123
 
        self.assertRaises(errors.NotABundle,
124
 
                          self.read_mergeable_from_url, self.get_url('tree'))
125
 
        self.assertRaises(errors.NotABundle,
126
 
                          self.read_mergeable_from_url, self.get_url('tree/a'))
127
 
 
128
 
    def test_read_mergeable_respects_possible_transports(self):
129
 
        if not isinstance(self.get_transport(self.bundle_name),
130
 
                          bzrlib.transport.ConnectedTransport):
131
 
            # There is no point testing transport reuse for not connected
132
 
            # transports (the test will fail even).
133
 
            raise tests.TestSkipped(
134
 
                'Need a ConnectedTransport to test transport reuse')
135
 
        url = unicode(self.get_url(self.bundle_name))
136
 
        info = self.read_mergeable_from_url(url)
137
 
        self.assertEqual(1, len(self.possible_transports))
 
93
        self._captureVar('BZR_NO_SMART_VFS', None)
 
94
        wt = self.create_test_bundle()
 
95
        if wt is None:
 
96
            return
 
97
 
 
98
        self.assertRaises(errors.NotABundle, 
 
99
            bzrlib.bundle.read_bundle_from_url, 
 
100
            self.get_url('tree'))
 
101
        self.assertRaises(errors.NotABundle, 
 
102
            bzrlib.bundle.read_bundle_from_url, 
 
103
            self.get_url('tree/a'))
 
104
 
 
105
    def test_read_mergeable_populates_possible_transports(self):
 
106
        self._captureVar('BZR_NO_SMART_VFS', None)
 
107
        wt = self.create_test_bundle()
 
108
        if wt is None:
 
109
            return
 
110
        possible_transports = []
 
111
        url = unicode(self.get_url('test_bundle'))
 
112
        info = bzrlib.bundle.read_mergeable_from_url(url,
 
113
            possible_transports=possible_transports)
 
114
        self.assertEqual(1, len(possible_transports))