/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_versioning.py

Merge from mbp.

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
31
28
 
32
29
 
33
30
class TestVersioning(TestCaseInTempDir):
34
31
    
35
32
    def test_mkdir(self): 
36
33
        """Basic 'bzr mkdir' operation"""
37
 
        from bzrlib.commands import run_bzr
38
34
 
39
 
        run_bzr(['init'])
40
 
        run_bzr(['mkdir', 'foo'])
 
35
        self.run_bzr('init')
 
36
        self.run_bzr('mkdir', 'foo')
41
37
        self.assert_(os.path.isdir('foo'))
42
38
 
43
 
        self.assertRaises(OSError, run_bzr, ['mkdir', 'foo'])
 
39
        self.run_bzr('mkdir', 'foo', retcode=3)
44
40
 
45
41
        from bzrlib.diff import compare_trees
46
42
        from bzrlib.branch import Branch
47
 
        b = Branch.open('.')
 
43
        b = Branch.open(u'.')
48
44
        
49
45
        delta = compare_trees(b.basis_tree(), b.working_tree())
50
46
 
54
50
        self.assertEquals(delta.added[0][0], 'foo')
55
51
        self.failIf(delta.modified)
56
52
 
57
 
    def test_branch_add_in_unversioned(self):
 
53
    def test_mkdir_in_subdir(self):
 
54
        """'bzr mkdir' operation in subdirectory"""
 
55
 
 
56
        self.run_bzr('init')
 
57
        self.run_bzr('mkdir', 'dir')
 
58
        self.assert_(os.path.isdir('dir'))
 
59
 
 
60
        os.chdir('dir')
 
61
        self.log('Run mkdir in subdir')
 
62
        self.run_bzr('mkdir', 'subdir')
 
63
        self.assert_(os.path.isdir('subdir'))
 
64
        os.chdir('..')
 
65
 
 
66
        from bzrlib.diff import compare_trees
 
67
        from bzrlib.branch import Branch
 
68
        b = Branch.open(u'.')
 
69
        
 
70
        delta = compare_trees(b.basis_tree(), b.working_tree())
 
71
 
 
72
        self.log('delta.added = %r' % delta.added)
 
73
 
 
74
        self.assertEquals(len(delta.added), 2)
 
75
        self.assertEquals(delta.added[0][0], 'dir')
 
76
        self.assertEquals(delta.added[1][0], os.path.join('dir','subdir'))
 
77
        self.failIf(delta.modified)
 
78
 
 
79
    def test_mkdir_w_nested_trees(self):
 
80
        """'bzr mkdir' with nested trees"""
 
81
 
 
82
        self.run_bzr('init')
 
83
        os.mkdir('a')
 
84
        os.chdir('a')
 
85
        self.run_bzr('init')
 
86
        os.mkdir('b')
 
87
        os.chdir('b')
 
88
        self.run_bzr('init')
 
89
        os.chdir('../..')
 
90
 
 
91
        self.run_bzr('mkdir', 'dir', 'a/dir', 'a/b/dir')
 
92
        self.failUnless(os.path.isdir('dir'))
 
93
        self.failUnless(os.path.isdir('a/dir'))
 
94
        self.failUnless(os.path.isdir('a/b/dir'))
 
95
 
 
96
        from bzrlib.diff import compare_trees
 
97
        b = Branch.open(u'.')
 
98
        b_a = Branch.open('a')
 
99
        b_b = Branch.open('a/b')
 
100
        
 
101
        delta = compare_trees(b.basis_tree(), b.working_tree())
 
102
        self.assertEquals(len(delta.added), 1)
 
103
        self.assertEquals(delta.added[0][0], 'dir')
 
104
        self.failIf(delta.modified)
 
105
 
 
106
        delta = compare_trees(b_a.basis_tree(), b_a.working_tree())
 
107
        self.assertEquals(len(delta.added), 1)
 
108
        self.assertEquals(delta.added[0][0], 'dir')
 
109
        self.failIf(delta.modified)
 
110
 
 
111
        delta = compare_trees(b_b.basis_tree(), b_b.working_tree())
 
112
        self.assertEquals(len(delta.added), 1)
 
113
        self.assertEquals(delta.added[0][0], 'dir')
 
114
        self.failIf(delta.modified)
 
115
 
 
116
    def test_working_tree_add_in_unversioned(self):
58
117
        """Try to add a file in an unversioned directory.
59
118
 
60
 
        "bzr add" adds the parent as necessary, but simple branch add
 
119
        "bzr add" adds the parent as necessary, but simple working tree add
61
120
        doesn't do that.
62
121
        """
63
122
        from bzrlib.branch import Branch
64
123
        from bzrlib.errors import NotVersionedError
 
124
        from bzrlib.workingtree import WorkingTree
65
125
 
66
 
        b = Branch.initialize('.')
 
126
        b = Branch.initialize(u'.')
67
127
 
68
128
        self.build_tree(['foo/',
69
129
                         'foo/hello'])
70
130
 
71
131
        self.assertRaises(NotVersionedError,
72
 
                          b.add,
 
132
                          WorkingTree(b.base, b).add,
73
133
                          'foo/hello')
74
134
        
75
 
        self.check_and_upgrade()
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/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_and_upgrade()
156
 
 
157
 
 
158
 
    def check_and_upgrade(self):
 
135
        self.check_branch()
 
136
 
 
137
    def check_branch(self):
159
138
        """After all the above changes, run the check and upgrade commands.
160
139
 
161
140
        The upgrade should be a no-op."""
162
 
        b = Branch.open('.')
163
 
        debug('branch has %d revisions', b.revno())
164
 
        
165
 
        debug('check branch...')
166
 
        from bzrlib.check import check
167
 
        check(b)
168
 
        
169
 
        debug('upgrade branch...')
170
 
        from bzrlib.upgrade import upgrade
171
 
        upgrade(b)
172
 
        
173
 
        debug('check branch...')
174
 
        from bzrlib.check import check
175
 
        check(b)
176
 
        
177
 
 
178
 
        
 
141
        b = Branch.open(u'.')
 
142
        mutter('branch has %d revisions', b.revno())
 
143
        
 
144
        mutter('check branch...')
 
145
        from bzrlib.check import check
 
146
        check(b, False)
 
147
 
 
148
 
179
149
class SubdirCommit(TestCaseInTempDir):
180
150
 
181
151
    def test_subdir_commit(self):
186
156
        self.build_tree(['a/', 'b/'])
187
157
        
188
158
        run_bzr('init')
189
 
        b = Branch.open('.')
 
159
        b = Branch.open(u'.')
190
160
        
191
161
        for fn in ('a/one', 'b/two', 'top'):
192
162
            file(fn, 'w').write('old contents')
197
167
        for fn in ('a/one', 'b/two', 'top'):
198
168
            file(fn, 'w').write('new contents')
199
169
            
 
170
        mutter('start selective subdir commit')
200
171
        run_bzr('commit', 'a', '-m', 'commit a only')
201
172
        
202
173
        old = b.revision_tree(b.get_rev_id(1))
222
193
        
223
194
        # TODO: factor out some kind of assert_tree_state() method
224
195
        
 
196
 
 
197
if __name__ == '__main__':
 
198
    import unittest
 
199
    unittest.main()
 
200