← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_versioning.py

  • Committer: Patch Queue Manager
  • Date: 2016-02-01 19:56:05 UTC
  • mfrom: (6615.1.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20160201195605-o7rl92wf6uyum3fk
(vila) Open trunk again as 2.8b1 (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

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