/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: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

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
from bzrlib.tests import (
31
32
    TestCaseWithTransport,
32
33
    )
33
 
from breezy.tests.matchers import ContainsNoVfsCalls
34
 
from breezy.tests.features import (
 
34
from bzrlib.tests import (
35
35
    HardlinkFeature,
 
36
    KnownFailure,
36
37
    )
37
38
 
38
39
 
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
67
        out, err = 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
        out, err = self.run_bzr(['checkout','--lightweight', '-r', '-2',
 
76
            'branch', 'checkout'])
76
77
        # the working tree should now be at revision '1' with the content
77
78
        # 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()
 
79
        result = bzrdir.BzrDir.open('checkout')
 
80
        self.assertEqual(['1'], result.open_workingtree().get_parent_ids())
 
81
        self.failIfExists('checkout/added_in_2')
88
82
 
89
83
    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
 
84
        # doing a 'bzr checkout' in the directory of a branch with no tree
 
85
        # or a 'bzr checkout path' with path the name of a directory with
92
86
        # a branch with no tree will reconsistute the tree.
93
87
        os.mkdir('treeless-branch')
94
 
        branch = controldir.ControlDir.create_branch_convenience(
 
88
        branch = bzrdir.BzrDir.create_branch_convenience(
95
89
            'treeless-branch',
96
90
            force_new_tree=False,
97
91
            format=bzrdir.BzrDirMetaFormat1())
98
92
        # check no tree was created
99
 
        self.assertRaises(errors.NoWorkingTree,
100
 
                          branch.controldir.open_workingtree)
 
93
        self.assertRaises(errors.NoWorkingTree, branch.bzrdir.open_workingtree)
101
94
        out, err = self.run_bzr('checkout treeless-branch')
102
95
        # we should have a tree now
103
 
        branch.controldir.open_workingtree()
 
96
        branch.bzrdir.open_workingtree()
104
97
        # with no diff
105
98
        out, err = self.run_bzr('diff treeless-branch')
106
99
 
107
100
        # now test with no parameters
108
 
        branch = controldir.ControlDir.create_branch_convenience(
 
101
        branch = bzrdir.BzrDir.create_branch_convenience(
109
102
            '.',
110
103
            force_new_tree=False,
111
104
            format=bzrdir.BzrDirMetaFormat1())
112
105
        # check no tree was created
113
 
        self.assertRaises(errors.NoWorkingTree,
114
 
                          branch.controldir.open_workingtree)
 
106
        self.assertRaises(errors.NoWorkingTree, branch.bzrdir.open_workingtree)
115
107
        out, err = self.run_bzr('checkout')
116
108
        # we should have a tree now
117
 
        branch.controldir.open_workingtree()
 
109
        branch.bzrdir.open_workingtree()
118
110
        # with no diff
119
111
        out, err = self.run_bzr('diff')
120
112
 
121
113
    def _test_checkout_existing_dir(self, lightweight):
122
114
        source = self.make_branch_and_tree('source')
123
 
        self.build_tree_contents([('source/file1', b'content1'),
124
 
                                  ('source/file2', b'content2'), ])
 
115
        self.build_tree_contents([('source/file1', 'content1'),
 
116
                                  ('source/file2', 'content2'),])
125
117
        source.add(['file1', 'file2'])
126
118
        source.commit('added files')
127
 
        self.build_tree_contents([('target/', b''),
128
 
                                  ('target/file1', b'content1'),
129
 
                                  ('target/file2', b'content3'), ])
 
119
        self.build_tree_contents([('target/', ''),
 
120
                                  ('target/file1', 'content1'),
 
121
                                  ('target/file2', 'content3'),])
130
122
        cmd = ['checkout', 'source', 'target']
131
123
        if lightweight:
132
124
            cmd.append('--lightweight')
133
125
        self.run_bzr('checkout source target')
134
126
        # files with unique content should be moved
135
 
        self.assertPathExists('target/file2.moved')
 
127
        self.failUnlessExists('target/file2.moved')
136
128
        # files with content matching tree should not be moved
137
 
        self.assertPathDoesNotExist('target/file1.moved')
 
129
        self.failIfExists('target/file1.moved')
138
130
 
139
131
    def test_checkout_existing_dir_heavy(self):
140
132
        self._test_checkout_existing_dir(False)
144
136
 
145
137
    def test_checkout_in_branch_with_r(self):
146
138
        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())
 
139
        branch.bzrdir.destroy_workingtree()
 
140
        os.chdir('branch')
 
141
        self.run_bzr('checkout -r 1')
 
142
        tree = workingtree.WorkingTree.open('.')
 
143
        self.assertEqual('1', tree.last_revision())
 
144
        branch.bzrdir.destroy_workingtree()
 
145
        self.run_bzr('checkout -r 0')
 
146
        self.assertEqual('null:', tree.last_revision())
154
147
 
155
148
    def test_checkout_files_from(self):
156
149
        branch = _mod_branch.Branch.open('branch')
163
156
        self.build_tree(['source/file1'])
164
157
        source.add('file1')
165
158
        source.commit('added file')
166
 
        out, err = self.run_bzr('checkout source target --hardlink')
 
159
        out, err = self.run_bzr(['checkout', 'source', 'target',
 
160
            '--files-from', 'source',
 
161
            '--hardlink'])
167
162
        source_stat = os.stat('source/file1')
168
163
        target_stat = os.stat('target/file1')
169
164
        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)