/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: 2017-06-08 23:30:31 UTC
  • mto: This revision was merged to the branch mainline in revision 6690.
  • Revision ID: jelmer@jelmer.uk-20170608233031-3qavls2o7a1pqllj
Update imports.

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