/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/blackbox/test_checkout.py

  • Committer: Robert Collins
  • Date: 2010-05-05 00:05:29 UTC
  • mto: This revision was merged to the branch mainline in revision 5206.
  • Revision ID: robertc@robertcollins.net-20100505000529-ltmllyms5watqj5u
Make 'pydoc bzrlib.tests.build_tree_shape' useful.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_checkout.py
1
 
# Copyright (C) 2006, 2007, 2009-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2006, 2007, 2009, 2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Tests for the 'checkout' CLI command."""
18
18
 
 
19
from cStringIO import StringIO
19
20
import os
 
21
import re
 
22
import shutil
 
23
import sys
20
24
 
21
 
from breezy import (
 
25
from bzrlib import (
22
26
    branch as _mod_branch,
23
 
    controldir,
 
27
    bzrdir,
24
28
    errors,
25
29
    workingtree,
26
30
    )
27
 
from breezy.bzr import (
28
 
    bzrdir,
29
 
    )
30
 
from breezy.tests import (
31
 
    TestCaseWithTransport,
32
 
    )
33
 
from breezy.tests.matchers import ContainsNoVfsCalls
34
 
from breezy.tests.features import (
 
31
from bzrlib.tests.blackbox import (
 
32
    ExternalBase,
 
33
    )
 
34
from bzrlib.tests import (
35
35
    HardlinkFeature,
 
36
    KnownFailure,
36
37
    )
37
38
 
38
39
 
39
 
class TestCheckout(TestCaseWithTransport):
 
40
class TestCheckout(ExternalBase):
40
41
 
41
42
    def setUp(self):
42
43
        super(TestCheckout, self).setUp()
43
 
        tree = controldir.ControlDir.create_standalone_workingtree('branch')
44
 
        tree.commit('1', rev_id=b'1', allow_pointless=True)
 
44
        tree = bzrdir.BzrDir.create_standalone_workingtree('branch')
 
45
        tree.commit('1', rev_id='1', allow_pointless=True)
45
46
        self.build_tree(['branch/added_in_2'])
46
47
        tree.add('added_in_2')
47
 
        tree.commit('2', rev_id=b'2')
 
48
        tree.commit('2', rev_id='2')
48
49
 
49
50
    def test_checkout_makes_bound_branch(self):
50
51
        self.run_bzr('checkout branch checkout')
51
52
        # if we have a checkout, the branch base should be 'branch'
52
 
        source = controldir.ControlDir.open('branch')
53
 
        result = controldir.ControlDir.open('checkout')
54
 
        self.assertEqual(source.open_branch().controldir.root_transport.base,
 
53
        source = bzrdir.BzrDir.open('branch')
 
54
        result = bzrdir.BzrDir.open('checkout')
 
55
        self.assertEqual(source.open_branch().bzrdir.root_transport.base,
55
56
                         result.open_branch().get_bound_location())
56
57
 
57
58
    def test_checkout_light_makes_checkout(self):
58
59
        self.run_bzr('checkout --lightweight branch checkout')
59
60
        # if we have a checkout, the branch base should be 'branch'
60
 
        source = controldir.ControlDir.open('branch')
61
 
        result = controldir.ControlDir.open('checkout')
62
 
        self.assertEqual(source.open_branch().controldir.root_transport.base,
63
 
                         result.open_branch().controldir.root_transport.base)
 
61
        source = bzrdir.BzrDir.open('branch')
 
62
        result = bzrdir.BzrDir.open('checkout')
 
63
        self.assertEqual(source.open_branch().bzrdir.root_transport.base,
 
64
                         result.open_branch().bzrdir.root_transport.base)
64
65
 
65
66
    def test_checkout_dash_r(self):
66
 
        out, err = self.run_bzr(['checkout', '-r', '-2', 'branch', 'checkout'])
 
67
        self.run_bzr('checkout -r -2 branch checkout')
67
68
        # the working tree should now be at revision '1' with the content
68
69
        # from 1.
69
 
        result = controldir.ControlDir.open('checkout')
70
 
        self.assertEqual([b'1'], result.open_workingtree().get_parent_ids())
71
 
        self.assertPathDoesNotExist('checkout/added_in_2')
 
70
        result = bzrdir.BzrDir.open('checkout')
 
71
        self.assertEqual(['1'], result.open_workingtree().get_parent_ids())
 
72
        self.failIfExists('checkout/added_in_2')
72
73
 
73
74
    def test_checkout_light_dash_r(self):
74
 
        out, err = self.run_bzr(['checkout', '--lightweight', '-r', '-2',
75
 
                                 'branch', 'checkout'])
 
75
        self.run_bzr('checkout --lightweight -r -2 branch checkout')
76
76
        # the working tree should now be at revision '1' with the content
77
77
        # from 1.
78
 
        result = controldir.ControlDir.open('checkout')
79
 
        self.assertEqual([b'1'], result.open_workingtree().get_parent_ids())
80
 
        self.assertPathDoesNotExist('checkout/added_in_2')
81
 
 
82
 
    def test_checkout_into_empty_dir(self):
83
 
        self.make_controldir('checkout')
84
 
        out, err = self.run_bzr(['checkout', 'branch', 'checkout'])
85
 
        result = controldir.ControlDir.open('checkout')
86
 
        tree = result.open_workingtree()
87
 
        branch = result.open_branch()
 
78
        result = bzrdir.BzrDir.open('checkout')
 
79
        self.assertEqual(['1'], result.open_workingtree().get_parent_ids())
 
80
        self.failIfExists('checkout/added_in_2')
88
81
 
89
82
    def test_checkout_reconstitutes_working_trees(self):
90
 
        # doing a 'brz checkout' in the directory of a branch with no tree
91
 
        # or a 'brz checkout path' with path the name of a directory with
 
83
        # doing a 'bzr checkout' in the directory of a branch with no tree
 
84
        # or a 'bzr checkout path' with path the name of a directory with
92
85
        # a branch with no tree will reconsistute the tree.
93
86
        os.mkdir('treeless-branch')
94
 
        branch = controldir.ControlDir.create_branch_convenience(
 
87
        branch = bzrdir.BzrDir.create_branch_convenience(
95
88
            'treeless-branch',
96
89
            force_new_tree=False,
97
90
            format=bzrdir.BzrDirMetaFormat1())
98
91
        # check no tree was created
99
 
        self.assertRaises(errors.NoWorkingTree,
100
 
                          branch.controldir.open_workingtree)
 
92
        self.assertRaises(errors.NoWorkingTree, branch.bzrdir.open_workingtree)
101
93
        out, err = self.run_bzr('checkout treeless-branch')
102
94
        # we should have a tree now
103
 
        branch.controldir.open_workingtree()
 
95
        branch.bzrdir.open_workingtree()
104
96
        # with no diff
105
97
        out, err = self.run_bzr('diff treeless-branch')
106
98
 
107
99
        # now test with no parameters
108
 
        branch = controldir.ControlDir.create_branch_convenience(
 
100
        branch = bzrdir.BzrDir.create_branch_convenience(
109
101
            '.',
110
102
            force_new_tree=False,
111
103
            format=bzrdir.BzrDirMetaFormat1())
112
104
        # check no tree was created
113
 
        self.assertRaises(errors.NoWorkingTree,
114
 
                          branch.controldir.open_workingtree)
 
105
        self.assertRaises(errors.NoWorkingTree, branch.bzrdir.open_workingtree)
115
106
        out, err = self.run_bzr('checkout')
116
107
        # we should have a tree now
117
 
        branch.controldir.open_workingtree()
 
108
        branch.bzrdir.open_workingtree()
118
109
        # with no diff
119
110
        out, err = self.run_bzr('diff')
120
111
 
121
112
    def _test_checkout_existing_dir(self, lightweight):
122
113
        source = self.make_branch_and_tree('source')
123
 
        self.build_tree_contents([('source/file1', b'content1'),
124
 
                                  ('source/file2', b'content2'), ])
 
114
        self.build_tree_contents([('source/file1', 'content1'),
 
115
                                  ('source/file2', 'content2'),])
125
116
        source.add(['file1', 'file2'])
126
117
        source.commit('added files')
127
 
        self.build_tree_contents([('target/', b''),
128
 
                                  ('target/file1', b'content1'),
129
 
                                  ('target/file2', b'content3'), ])
 
118
        self.build_tree_contents([('target/', ''),
 
119
                                  ('target/file1', 'content1'),
 
120
                                  ('target/file2', 'content3'),])
130
121
        cmd = ['checkout', 'source', 'target']
131
122
        if lightweight:
132
123
            cmd.append('--lightweight')
133
124
        self.run_bzr('checkout source target')
134
125
        # files with unique content should be moved
135
 
        self.assertPathExists('target/file2.moved')
 
126
        self.failUnlessExists('target/file2.moved')
136
127
        # files with content matching tree should not be moved
137
 
        self.assertPathDoesNotExist('target/file1.moved')
 
128
        self.failIfExists('target/file1.moved')
138
129
 
139
130
    def test_checkout_existing_dir_heavy(self):
140
131
        self._test_checkout_existing_dir(False)
144
135
 
145
136
    def test_checkout_in_branch_with_r(self):
146
137
        branch = _mod_branch.Branch.open('branch')
147
 
        branch.controldir.destroy_workingtree()
148
 
        self.run_bzr('checkout -r 1', working_dir='branch')
149
 
        tree = workingtree.WorkingTree.open('branch')
150
 
        self.assertEqual(b'1', tree.last_revision())
151
 
        branch.controldir.destroy_workingtree()
152
 
        self.run_bzr('checkout -r 0', working_dir='branch')
153
 
        self.assertEqual(b'null:', tree.last_revision())
 
138
        branch.bzrdir.destroy_workingtree()
 
139
        os.chdir('branch')
 
140
        self.run_bzr('checkout -r 1')
 
141
        tree = workingtree.WorkingTree.open('.')
 
142
        self.assertEqual('1', tree.last_revision())
 
143
        branch.bzrdir.destroy_workingtree()
 
144
        self.run_bzr('checkout -r 0')
 
145
        self.assertEqual('null:', tree.last_revision())
154
146
 
155
147
    def test_checkout_files_from(self):
156
148
        branch = _mod_branch.Branch.open('branch')
163
155
        self.build_tree(['source/file1'])
164
156
        source.add('file1')
165
157
        source.commit('added file')
166
 
        out, err = self.run_bzr('checkout source target --hardlink')
 
158
        out, err = self.run_bzr(['checkout', 'source', 'target',
 
159
            '--files-from', 'source',
 
160
            '--hardlink'])
167
161
        source_stat = os.stat('source/file1')
168
162
        target_stat = os.stat('target/file1')
169
163
        self.assertEqual(source_stat, target_stat)
170
 
 
171
 
    def test_checkout_hardlink_files_from(self):
172
 
        self.requireFeature(HardlinkFeature)
173
 
        source = self.make_branch_and_tree('source')
174
 
        self.build_tree(['source/file1'])
175
 
        source.add('file1')
176
 
        source.commit('added file')
177
 
        source.controldir.sprout('second')
178
 
        out, err = self.run_bzr('checkout source target --hardlink'
179
 
                                ' --files-from second')
180
 
        second_stat = os.stat('second/file1')
181
 
        target_stat = os.stat('target/file1')
182
 
        self.assertEqual(second_stat, target_stat)
183
 
 
184
 
    def test_colo_checkout(self):
185
 
        source = self.make_branch_and_tree('source', format='development-colo')
186
 
        self.build_tree(['source/file1'])
187
 
        source.add('file1')
188
 
        source.commit('added file')
189
 
        target = source.controldir.sprout('file:second,branch=somebranch',
190
 
                                          create_tree_if_local=False)
191
 
        out, err = self.run_bzr('checkout file:,branch=somebranch .',
192
 
                                working_dir='second')
193
 
        # We should always be creating a lighweight checkout for colocated
194
 
        # branches.
195
 
        self.assertEqual(
196
 
            target.open_branch(name='somebranch').user_url,
197
 
            target.get_branch_reference(name=""))
198
 
 
199
 
 
200
 
class TestSmartServerCheckout(TestCaseWithTransport):
201
 
 
202
 
    def test_heavyweight_checkout(self):
203
 
        self.setup_smart_server_with_call_log()
204
 
        t = self.make_branch_and_tree('from')
205
 
        for count in range(9):
206
 
            t.commit(message='commit %d' % count)
207
 
        self.reset_smart_call_log()
208
 
        out, err = self.run_bzr(['checkout', self.get_url('from'), 'target'])
209
 
        # This figure represent the amount of work to perform this use case. It
210
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
211
 
        # being too low. If rpc_count increases, more network roundtrips have
212
 
        # become necessary for this use case. Please do not adjust this number
213
 
        # upwards without agreement from bzr's network support maintainers.
214
 
        self.assertLength(11, self.hpss_calls)
215
 
        self.assertLength(1, self.hpss_connections)
216
 
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)
217
 
 
218
 
    def test_lightweight_checkout(self):
219
 
        self.setup_smart_server_with_call_log()
220
 
        t = self.make_branch_and_tree('from')
221
 
        for count in range(9):
222
 
            t.commit(message='commit %d' % count)
223
 
        self.reset_smart_call_log()
224
 
        out, err = self.run_bzr(['checkout', '--lightweight', self.get_url('from'),
225
 
                                 'target'])
226
 
        # This figure represent the amount of work to perform this use case. It
227
 
        # is entirely ok to reduce this number if a test fails due to rpc_count
228
 
        # being too low. If rpc_count increases, more network roundtrips have
229
 
        # become necessary for this use case. Please do not adjust this number
230
 
        # upwards without agreement from bzr's network support maintainers.
231
 
        self.assertLength(13, self.hpss_calls)
232
 
        self.assertThat(self.hpss_calls, ContainsNoVfsCalls)