/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: 2019-10-28 01:38:39 UTC
  • mto: This revision was merged to the branch mainline in revision 7412.
  • Revision ID: jelmer@jelmer.uk-20191028013839-q63zzm4yr0id9b3o
Allow unknown extras in git commits when just inspecting revisions, rather than importing.

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].path[1], '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].path[1], 'dir')
 
82
        self.assertEqual(delta.added[1].path[1], 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].path[1], '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].path[1], '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].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)
136
123
 
137
124
 
138
125
class SubdirCommit(TestCaseWithTransport):
142
129
        tree = self.make_branch_and_tree('.')
143
130
        b = tree.branch
144
131
        self.build_tree(['a/', 'b/'])
 
132
 
145
133
        def set_contents(contents):
146
134
            self.build_tree_contents([
147
135
                ('a/one', contents),
148
136
                ('b/two', contents),
149
137
                ('top', contents),
150
138
                ])
151
 
        set_contents('old contents')
 
139
        set_contents(b'old contents')
152
140
        tree.smart_add(['.'])
153
141
        tree.commit('first revision')
154
 
        set_contents('new contents')
 
142
        set_contents(b'new contents')
155
143
 
156
144
        mutter('start selective subdir commit')
157
145
        self.run_bzr(['commit', 'a', '-m', 'commit a only'])
159
147
        new = b.repository.revision_tree(b.get_rev_id(2))
160
148
        new.lock_read()
161
149
 
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')
 
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')
165
156
        new.unlock()
166
157
 
167
 
        os.chdir('a')
168
158
        # commit from here should do nothing
169
 
        self.run_bzr(['commit', '.', '-m', 'commit subdir only', '--unchanged'])
 
159
        self.run_bzr(['commit', '.', '-m', 'commit subdir only', '--unchanged'],
 
160
                     working_dir='a')
170
161
        v3 = b.repository.revision_tree(b.get_rev_id(3))
171
162
        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')
 
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')
175
166
        v3.unlock()
176
167
 
177
168
        # commit in subdirectory commits whole tree
178
 
        self.run_bzr(['commit', '-m', 'commit whole tree from subdir'])
 
169
        self.run_bzr(['commit', '-m', 'commit whole tree from subdir'],
 
170
                     working_dir='a')
179
171
        v4 = b.repository.revision_tree(b.get_rev_id(4))
180
172
        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')
 
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')
183
175
        v4.unlock()
184
176
 
185
177
        # TODO: factor out some kind of assert_tree_state() method