/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

  • 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_versioning.py
1
 
# Copyright (C) 2005, 2006, 2007, 2009-2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2005, 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
22
22
 
23
23
import os
24
24
 
25
 
from breezy.branch import Branch
26
 
from breezy.osutils import pathjoin
27
 
from breezy.tests import TestCaseInTempDir, TestCaseWithTransport
28
 
from breezy.trace import mutter
29
 
from breezy.workingtree import WorkingTree
 
25
from bzrlib.branch import Branch
 
26
from bzrlib.osutils import pathjoin
 
27
from bzrlib.tests import TestCaseInTempDir, TestCaseWithTransport
 
28
from bzrlib.trace import mutter
 
29
from bzrlib.workingtree import WorkingTree
30
30
 
31
31
 
32
32
class TestMkdir(TestCaseWithTransport):
39
39
        # here locally.
40
40
        shared_repo = self.make_repository('.')
41
41
        self.run_bzr(['mkdir', 'abc'], retcode=3)
42
 
        self.assertPathDoesNotExist('abc')
 
42
        self.failIfExists('abc')
 
43
 
 
44
 
 
45
class TestVersioning(TestCaseInTempDir):
43
46
 
44
47
    def test_mkdir(self):
45
 
        """Basic 'brz mkdir' operation"""
 
48
        """Basic 'bzr mkdir' operation"""
46
49
 
47
 
        self.make_branch_and_tree('.')
 
50
        self.run_bzr('init')
48
51
        self.run_bzr(['mkdir', 'foo'])
49
 
        self.assertTrue(os.path.isdir('foo'))
 
52
        self.assert_(os.path.isdir('foo'))
50
53
 
51
54
        self.run_bzr(['mkdir', 'foo'], retcode=3)
52
55
 
56
59
 
57
60
        self.log('delta.added = %r' % delta.added)
58
61
 
59
 
        self.assertEqual(len(delta.added), 1)
60
 
        self.assertEqual(delta.added[0].path[1], 'foo')
61
 
        self.assertFalse(delta.modified)
 
62
        self.assertEquals(len(delta.added), 1)
 
63
        self.assertEquals(delta.added[0][0], 'foo')
 
64
        self.failIf(delta.modified)
62
65
 
63
66
    def test_mkdir_in_subdir(self):
64
 
        """'brz mkdir' operation in subdirectory"""
 
67
        """'bzr mkdir' operation in subdirectory"""
65
68
 
66
 
        self.make_branch_and_tree('.')
 
69
        self.run_bzr('init')
67
70
        self.run_bzr(['mkdir', 'dir'])
68
 
        self.assertTrue(os.path.isdir('dir'))
 
71
        self.assert_(os.path.isdir('dir'))
69
72
 
 
73
        os.chdir('dir')
70
74
        self.log('Run mkdir in subdir')
71
 
        self.run_bzr(['mkdir', 'subdir'], working_dir='dir')
72
 
        self.assertTrue(os.path.isdir('dir/subdir'))
 
75
        self.run_bzr(['mkdir', 'subdir'])
 
76
        self.assert_(os.path.isdir('subdir'))
 
77
        os.chdir('..')
73
78
 
74
79
        wt = WorkingTree.open('.')
75
80
 
77
82
 
78
83
        self.log('delta.added = %r' % delta.added)
79
84
 
80
 
        self.assertEqual(len(delta.added), 2)
81
 
        self.assertEqual(delta.added[0].path[1], 'dir')
82
 
        self.assertEqual(delta.added[1].path[1], pathjoin('dir', 'subdir'))
83
 
        self.assertFalse(delta.modified)
 
85
        self.assertEquals(len(delta.added), 2)
 
86
        self.assertEquals(delta.added[0][0], 'dir')
 
87
        self.assertEquals(delta.added[1][0], pathjoin('dir','subdir'))
 
88
        self.failIf(delta.modified)
84
89
 
85
90
    def test_mkdir_w_nested_trees(self):
86
 
        """'brz mkdir' with nested trees"""
 
91
        """'bzr mkdir' with nested trees"""
87
92
 
88
 
        self.make_branch_and_tree('.')
89
 
        self.make_branch_and_tree('a')
90
 
        self.make_branch_and_tree('a/b')
 
93
        self.run_bzr('init')
 
94
        os.mkdir('a')
 
95
        os.chdir('a')
 
96
        self.run_bzr('init')
 
97
        os.mkdir('b')
 
98
        os.chdir('b')
 
99
        self.run_bzr('init')
 
100
        os.chdir('../..')
91
101
 
92
102
        self.run_bzr(['mkdir', 'dir', 'a/dir', 'a/b/dir'])
93
 
        self.assertTrue(os.path.isdir('dir'))
94
 
        self.assertTrue(os.path.isdir('a/dir'))
95
 
        self.assertTrue(os.path.isdir('a/b/dir'))
 
103
        self.failUnless(os.path.isdir('dir'))
 
104
        self.failUnless(os.path.isdir('a/dir'))
 
105
        self.failUnless(os.path.isdir('a/b/dir'))
96
106
 
97
107
        wt = WorkingTree.open('.')
98
108
        wt_a = WorkingTree.open('a')
99
109
        wt_b = WorkingTree.open('a/b')
100
110
 
101
111
        delta = wt.changes_from(wt.basis_tree())
102
 
        self.assertEqual(len(delta.added), 1)
103
 
        self.assertEqual(delta.added[0].path[1], 'dir')
104
 
        self.assertFalse(delta.modified)
 
112
        self.assertEquals(len(delta.added), 1)
 
113
        self.assertEquals(delta.added[0][0], 'dir')
 
114
        self.failIf(delta.modified)
105
115
 
106
116
        delta = wt_a.changes_from(wt_a.basis_tree())
107
 
        self.assertEqual(len(delta.added), 1)
108
 
        self.assertEqual(delta.added[0].path[1], 'dir')
109
 
        self.assertFalse(delta.modified)
 
117
        self.assertEquals(len(delta.added), 1)
 
118
        self.assertEquals(delta.added[0][0], 'dir')
 
119
        self.failIf(delta.modified)
110
120
 
111
121
        delta = wt_b.changes_from(wt_b.basis_tree())
112
 
        self.assertEqual(len(delta.added), 1)
113
 
        self.assertEqual(delta.added[0].path[1], 'dir')
114
 
        self.assertFalse(delta.modified)
115
 
 
116
 
    def test_mkdir_quiet(self):
117
 
        """'brz mkdir --quiet' should not print a status message"""
118
 
 
119
 
        self.make_branch_and_tree('.')
120
 
        out, err = self.run_bzr(['mkdir', '--quiet', 'foo'])
121
 
        self.assertEqual('', err)
122
 
        self.assertEqual('', out)
 
122
        self.assertEquals(len(delta.added), 1)
 
123
        self.assertEquals(delta.added[0][0], 'dir')
 
124
        self.failIf(delta.modified)
 
125
 
 
126
    def check_branch(self):
 
127
        """After all the above changes, run the check and upgrade commands.
 
128
 
 
129
        The upgrade should be a no-op."""
 
130
        b = Branch.open(u'.')
 
131
        mutter('branch has %d revisions', b.revno())
 
132
 
 
133
        mutter('check branch...')
 
134
        from bzrlib.check import check
 
135
        check(b, False)
123
136
 
124
137
 
125
138
class SubdirCommit(TestCaseWithTransport):
129
142
        tree = self.make_branch_and_tree('.')
130
143
        b = tree.branch
131
144
        self.build_tree(['a/', 'b/'])
132
 
 
133
145
        def set_contents(contents):
134
146
            self.build_tree_contents([
135
147
                ('a/one', contents),
136
148
                ('b/two', contents),
137
149
                ('top', contents),
138
150
                ])
139
 
        set_contents(b'old contents')
 
151
        set_contents('old contents')
140
152
        tree.smart_add(['.'])
141
153
        tree.commit('first revision')
142
 
        set_contents(b'new contents')
 
154
        set_contents('new contents')
143
155
 
144
156
        mutter('start selective subdir commit')
145
157
        self.run_bzr(['commit', 'a', '-m', 'commit a only'])
147
159
        new = b.repository.revision_tree(b.get_rev_id(2))
148
160
        new.lock_read()
149
161
 
150
 
        def get_text_by_path(tree, path):
151
 
            return tree.get_file_text(path)
152
 
 
153
 
        self.assertEqual(get_text_by_path(new, 'b/two'), b'old contents')
154
 
        self.assertEqual(get_text_by_path(new, 'top'), b'old contents')
155
 
        self.assertEqual(get_text_by_path(new, 'a/one'), b'new contents')
 
162
        self.assertEqual(new.get_file_by_path('b/two').read(), 'old contents')
 
163
        self.assertEqual(new.get_file_by_path('top').read(), 'old contents')
 
164
        self.assertEqual(new.get_file_by_path('a/one').read(), 'new contents')
156
165
        new.unlock()
157
166
 
 
167
        os.chdir('a')
158
168
        # commit from here should do nothing
159
 
        self.run_bzr(['commit', '.', '-m', 'commit subdir only', '--unchanged'],
160
 
                     working_dir='a')
 
169
        self.run_bzr(['commit', '.', '-m', 'commit subdir only', '--unchanged'])
161
170
        v3 = b.repository.revision_tree(b.get_rev_id(3))
162
171
        v3.lock_read()
163
 
        self.assertEqual(get_text_by_path(v3, 'b/two'), b'old contents')
164
 
        self.assertEqual(get_text_by_path(v3, 'top'), b'old contents')
165
 
        self.assertEqual(get_text_by_path(v3, 'a/one'), b'new contents')
 
172
        self.assertEqual(v3.get_file_by_path('b/two').read(), 'old contents')
 
173
        self.assertEqual(v3.get_file_by_path('top').read(), 'old contents')
 
174
        self.assertEqual(v3.get_file_by_path('a/one').read(), 'new contents')
166
175
        v3.unlock()
167
176
 
168
177
        # commit in subdirectory commits whole tree
169
 
        self.run_bzr(['commit', '-m', 'commit whole tree from subdir'],
170
 
                     working_dir='a')
 
178
        self.run_bzr(['commit', '-m', 'commit whole tree from subdir'])
171
179
        v4 = b.repository.revision_tree(b.get_rev_id(4))
172
180
        v4.lock_read()
173
 
        self.assertEqual(get_text_by_path(v4, 'b/two'), b'new contents')
174
 
        self.assertEqual(get_text_by_path(v4, 'top'), b'new contents')
 
181
        self.assertEqual(v4.get_file_by_path('b/two').read(), 'new contents')
 
182
        self.assertEqual(v4.get_file_by_path('top').read(), 'new contents')
175
183
        v4.unlock()
176
184
 
177
185
        # TODO: factor out some kind of assert_tree_state() method