/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 breezy/tests/blackbox/test_versioning.py

  • Committer: Jelmer Vernooij
  • Date: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/blackbox/test_versioning.py
1
 
# Copyright (C) 2005, 2006, 2007, 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2009-2012, 2016 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 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
 
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
30
30
 
31
31
 
32
32
class TestMkdir(TestCaseWithTransport):
33
33
 
34
34
    def test_mkdir_fails_cleanly(self):
35
35
        """'mkdir' fails cleanly when no working tree is available.
36
 
        https://bugs.edge.launchpad.net/bzr/+bug/138600
 
36
        https://bugs.launchpad.net/bzr/+bug/138600
37
37
        """
38
38
        # Since there is a safety working tree above us, we create a bare repo
39
39
        # here locally.
40
40
        shared_repo = self.make_repository('.')
41
41
        self.run_bzr(['mkdir', 'abc'], retcode=3)
42
 
        self.failIfExists('abc')
43
 
 
44
 
 
45
 
class TestVersioning(TestCaseInTempDir):
 
42
        self.assertPathDoesNotExist('abc')
46
43
 
47
44
    def test_mkdir(self):
48
 
        """Basic 'bzr mkdir' operation"""
 
45
        """Basic 'brz mkdir' operation"""
49
46
 
50
 
        self.run_bzr('init')
 
47
        self.make_branch_and_tree('.')
51
48
        self.run_bzr(['mkdir', 'foo'])
52
 
        self.assert_(os.path.isdir('foo'))
 
49
        self.assertTrue(os.path.isdir('foo'))
53
50
 
54
51
        self.run_bzr(['mkdir', 'foo'], retcode=3)
55
52
 
59
56
 
60
57
        self.log('delta.added = %r' % delta.added)
61
58
 
62
 
        self.assertEquals(len(delta.added), 1)
63
 
        self.assertEquals(delta.added[0][0], 'foo')
64
 
        self.failIf(delta.modified)
 
59
        self.assertEqual(len(delta.added), 1)
 
60
        self.assertEqual(delta.added[0][0], 'foo')
 
61
        self.assertFalse(delta.modified)
65
62
 
66
63
    def test_mkdir_in_subdir(self):
67
 
        """'bzr mkdir' operation in subdirectory"""
 
64
        """'brz mkdir' operation in subdirectory"""
68
65
 
69
 
        self.run_bzr('init')
 
66
        self.make_branch_and_tree('.')
70
67
        self.run_bzr(['mkdir', 'dir'])
71
 
        self.assert_(os.path.isdir('dir'))
 
68
        self.assertTrue(os.path.isdir('dir'))
72
69
 
73
 
        os.chdir('dir')
74
70
        self.log('Run mkdir in subdir')
75
 
        self.run_bzr(['mkdir', 'subdir'])
76
 
        self.assert_(os.path.isdir('subdir'))
77
 
        os.chdir('..')
 
71
        self.run_bzr(['mkdir', 'subdir'], working_dir='dir')
 
72
        self.assertTrue(os.path.isdir('dir/subdir'))
78
73
 
79
74
        wt = WorkingTree.open('.')
80
75
 
82
77
 
83
78
        self.log('delta.added = %r' % delta.added)
84
79
 
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)
 
80
        self.assertEqual(len(delta.added), 2)
 
81
        self.assertEqual(delta.added[0][0], 'dir')
 
82
        self.assertEqual(delta.added[1][0], pathjoin('dir', 'subdir'))
 
83
        self.assertFalse(delta.modified)
89
84
 
90
85
    def test_mkdir_w_nested_trees(self):
91
 
        """'bzr mkdir' with nested trees"""
 
86
        """'brz mkdir' with nested trees"""
92
87
 
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('../..')
 
88
        self.make_branch_and_tree('.')
 
89
        self.make_branch_and_tree('a')
 
90
        self.make_branch_and_tree('a/b')
101
91
 
102
92
        self.run_bzr(['mkdir', 'dir', 'a/dir', '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'))
 
93
        self.assertTrue(os.path.isdir('dir'))
 
94
        self.assertTrue(os.path.isdir('a/dir'))
 
95
        self.assertTrue(os.path.isdir('a/b/dir'))
106
96
 
107
97
        wt = WorkingTree.open('.')
108
98
        wt_a = WorkingTree.open('a')
109
99
        wt_b = WorkingTree.open('a/b')
110
100
 
111
101
        delta = wt.changes_from(wt.basis_tree())
112
 
        self.assertEquals(len(delta.added), 1)
113
 
        self.assertEquals(delta.added[0][0], 'dir')
114
 
        self.failIf(delta.modified)
 
102
        self.assertEqual(len(delta.added), 1)
 
103
        self.assertEqual(delta.added[0][0], 'dir')
 
104
        self.assertFalse(delta.modified)
115
105
 
116
106
        delta = wt_a.changes_from(wt_a.basis_tree())
117
 
        self.assertEquals(len(delta.added), 1)
118
 
        self.assertEquals(delta.added[0][0], 'dir')
119
 
        self.failIf(delta.modified)
 
107
        self.assertEqual(len(delta.added), 1)
 
108
        self.assertEqual(delta.added[0][0], 'dir')
 
109
        self.assertFalse(delta.modified)
120
110
 
121
111
        delta = wt_b.changes_from(wt_b.basis_tree())
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)
 
112
        self.assertEqual(len(delta.added), 1)
 
113
        self.assertEqual(delta.added[0][0], '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(b'', err)
 
122
        self.assertEqual(b'', out)
136
123
 
137
124
 
138
125
class SubdirCommit(TestCaseWithTransport):
148
135
                ('b/two', contents),
149
136
                ('top', contents),
150
137
                ])
151
 
        set_contents('old contents')
 
138
        set_contents(b'old contents')
152
139
        tree.smart_add(['.'])
153
140
        tree.commit('first revision')
154
 
        set_contents('new contents')
 
141
        set_contents(b'new contents')
155
142
 
156
143
        mutter('start selective subdir commit')
157
144
        self.run_bzr(['commit', 'a', '-m', 'commit a only'])
159
146
        new = b.repository.revision_tree(b.get_rev_id(2))
160
147
        new.lock_read()
161
148
 
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')
 
149
        def get_text_by_path(tree, path):
 
150
            return tree.get_file_text(path)
 
151
 
 
152
        self.assertEqual(get_text_by_path(new, 'b/two'), b'old contents')
 
153
        self.assertEqual(get_text_by_path(new, 'top'), b'old contents')
 
154
        self.assertEqual(get_text_by_path(new, 'a/one'), b'new contents')
165
155
        new.unlock()
166
156
 
167
 
        os.chdir('a')
168
157
        # commit from here should do nothing
169
 
        self.run_bzr(['commit', '.', '-m', 'commit subdir only', '--unchanged'])
 
158
        self.run_bzr(['commit', '.', '-m', 'commit subdir only', '--unchanged'],
 
159
                     working_dir='a')
170
160
        v3 = b.repository.revision_tree(b.get_rev_id(3))
171
161
        v3.lock_read()
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')
 
162
        self.assertEqual(get_text_by_path(v3, 'b/two'), b'old contents')
 
163
        self.assertEqual(get_text_by_path(v3, 'top'), b'old contents')
 
164
        self.assertEqual(get_text_by_path(v3, 'a/one'), b'new contents')
175
165
        v3.unlock()
176
166
 
177
167
        # commit in subdirectory commits whole tree
178
 
        self.run_bzr(['commit', '-m', 'commit whole tree from subdir'])
 
168
        self.run_bzr(['commit', '-m', 'commit whole tree from subdir'],
 
169
                     working_dir='a')
179
170
        v4 = b.repository.revision_tree(b.get_rev_id(4))
180
171
        v4.lock_read()
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')
 
172
        self.assertEqual(get_text_by_path(v4, 'b/two'), b'new contents')
 
173
        self.assertEqual(get_text_by_path(v4, 'top'), b'new contents')
183
174
        v4.unlock()
184
175
 
185
176
        # TODO: factor out some kind of assert_tree_state() method