← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_versioning.py

[merge] jam-integration

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_versioning.py
22
22
 
23
23
import os
24
24
 
25
 
from bzrlib.selftest import BzrTestBase, TestCaseInTempDir
 
25
from bzrlib.tests import BzrTestBase, TestCaseInTempDir
26
26
from bzrlib.branch import Branch
27
 
 
28
 
import logging
29
 
logger = logging.getLogger('bzr.test.versioning')
30
 
debug = logger.debug
 
27
from bzrlib.trace import mutter
 
28
from bzrlib.osutils import pathjoin
31
29
 
32
30
 
33
31
class TestVersioning(TestCaseInTempDir):
34
32
    
35
33
    def test_mkdir(self): 
36
34
        """Basic 'bzr mkdir' operation"""
37
 
        from bzrlib.commands import run_bzr
38
35
 
39
 
        run_bzr(['init'])
40
 
        run_bzr(['mkdir', 'foo'])
 
36
        self.run_bzr('init')
 
37
        self.run_bzr('mkdir', 'foo')
41
38
        self.assert_(os.path.isdir('foo'))
42
39
 
43
 
        self.assertRaises(OSError, run_bzr, ['mkdir', 'foo'])
 
40
        self.run_bzr('mkdir', 'foo', retcode=3)
44
41
 
45
42
        from bzrlib.diff import compare_trees
46
43
        from bzrlib.branch import Branch
47
 
        b = Branch.open('.')
 
44
        b = Branch.open(u'.')
48
45
        
49
46
        delta = compare_trees(b.basis_tree(), b.working_tree())
50
47
 
54
51
        self.assertEquals(delta.added[0][0], 'foo')
55
52
        self.failIf(delta.modified)
56
53
 
57
 
    def test_branch_add_in_unversioned(self):
58
 
        """Try to add a file in an unversioned directory.
59
 
 
60
 
        "bzr add" adds the parent as necessary, but simple branch add
61
 
        doesn't do that.
62
 
        """
63
 
        from bzrlib.branch import Branch
64
 
        from bzrlib.errors import NotVersionedError
65
 
 
66
 
        b = Branch.initialize('.')
67
 
 
68
 
        self.build_tree(['foo/',
69
 
                         'foo/hello'])
70
 
 
71
 
        self.assertRaises(NotVersionedError,
72
 
                          b.add,
73
 
                          'foo/hello')
74
 
        
75
 
        self.check_branch()
76
 
 
77
 
 
78
 
    def test_add_in_unversioned(self):
79
 
        """Try to add a file in an unversioned directory.
80
 
 
81
 
        "bzr add" should add the parent(s) as necessary.
82
 
        """
83
 
        from bzrlib.branch import Branch
84
 
        from bzrlib.commands import run_bzr
85
 
        eq = self.assertEqual
86
 
 
87
 
        b = Branch.initialize('.')
88
 
 
89
 
        self.build_tree(['inertiatic/', 'inertiatic/esp'])
90
 
        eq(list(b.unknowns()), ['inertiatic'])
91
 
        run_bzr(['add', 'inertiatic/esp'])
92
 
        eq(list(b.unknowns()), [])
93
 
 
94
 
        # Multiple unversioned parents
95
 
        self.build_tree(['veil/', 'veil/cerpin/', 'veil/cerpin/taxt'])
96
 
        eq(list(b.unknowns()), ['veil'])
97
 
        run_bzr(['add', 'veil/cerpin/taxt'])
98
 
        eq(list(b.unknowns()), [])
99
 
 
100
 
        # Check whacky paths work
101
 
        self.build_tree(['cicatriz/', 'cicatriz/esp'])
102
 
        eq(list(b.unknowns()), ['cicatriz'])
103
 
        run_bzr(['add', 'inertiatic/../cicatriz/esp'])
104
 
        eq(list(b.unknowns()), [])
105
 
 
106
 
    def test_add_in_versioned(self):
107
 
        """Try to add a file in a versioned directory.
108
 
 
109
 
        "bzr add" should do this happily.
110
 
        """
111
 
        from bzrlib.branch import Branch
112
 
        from bzrlib.commands import run_bzr
113
 
        eq = self.assertEqual
114
 
 
115
 
        b = Branch.initialize('.')
116
 
 
117
 
        self.build_tree(['inertiatic/', 'inertiatic/esp'])
118
 
        eq(list(b.unknowns()), ['inertiatic'])
119
 
        run_bzr(['add', '--no-recurse', 'inertiatic'])
120
 
        eq(list(b.unknowns()), ['inertiatic'+os.sep+'esp'])
121
 
        run_bzr(['add', 'inertiatic/esp'])
122
 
        eq(list(b.unknowns()), [])
123
 
 
124
 
    def test_subdir_add(self):
125
 
        """Add in subdirectory should add only things from there down"""
126
 
        
127
 
        from bzrlib.branch import Branch
128
 
        from bzrlib.commands import run_bzr
129
 
        
130
 
        eq = self.assertEqual
131
 
        ass = self.assert_
132
 
        chdir = os.chdir
133
 
        
134
 
        b = Branch.initialize('.')
135
 
        self.build_tree(['src/', 'README'])
136
 
        
137
 
        eq(sorted(b.unknowns()),
138
 
           ['README', 'src'])
139
 
        
140
 
        eq(run_bzr(['add', 'src']), 0)
141
 
        
142
 
        self.build_tree(['src/foo.c'])
143
 
        
144
 
        chdir('src')
145
 
        eq(run_bzr(['add']), 0)
146
 
        
147
 
        eq(sorted(b.unknowns()), 
148
 
           ['README'])
149
 
        eq(len(b.inventory), 3)
150
 
                
151
 
        chdir('..')
152
 
        eq(run_bzr(['add']), 0)
153
 
        eq(list(b.unknowns()), [])
154
 
 
155
 
        self.check_branch()
156
 
 
 
54
    def test_mkdir_in_subdir(self):
 
55
        """'bzr mkdir' operation in subdirectory"""
 
56
 
 
57
        self.run_bzr('init')
 
58
        self.run_bzr('mkdir', 'dir')
 
59
        self.assert_(os.path.isdir('dir'))
 
60
 
 
61
        os.chdir('dir')
 
62
        self.log('Run mkdir in subdir')
 
63
        self.run_bzr('mkdir', 'subdir')
 
64
        self.assert_(os.path.isdir('subdir'))
 
65
        os.chdir('..')
 
66
 
 
67
        from bzrlib.diff import compare_trees
 
68
        from bzrlib.branch import Branch
 
69
        b = Branch.open(u'.')
 
70
        
 
71
        delta = compare_trees(b.basis_tree(), b.working_tree())
 
72
 
 
73
        self.log('delta.added = %r' % delta.added)
 
74
 
 
75
        self.assertEquals(len(delta.added), 2)
 
76
        self.assertEquals(delta.added[0][0], 'dir')
 
77
        self.assertEquals(delta.added[1][0], pathjoin('dir','subdir'))
 
78
        self.failIf(delta.modified)
 
79
 
 
80
    def test_mkdir_w_nested_trees(self):
 
81
        """'bzr mkdir' with nested trees"""
 
82
 
 
83
        self.run_bzr('init')
 
84
        os.mkdir('a')
 
85
        os.chdir('a')
 
86
        self.run_bzr('init')
 
87
        os.mkdir('b')
 
88
        os.chdir('b')
 
89
        self.run_bzr('init')
 
90
        os.chdir('../..')
 
91
 
 
92
        self.run_bzr('mkdir', 'dir', 'a/dir', 'a/b/dir')
 
93
        self.failUnless(os.path.isdir('dir'))
 
94
        self.failUnless(os.path.isdir('a/dir'))
 
95
        self.failUnless(os.path.isdir('a/b/dir'))
 
96
 
 
97
        from bzrlib.diff import compare_trees
 
98
        b = Branch.open(u'.')
 
99
        b_a = Branch.open('a')
 
100
        b_b = Branch.open('a/b')
 
101
        
 
102
        delta = compare_trees(b.basis_tree(), b.working_tree())
 
103
        self.assertEquals(len(delta.added), 1)
 
104
        self.assertEquals(delta.added[0][0], 'dir')
 
105
        self.failIf(delta.modified)
 
106
 
 
107
        delta = compare_trees(b_a.basis_tree(), b_a.working_tree())
 
108
        self.assertEquals(len(delta.added), 1)
 
109
        self.assertEquals(delta.added[0][0], 'dir')
 
110
        self.failIf(delta.modified)
 
111
 
 
112
        delta = compare_trees(b_b.basis_tree(), b_b.working_tree())
 
113
        self.assertEquals(len(delta.added), 1)
 
114
        self.assertEquals(delta.added[0][0], 'dir')
 
115
        self.failIf(delta.modified)
157
116
 
158
117
    def check_branch(self):
159
118
        """After all the above changes, run the check and upgrade commands.
160
119
 
161
120
        The upgrade should be a no-op."""
162
 
        b = Branch.open('.')
163
 
        debug('branch has %d revisions', b.revno())
 
121
        b = Branch.open(u'.')
 
122
        mutter('branch has %d revisions', b.revno())
164
123
        
165
 
        debug('check branch...')
 
124
        mutter('check branch...')
166
125
        from bzrlib.check import check
167
 
        check(b)
168
 
        
169
 
 
170
 
        
 
126
        check(b, False)
 
127
 
 
128
 
171
129
class SubdirCommit(TestCaseInTempDir):
172
130
 
173
131
    def test_subdir_commit(self):
178
136
        self.build_tree(['a/', 'b/'])
179
137
        
180
138
        run_bzr('init')
181
 
        b = Branch.open('.')
 
139
        b = Branch.open(u'.')
182
140
        
183
141
        for fn in ('a/one', 'b/two', 'top'):
184
142
            file(fn, 'w').write('old contents')
189
147
        for fn in ('a/one', 'b/two', 'top'):
190
148
            file(fn, 'w').write('new contents')
191
149
            
192
 
        debug('start selective subdir commit')
 
150
        mutter('start selective subdir commit')
193
151
        run_bzr('commit', 'a', '-m', 'commit a only')
194
152
        
195
 
        old = b.revision_tree(b.get_rev_id(1))
196
 
        new = b.revision_tree(b.get_rev_id(2))
 
153
        old = b.repository.revision_tree(b.get_rev_id(1))
 
154
        new = b.repository.revision_tree(b.get_rev_id(2))
197
155
        
198
156
        eq(new.get_file_by_path('b/two').read(), 'old contents')
199
157
        eq(new.get_file_by_path('top').read(), 'old contents')
202
160
        os.chdir('a')
203
161
        # commit from here should do nothing
204
162
        run_bzr('commit', '.', '-m', 'commit subdir only', '--unchanged')
205
 
        v3 = b.revision_tree(b.get_rev_id(3))
 
163
        v3 = b.repository.revision_tree(b.get_rev_id(3))
206
164
        eq(v3.get_file_by_path('b/two').read(), 'old contents')
207
165
        eq(v3.get_file_by_path('top').read(), 'old contents')
208
166
        eq(v3.get_file_by_path('a/one').read(), 'new contents')
209
167
                
210
168
        # commit in subdirectory commits whole tree
211
169
        run_bzr('commit', '-m', 'commit whole tree from subdir')
212
 
        v4 = b.revision_tree(b.get_rev_id(4))
 
170
        v4 = b.repository.revision_tree(b.get_rev_id(4))
213
171
        eq(v4.get_file_by_path('b/two').read(), 'new contents')        
214
172
        eq(v4.get_file_by_path('top').read(), 'new contents')
215
173