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

  • Committer: Jelmer Vernooij
  • Date: 2020-03-22 01:35:14 UTC
  • mfrom: (7490.7.6 work)
  • mto: This revision was merged to the branch mainline in revision 7499.
  • Revision ID: jelmer@jelmer.uk-20200322013514-7vw1ntwho04rcuj3
merge lp:brz/3.1.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_export.py
16
16
 
17
17
"""Tests for breezy.export."""
18
18
 
 
19
import gzip
 
20
from io import BytesIO
19
21
import os
20
22
import tarfile
21
23
import time
27
29
    tests,
28
30
    )
29
31
from ..export import get_root_name
30
 
from ..export.tar_exporter import export_tarball_generator
31
 
from ..sixish import (
32
 
    BytesIO,
33
 
    )
 
32
from ..archive.tar import tarball_generator
34
33
from . import features
35
34
 
36
35
 
58
57
        export.export(wt, 'target', format="dir")
59
58
        self.assertPathExists('target/link')
60
59
 
 
60
    def test_nested_tree(self):
 
61
        wt = self.make_branch_and_tree('.', format='development-subtree')
 
62
        subtree = self.make_branch_and_tree('subtree')
 
63
        self.build_tree(['subtree/file'])
 
64
        subtree.add(['file'])
 
65
        wt.add(['subtree'])
 
66
        export.export(wt, 'target', format="dir")
 
67
        self.assertPathExists('target/subtree')
 
68
        # TODO(jelmer): Once iter_entries_by_dir supports nested tree iteration:
 
69
        # self.assertPathExists('target/subtree/file')
 
70
 
61
71
    def test_to_existing_empty_dir_success(self):
62
72
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
63
73
        wt = self.make_branch_and_tree('source')
87
97
        wt.commit('1')
88
98
        self.build_tree(['target/', 'target/foo'])
89
99
        self.assertRaises(errors.BzrError,
90
 
            export.export, wt, 'target', format="dir")
 
100
                          export.export, wt, 'target', format="dir")
91
101
 
92
102
    def test_existing_single_file(self):
93
103
        self.build_tree([
104
114
        builder = self.make_branch_builder('source')
105
115
        builder.start_series()
106
116
        builder.build_snapshot(None, [
107
 
            ('add', ('', 'root-id', 'directory', '')),
108
 
            ('add', ('a', 'a-id', 'file', 'content\n'))])
 
117
            ('add', ('', b'root-id', 'directory', '')),
 
118
            ('add', ('a', b'a-id', 'file', b'content\n'))])
109
119
        builder.build_snapshot(None, [
110
 
            ('add', ('b', 'b-id', 'file', 'content\n'))])
 
120
            ('add', ('b', b'b-id', 'file', b'content\n'))])
111
121
        builder.finish_series()
112
122
        b = builder.get_branch()
113
123
        b.lock_read()
135
145
        a_time = time.mktime((1999, 12, 12, 0, 0, 0, 0, 0, 0))
136
146
        b_time = time.mktime((1980, 0o1, 0o1, 0, 0, 0, 0, 0, 0))
137
147
        builder.build_snapshot(None, [
138
 
            ('add', ('', 'root-id', 'directory', '')),
139
 
            ('add', ('a', 'a-id', 'file', 'content\n'))],
 
148
            ('add', ('', b'root-id', 'directory', '')),
 
149
            ('add', ('a', b'a-id', 'file', b'content\n'))],
140
150
            timestamp=a_time)
141
151
        builder.build_snapshot(None, [
142
 
            ('add', ('b', 'b-id', 'file', 'content\n'))],
 
152
            ('add', ('b', b'b-id', 'file', b'content\n'))],
143
153
            timestamp=b_time)
144
154
        builder.finish_series()
145
155
        b = builder.get_branch()
156
166
        builder.start_series()
157
167
        foo_time = time.mktime((1999, 12, 12, 0, 0, 0, 0, 0, 0))
158
168
        builder.build_snapshot(None, [
159
 
            ('add', ('', 'root-id', 'directory', '')),
160
 
            ('add', ('subdir', 'subdir-id', 'directory', '')),
161
 
            ('add', ('subdir/foo.txt', 'foo-id', 'file', 'content\n'))],
 
169
            ('add', ('', b'root-id', 'directory', '')),
 
170
            ('add', ('subdir', b'subdir-id', 'directory', '')),
 
171
            ('add', ('subdir/foo.txt', b'foo-id', 'file', b'content\n'))],
162
172
            timestamp=foo_time)
163
173
        builder.finish_series()
164
174
        b = builder.get_branch()
166
176
        self.addCleanup(b.unlock)
167
177
        tree = b.basis_tree()
168
178
        export.export(tree, 'target', format='dir', subdir='subdir',
169
 
            per_file_timestamps=True)
 
179
                      per_file_timestamps=True)
170
180
        t = self.get_transport('target')
171
181
        self.assertEqual(foo_time, t.stat('foo.txt').st_mtime)
172
182
 
204
214
        tf = tarfile.open('target.tar.gz')
205
215
        self.assertEqual(["target/a"], tf.getnames())
206
216
 
 
217
    def test_tgz_consistent_mtime(self):
 
218
        wt = self.make_branch_and_tree('.')
 
219
        self.build_tree(['a'])
 
220
        wt.add(["a"])
 
221
        timestamp = 1547400500
 
222
        revid = wt.commit("1", timestamp=timestamp)
 
223
        revtree = wt.branch.repository.revision_tree(revid)
 
224
        export.export(revtree, 'target.tar.gz', format="tgz")
 
225
        with gzip.GzipFile('target.tar.gz', 'r') as f:
 
226
            f.read()
 
227
            self.assertEqual(int(f.mtime), timestamp)
 
228
 
207
229
    def test_tgz_ignores_dest_path(self):
208
230
        # The target path should not be a part of the target file.
209
231
        # (bug #102234)
214
236
        os.mkdir("testdir1")
215
237
        os.mkdir("testdir2")
216
238
        export.export(wt, 'testdir1/target.tar.gz', format="tgz",
217
 
            per_file_timestamps=True)
 
239
                      per_file_timestamps=True)
218
240
        export.export(wt, 'testdir2/target.tar.gz', format="tgz",
219
 
            per_file_timestamps=True)
220
 
        file1 = open('testdir1/target.tar.gz', 'r')
 
241
                      per_file_timestamps=True)
 
242
        file1 = open('testdir1/target.tar.gz', 'rb')
221
243
        self.addCleanup(file1.close)
222
 
        file2 = open('testdir1/target.tar.gz', 'r')
 
244
        file2 = open('testdir1/target.tar.gz', 'rb')
223
245
        self.addCleanup(file2.close)
224
246
        content1 = file1.read()
225
247
        content2 = file2.read()
226
248
        self.assertEqualDiff(content1, content2)
227
249
        # the gzip module doesn't have a way to read back to the original
228
250
        # filename, but it's stored as-is in the tarfile.
229
 
        self.assertFalse("testdir1" in content1)
230
 
        self.assertFalse("target.tar.gz" in content1)
231
 
        self.assertTrue("target.tar" in content1)
 
251
        self.assertFalse(b"testdir1" in content1)
 
252
        self.assertFalse(b"target.tar.gz" in content1)
 
253
        self.assertTrue(b"target.tar" in content1)
232
254
 
233
255
    def test_tbz2(self):
234
256
        wt = self.make_branch_and_tree('.')
239
261
        tf = tarfile.open('target.tar.bz2')
240
262
        self.assertEqual(["target/a"], tf.getnames())
241
263
 
242
 
    def test_xz_stdout(self):
243
 
        wt = self.make_branch_and_tree('.')
244
 
        self.assertRaises(errors.BzrError, export.export, wt, '-',
245
 
            format="txz")
246
 
 
247
264
    def test_export_tarball_generator(self):
248
265
        wt = self.make_branch_and_tree('.')
249
266
        self.build_tree(['a'])
250
267
        wt.add(["a"])
251
268
        wt.commit("1", timestamp=42)
252
269
        target = BytesIO()
253
 
        ball = tarfile.open(None, "w|", target)
254
 
        wt.lock_read()
255
 
        try:
256
 
            for _ in export_tarball_generator(wt, ball, "bar"):
257
 
                pass
258
 
        finally:
259
 
            wt.unlock()
 
270
        with wt.lock_read():
 
271
            target.writelines(tarball_generator(wt, "bar"))
260
272
        # Ball should now be closed.
261
273
        target.seek(0)
262
274
        ball2 = tarfile.open(None, "r", target)
268
280
 
269
281
    def test_per_file_timestamps(self):
270
282
        tree = self.make_branch_and_tree('.')
271
 
        self.build_tree_contents([('har', 'foo')])
 
283
        self.build_tree_contents([('har', b'foo')])
272
284
        tree.add('har')
273
285
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
274
286
        timestamp = 347151600
275
287
        tree.commit('setup', timestamp=timestamp)
276
288
        export.export(tree.basis_tree(), 'test.zip', format='zip',
277
 
            per_file_timestamps=True)
 
289
                      per_file_timestamps=True)
278
290
        zfile = zipfile.ZipFile('test.zip')
279
291
        info = zfile.getinfo("test/har")
280
292
        self.assertEqual(time.localtime(timestamp)[:6], info.date_time)
292
304
        self.assertEqual('bzr-0.0.5', get_root_name('bzr-0.0.5'))
293
305
        self.assertEqual('mytar', get_root_name('a/long/path/mytar.tgz'))
294
306
        self.assertEqual('other',
295
 
            get_root_name('../parent/../dir/other.tbz2'))
 
307
                         get_root_name('../parent/../dir/other.tbz2'))
296
308
        self.assertEqual('', get_root_name('-'))