/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/test_memorytree.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_memorytree.py
17
17
 
18
18
"""Tests for the MemoryTree class."""
19
19
 
20
 
from .. import errors
21
 
from ..memorytree import MemoryTree
22
 
from . import TestCaseWithTransport
23
 
from ..treebuilder import TreeBuilder
 
20
from bzrlib import errors
 
21
from bzrlib.memorytree import MemoryTree
 
22
from bzrlib.tests import TestCaseWithTransport
 
23
from bzrlib.treebuilder import TreeBuilder
24
24
 
25
25
 
26
26
class TestMemoryTree(TestCaseWithTransport):
29
29
        """Creating a mutable tree on a trivial branch works."""
30
30
        branch = self.make_branch('branch')
31
31
        tree = MemoryTree.create_on_branch(branch)
32
 
        self.assertEqual(branch.controldir, tree.controldir)
 
32
        self.assertEqual(branch.bzrdir, tree.bzrdir)
33
33
        self.assertEqual(branch, tree.branch)
34
34
        self.assertEqual([], tree.get_parent_ids())
35
35
 
49
49
        tree.lock_read()
50
50
        self.assertEqual([rev_id], tree.get_parent_ids())
51
51
        self.assertEqual('contents of foo\n',
52
 
            tree.get_file('foo').read())
 
52
            tree.get_file(tree.path2id('foo')).read())
53
53
        tree.unlock()
54
54
 
55
55
    def test_get_root_id(self):
108
108
        branch = self.make_branch('branch')
109
109
        tree = MemoryTree.create_on_branch(branch)
110
110
        tree.lock_write()
111
 
        tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
 
111
        tree.add(['', 'foo'], ids=['root-id', 'foo-id'],
112
112
                  kinds=['directory', 'file'])
113
 
        tree.put_file_bytes_non_atomic('foo', 'barshoom')
114
 
        self.assertEqual('barshoom', tree.get_file('foo').read())
 
113
        tree.put_file_bytes_non_atomic('foo-id', 'barshoom')
 
114
        self.assertEqual('barshoom', tree.get_file('foo-id').read())
115
115
        tree.unlock()
116
116
 
117
117
    def test_put_existing_file(self):
118
118
        branch = self.make_branch('branch')
119
119
        tree = MemoryTree.create_on_branch(branch)
120
120
        tree.lock_write()
121
 
        tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
 
121
        tree.add(['', 'foo'], ids=['root-id', 'foo-id'],
122
122
                 kinds=['directory', 'file'])
123
 
        tree.put_file_bytes_non_atomic('foo', 'first-content')
124
 
        tree.put_file_bytes_non_atomic('foo', 'barshoom')
125
 
        self.assertEqual('barshoom', tree.get_file('foo').read())
 
123
        tree.put_file_bytes_non_atomic('foo-id', 'first-content')
 
124
        tree.put_file_bytes_non_atomic('foo-id', 'barshoom')
 
125
        self.assertEqual('barshoom', tree.get_file('foo-id').read())
126
126
        tree.unlock()
127
127
 
128
128
    def test_add_in_subdir(self):
130
130
        tree = MemoryTree.create_on_branch(branch)
131
131
        tree.lock_write()
132
132
        self.addCleanup(tree.unlock)
133
 
        tree.add([''], [b'root-id'], ['directory'])
 
133
        tree.add([''], ['root-id'], ['directory'])
134
134
        # Unfortunately, the only way to 'mkdir' is to call 'tree.mkdir', but
135
135
        # that *always* adds the directory as well. So if you want to create a
136
136
        # file in a subdirectory, you have to split out the 'mkdir()' calls
137
137
        # from the add and put_file_bytes_non_atomic calls. :(
138
138
        tree.mkdir('adir', 'dir-id')
139
 
        tree.add(['adir/afile'], [b'file-id'], ['file'])
140
 
        self.assertEqual('adir/afile', tree.id2path(b'file-id'))
141
 
        self.assertEqual('adir', tree.id2path(b'dir-id'))
142
 
        tree.put_file_bytes_non_atomic('adir/afile', 'barshoom')
 
139
        tree.add(['adir/afile'], ['file-id'], ['file'])
 
140
        self.assertEqual('adir/afile', tree.id2path('file-id'))
 
141
        self.assertEqual('adir', tree.id2path('dir-id'))
 
142
        tree.put_file_bytes_non_atomic('file-id', 'barshoom')
143
143
 
144
144
    def test_commit_trivial(self):
145
145
        """Smoke test for commit on a MemoryTree.
150
150
        branch = self.make_branch('branch')
151
151
        tree = MemoryTree.create_on_branch(branch)
152
152
        tree.lock_write()
153
 
        tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
 
153
        tree.add(['', 'foo'], ids=['root-id', 'foo-id'],
154
154
                 kinds=['directory', 'file'])
155
 
        tree.put_file_bytes_non_atomic('foo', 'barshoom')
 
155
        tree.put_file_bytes_non_atomic('foo-id', 'barshoom')
156
156
        revision_id = tree.commit('message baby')
157
157
        # the parents list for the tree should have changed.
158
158
        self.assertEqual([revision_id], tree.get_parent_ids())
161
161
        revtree = tree.branch.repository.revision_tree(revision_id)
162
162
        revtree.lock_read()
163
163
        self.addCleanup(revtree.unlock)
164
 
        self.assertEqual('barshoom', revtree.get_file('foo').read())
 
164
        self.assertEqual('barshoom', revtree.get_file('foo-id').read())
165
165
 
166
166
    def test_unversion(self):
167
167
        """Some test for unversion of a memory tree."""
168
168
        branch = self.make_branch('branch')
169
169
        tree = MemoryTree.create_on_branch(branch)
170
170
        tree.lock_write()
171
 
        tree.add(['', 'foo'], ids=[b'root-id', b'foo-id'],
 
171
        tree.add(['', 'foo'], ids=['root-id', 'foo-id'],
172
172
                 kinds=['directory', 'file'])
173
 
        tree.unversion(['foo'])
174
 
        self.assertFalse(tree.is_versioned('foo'))
175
 
        self.assertFalse(tree.has_id(b'foo-id'))
 
173
        tree.unversion(['foo-id'])
 
174
        self.assertFalse(tree.has_id('foo-id'))
176
175
        tree.unlock()
177
176
 
178
177
    def test_last_revision(self):
188
187
        tree = self.make_branch_and_memory_tree('branch')
189
188
        tree.lock_write()
190
189
        self.addCleanup(tree.unlock)
191
 
        tree.add(['', 'foo'], [b'root-id', b'foo-id'], ['directory', 'file'])
192
 
        tree.put_file_bytes_non_atomic('foo', 'content\n')
193
 
        tree.commit('one', rev_id=b'rev-one')
 
190
        tree.add(['', 'foo'], ['root-id', 'foo-id'], ['directory', 'file'])
 
191
        tree.put_file_bytes_non_atomic('foo-id', 'content\n')
 
192
        tree.commit('one', rev_id='rev-one')
194
193
        tree.rename_one('foo', 'bar')
195
 
        self.assertEqual('bar', tree.id2path(b'foo-id'))
 
194
        self.assertEqual('bar', tree.id2path('foo-id'))
196
195
        self.assertEqual('content\n', tree._file_transport.get_bytes('bar'))
197
196
        self.assertRaises(errors.NoSuchFile,
198
197
                          tree._file_transport.get_bytes, 'foo')
199
 
        tree.commit('two', rev_id=b'rev-two')
 
198
        tree.commit('two', rev_id='rev-two')
200
199
        self.assertEqual('content\n', tree._file_transport.get_bytes('bar'))
201
200
        self.assertRaises(errors.NoSuchFile,
202
201
                          tree._file_transport.get_bytes, 'foo')
203
202
 
204
 
        rev_tree2 = tree.branch.repository.revision_tree(b'rev-two')
205
 
        self.assertEqual('bar', rev_tree2.id2path(b'foo-id'))
206
 
        self.assertEqual('content\n', rev_tree2.get_file_text('bar'))
 
203
        rev_tree2 = tree.branch.repository.revision_tree('rev-two')
 
204
        self.assertEqual('bar', rev_tree2.id2path('foo-id'))
 
205
        self.assertEqual('content\n', rev_tree2.get_file_text('foo-id'))
207
206
 
208
207
    def test_rename_file_to_subdir(self):
209
208
        tree = self.make_branch_and_memory_tree('branch')
210
209
        tree.lock_write()
211
210
        self.addCleanup(tree.unlock)
212
211
        tree.add('')
213
 
        tree.mkdir('subdir', b'subdir-id')
214
 
        tree.add('foo', b'foo-id', 'file')
215
 
        tree.put_file_bytes_non_atomic('foo', 'content\n')
216
 
        tree.commit('one', rev_id=b'rev-one')
 
212
        tree.mkdir('subdir', 'subdir-id')
 
213
        tree.add('foo', 'foo-id', 'file')
 
214
        tree.put_file_bytes_non_atomic('foo-id', 'content\n')
 
215
        tree.commit('one', rev_id='rev-one')
217
216
 
218
217
        tree.rename_one('foo', 'subdir/bar')
219
 
        self.assertEqual('subdir/bar', tree.id2path(b'foo-id'))
 
218
        self.assertEqual('subdir/bar', tree.id2path('foo-id'))
220
219
        self.assertEqual('content\n',
221
220
                         tree._file_transport.get_bytes('subdir/bar'))
222
 
        tree.commit('two', rev_id=b'rev-two')
223
 
        rev_tree2 = tree.branch.repository.revision_tree(b'rev-two')
224
 
        self.assertEqual('subdir/bar', rev_tree2.id2path(b'foo-id'))
 
221
        tree.commit('two', rev_id='rev-two')
 
222
        rev_tree2 = tree.branch.repository.revision_tree('rev-two')
 
223
        self.assertEqual('subdir/bar', rev_tree2.id2path('foo-id'))