~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/versioning.py

  • Committer: Robert Collins
  • Date: 2005-08-25 01:13:32 UTC
  • mto: (974.1.50) (1185.1.10) (1092.3.1)
  • mto: This revision was merged to the branch mainline in revision 1139.
  • Revision ID: robertc@robertcollins.net-20050825011331-6d549d5de7edcec1
two bugfixes to smart_add - do not add paths from nested trees to the parent tree, and do not mutate the user supplied file list

Show diffs side-by-side

added added

removed removed

Lines of Context:
17
17
 
18
18
"""Tests of simple versioning operations"""
19
19
 
 
20
# TODO: test adding a file whose directory is not versioned
20
21
# TODO: test trying to commit within a directory that is not yet added
21
22
 
22
23
 
23
24
import os
24
 
 
25
 
from bzrlib.tests import BzrTestBase, TestCaseInTempDir
 
25
from bzrlib.selftest import InTempDir, BzrTestBase
26
26
from bzrlib.branch import Branch
27
 
from bzrlib.trace import mutter
28
 
from bzrlib.osutils import pathjoin
29
 
 
30
 
 
31
 
class TestVersioning(TestCaseInTempDir):
 
27
 
 
28
 
 
29
class TestVersioning(InTempDir):
32
30
    
33
31
    def test_mkdir(self): 
34
32
        """Basic 'bzr mkdir' operation"""
 
33
        from bzrlib.commands import run_bzr
35
34
 
36
 
        self.run_bzr('init')
37
 
        self.run_bzr('mkdir', 'foo')
 
35
        run_bzr(['init'])
 
36
        run_bzr(['mkdir', 'foo'])
38
37
        self.assert_(os.path.isdir('foo'))
39
38
 
40
 
        self.run_bzr('mkdir', 'foo', retcode=3)
 
39
        self.assertRaises(OSError, run_bzr, ['mkdir', 'foo'])
41
40
 
42
41
        from bzrlib.diff import compare_trees
43
42
        from bzrlib.branch import Branch
44
 
        b = Branch.open(u'.')
 
43
        b = Branch('.')
45
44
        
46
45
        delta = compare_trees(b.basis_tree(), b.working_tree())
47
46
 
51
50
        self.assertEquals(delta.added[0][0], 'foo')
52
51
        self.failIf(delta.modified)
53
52
 
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)
116
 
 
117
 
    def test_working_tree_add_in_unversioned(self):
 
53
    def test_add_in_unversioned(self):
118
54
        """Try to add a file in an unversioned directory.
119
55
 
120
 
        "bzr add" adds the parent as necessary, but simple working tree add
121
 
        doesn't do that.
 
56
        smart_add may eventually add the parent as necessary, but simple
 
57
        branch add doesn't do that.
122
58
        """
123
59
        from bzrlib.branch import Branch
124
60
        from bzrlib.errors import NotVersionedError
125
 
        from bzrlib.workingtree import WorkingTree
126
61
 
127
 
        b = Branch.initialize(u'.')
 
62
        b = Branch('.', init=True)
128
63
 
129
64
        self.build_tree(['foo/',
130
65
                         'foo/hello'])
131
66
 
132
67
        self.assertRaises(NotVersionedError,
133
 
                          WorkingTree(b.base, b).add,
 
68
                          b.add,
134
69
                          'foo/hello')
135
70
        
136
 
        self.check_branch()
137
 
 
138
 
    def check_branch(self):
139
 
        """After all the above changes, run the check and upgrade commands.
140
 
 
141
 
        The upgrade should be a no-op."""
142
 
        b = Branch.open(u'.')
143
 
        mutter('branch has %d revisions', b.revno())
144
 
        
145
 
        mutter('check branch...')
146
 
        from bzrlib.check import check
147
 
        check(b, False)
148
 
 
149
 
 
150
 
class SubdirCommit(TestCaseInTempDir):
 
71
    def test_subdir_add(self):
 
72
        """Add in subdirectory should add only things from there down"""
 
73
        
 
74
        from bzrlib.branch import Branch
 
75
        from bzrlib.commands import run_bzr
 
76
        
 
77
        eq = self.assertEqual
 
78
        ass = self.assert_
 
79
        chdir = os.chdir
 
80
        
 
81
        b = Branch('.', init=True)
 
82
        self.build_tree(['src/', 'README'])
 
83
        
 
84
        eq(sorted(b.unknowns()),
 
85
           ['README', 'src'])
 
86
        
 
87
        eq(run_bzr(['add', 'src']), 0)
 
88
        
 
89
        self.build_tree(['src/foo.c'])
 
90
        
 
91
        chdir('src')
 
92
        eq(run_bzr(['add']), 0)
 
93
        
 
94
        eq(sorted(b.unknowns()), 
 
95
           ['README'])
 
96
        eq(len(b.inventory), 3)
 
97
                
 
98
        chdir('..')
 
99
        eq(run_bzr(['add']), 0)
 
100
        eq(list(b.unknowns()), [])
 
101
        
 
102
        
 
103
class SubdirCommit(BzrTestBase):
151
104
 
152
105
    def test_subdir_commit(self):
153
106
        """Test committing a subdirectory, and committing within a directory."""
157
110
        self.build_tree(['a/', 'b/'])
158
111
        
159
112
        run_bzr('init')
160
 
        b = Branch.open(u'.')
 
113
        b = Branch('.')
161
114
        
162
115
        for fn in ('a/one', 'b/two', 'top'):
163
116
            file(fn, 'w').write('old contents')
168
121
        for fn in ('a/one', 'b/two', 'top'):
169
122
            file(fn, 'w').write('new contents')
170
123
            
171
 
        mutter('start selective subdir commit')
172
124
        run_bzr('commit', 'a', '-m', 'commit a only')
173
125
        
174
 
        old = b.repository.revision_tree(b.get_rev_id(1))
175
 
        new = b.repository.revision_tree(b.get_rev_id(2))
 
126
        old = b.revision_tree(b.lookup_revision(1))
 
127
        new = b.revision_tree(b.lookup_revision(2))
176
128
        
177
129
        eq(new.get_file_by_path('b/two').read(), 'old contents')
178
130
        eq(new.get_file_by_path('top').read(), 'old contents')
181
133
        os.chdir('a')
182
134
        # commit from here should do nothing
183
135
        run_bzr('commit', '.', '-m', 'commit subdir only', '--unchanged')
184
 
        v3 = b.repository.revision_tree(b.get_rev_id(3))
 
136
        v3 = b.revision_tree(b.lookup_revision(3))
185
137
        eq(v3.get_file_by_path('b/two').read(), 'old contents')
186
138
        eq(v3.get_file_by_path('top').read(), 'old contents')
187
139
        eq(v3.get_file_by_path('a/one').read(), 'new contents')
188
140
                
189
141
        # commit in subdirectory commits whole tree
190
142
        run_bzr('commit', '-m', 'commit whole tree from subdir')
191
 
        v4 = b.repository.revision_tree(b.get_rev_id(4))
 
143
        v4 = b.revision_tree(b.lookup_revision(4))
192
144
        eq(v4.get_file_by_path('b/two').read(), 'new contents')        
193
145
        eq(v4.get_file_by_path('top').read(), 'new contents')
194
146
        
195
147
        # TODO: factor out some kind of assert_tree_state() method
196
148
        
197
 
 
198
 
if __name__ == '__main__':
199
 
    import unittest
200
 
    unittest.main()
201