/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: 2018-07-08 14:45:27 UTC
  • mto: This revision was merged to the branch mainline in revision 7036.
  • Revision ID: jelmer@jelmer.uk-20180708144527-codhlvdcdg9y0nji
Fix a bunch of merge tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_export.py
1
 
# Copyright (C) 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2009, 2010, 2011, 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
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
 
17
"""Tests for breezy.export."""
 
18
 
17
19
import os
 
20
import tarfile
18
21
import time
 
22
import zipfile
19
23
 
20
 
from bzrlib import (
 
24
from .. import (
21
25
    errors,
22
26
    export,
23
27
    tests,
24
28
    )
25
 
 
26
 
 
27
 
class TestExport(tests.TestCaseWithTransport):
28
 
 
29
 
    def test_dir_export_missing_file(self):
 
29
from ..export import get_root_name
 
30
from ..archive.tar import tarball_generator
 
31
from ..sixish import (
 
32
    BytesIO,
 
33
    )
 
34
from . import features
 
35
 
 
36
 
 
37
class TestDirExport(tests.TestCaseWithTransport):
 
38
 
 
39
    def test_missing_file(self):
30
40
        self.build_tree(['a/', 'a/b', 'a/c'])
31
41
        wt = self.make_branch_and_tree('.')
32
42
        wt.add(['a', 'a/b', 'a/c'])
33
43
        os.unlink('a/c')
34
44
        export.export(wt, 'target', format="dir")
35
 
        self.failUnlessExists('target/a/b')
36
 
        self.failIfExists('target/a/c')
37
 
 
38
 
    def test_dir_export_symlink(self):
39
 
        self.requireFeature(tests.SymlinkFeature)
 
45
        self.assertPathExists('target/a/b')
 
46
        self.assertPathDoesNotExist('target/a/c')
 
47
 
 
48
    def test_empty(self):
 
49
        wt = self.make_branch_and_tree('.')
 
50
        export.export(wt, 'target', format="dir")
 
51
        self.assertEqual([], os.listdir("target"))
 
52
 
 
53
    def test_symlink(self):
 
54
        self.requireFeature(features.SymlinkFeature)
40
55
        wt = self.make_branch_and_tree('.')
41
56
        os.symlink('source', 'link')
42
57
        wt.add(['link'])
43
58
        export.export(wt, 'target', format="dir")
44
 
        self.failUnlessExists('target/link')
45
 
 
46
 
    def test_dir_export_to_existing_empty_dir_success(self):
47
 
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
48
 
        wt = self.make_branch_and_tree('source')
49
 
        wt.add(['a', 'b', 'b/c'])
50
 
        wt.commit('1')
51
 
        self.build_tree(['target/'])
52
 
        export.export(wt, 'target', format="dir")
53
 
        self.failUnlessExists('target/a')
54
 
        self.failUnlessExists('target/b')
55
 
        self.failUnlessExists('target/b/c')
56
 
 
57
 
    def test_dir_export_to_existing_nonempty_dir_fail(self):
 
59
        self.assertPathExists('target/link')
 
60
 
 
61
    def test_nested_tree(self):
 
62
        wt = self.make_branch_and_tree('.', format='development-subtree')
 
63
        subtree = self.make_branch_and_tree('subtree')
 
64
        self.build_tree(['subtree/file'])
 
65
        subtree.add(['file'])
 
66
        wt.add(['subtree'])
 
67
        export.export(wt, 'target', format="dir")
 
68
        self.assertPathExists('target/subtree')
 
69
        # TODO(jelmer): Once iter_entries_by_dir supports nested tree iteration:
 
70
        # self.assertPathExists('target/subtree/file')
 
71
 
 
72
    def test_to_existing_empty_dir_success(self):
 
73
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
 
74
        wt = self.make_branch_and_tree('source')
 
75
        wt.add(['a', 'b', 'b/c'])
 
76
        wt.commit('1')
 
77
        self.build_tree(['target/'])
 
78
        export.export(wt, 'target', format="dir")
 
79
        self.assertPathExists('target/a')
 
80
        self.assertPathExists('target/b')
 
81
        self.assertPathExists('target/b/c')
 
82
 
 
83
    def test_empty_subdir(self):
 
84
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
 
85
        wt = self.make_branch_and_tree('source')
 
86
        wt.add(['a', 'b', 'b/c'])
 
87
        wt.commit('1')
 
88
        self.build_tree(['target/'])
 
89
        export.export(wt, 'target', format="dir", subdir='')
 
90
        self.assertPathExists('target/a')
 
91
        self.assertPathExists('target/b')
 
92
        self.assertPathExists('target/b/c')
 
93
 
 
94
    def test_to_existing_nonempty_dir_fail(self):
58
95
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
59
96
        wt = self.make_branch_and_tree('source')
60
97
        wt.add(['a', 'b', 'b/c'])
61
98
        wt.commit('1')
62
99
        self.build_tree(['target/', 'target/foo'])
63
 
        self.assertRaises(errors.BzrError, export.export, wt, 'target', format="dir")
 
100
        self.assertRaises(errors.BzrError,
 
101
            export.export, wt, 'target', format="dir")
64
102
 
65
 
    def test_dir_export_existing_single_file(self):
66
 
        self.build_tree(['dir1/', 'dir1/dir2/', 'dir1/first', 'dir1/dir2/second'])
 
103
    def test_existing_single_file(self):
 
104
        self.build_tree([
 
105
            'dir1/', 'dir1/dir2/', 'dir1/first', 'dir1/dir2/second'])
67
106
        wtree = self.make_branch_and_tree('dir1')
68
107
        wtree.add(['dir2', 'first', 'dir2/second'])
69
108
        wtree.commit('1')
70
109
        export.export(wtree, 'target1', format='dir', subdir='first')
71
 
        self.failUnlessExists('target1/first')
 
110
        self.assertPathExists('target1/first')
72
111
        export.export(wtree, 'target2', format='dir', subdir='dir2/second')
73
 
        self.failUnlessExists('target2/second')
74
 
        
75
 
    def test_dir_export_files_same_timestamp(self):
 
112
        self.assertPathExists('target2/second')
 
113
 
 
114
    def test_files_same_timestamp(self):
76
115
        builder = self.make_branch_builder('source')
77
116
        builder.start_series()
78
 
        builder.build_snapshot(None, None, [
79
 
            ('add', ('', 'root-id', 'directory', '')),
80
 
            ('add', ('a', 'a-id', 'file', 'content\n'))])
81
 
        builder.build_snapshot(None, None, [
82
 
            ('add', ('b', 'b-id', 'file', 'content\n'))])
 
117
        builder.build_snapshot(None, [
 
118
            ('add', ('', b'root-id', 'directory', '')),
 
119
            ('add', ('a', b'a-id', 'file', b'content\n'))])
 
120
        builder.build_snapshot(None, [
 
121
            ('add', ('b', b'b-id', 'file', b'content\n'))])
83
122
        builder.finish_series()
84
123
        b = builder.get_branch()
85
124
        b.lock_read()
86
125
        self.addCleanup(b.unlock)
87
126
        tree = b.basis_tree()
88
127
        orig_iter_files_bytes = tree.iter_files_bytes
 
128
 
89
129
        # Make iter_files_bytes slower, so we provoke mtime skew
90
130
        def iter_files_bytes(to_fetch):
91
131
            for thing in orig_iter_files_bytes(to_fetch):
99
139
        # All files must be given the same mtime.
100
140
        self.assertEqual(st_a.st_mtime, st_b.st_mtime)
101
141
 
102
 
    def test_dir_export_files_per_file_timestamps(self):
 
142
    def test_files_per_file_timestamps(self):
103
143
        builder = self.make_branch_builder('source')
104
144
        builder.start_series()
105
145
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
106
146
        a_time = time.mktime((1999, 12, 12, 0, 0, 0, 0, 0, 0))
107
 
        b_time = time.mktime((1980, 01, 01, 0, 0, 0, 0, 0, 0))
108
 
        builder.build_snapshot(None, None, [
109
 
            ('add', ('', 'root-id', 'directory', '')),
110
 
            ('add', ('a', 'a-id', 'file', 'content\n'))],
 
147
        b_time = time.mktime((1980, 0o1, 0o1, 0, 0, 0, 0, 0, 0))
 
148
        builder.build_snapshot(None, [
 
149
            ('add', ('', b'root-id', 'directory', '')),
 
150
            ('add', ('a', b'a-id', 'file', b'content\n'))],
111
151
            timestamp=a_time)
112
 
        builder.build_snapshot(None, None, [
113
 
            ('add', ('b', 'b-id', 'file', 'content\n'))],
 
152
        builder.build_snapshot(None, [
 
153
            ('add', ('b', b'b-id', 'file', b'content\n'))],
114
154
            timestamp=b_time)
115
155
        builder.finish_series()
116
156
        b = builder.get_branch()
121
161
        t = self.get_transport('target')
122
162
        self.assertEqual(a_time, t.stat('a').st_mtime)
123
163
        self.assertEqual(b_time, t.stat('b').st_mtime)
 
164
 
 
165
    def test_subdir_files_per_timestamps(self):
 
166
        builder = self.make_branch_builder('source')
 
167
        builder.start_series()
 
168
        foo_time = time.mktime((1999, 12, 12, 0, 0, 0, 0, 0, 0))
 
169
        builder.build_snapshot(None, [
 
170
            ('add', ('', b'root-id', 'directory', '')),
 
171
            ('add', ('subdir', b'subdir-id', 'directory', '')),
 
172
            ('add', ('subdir/foo.txt', b'foo-id', 'file', b'content\n'))],
 
173
            timestamp=foo_time)
 
174
        builder.finish_series()
 
175
        b = builder.get_branch()
 
176
        b.lock_read()
 
177
        self.addCleanup(b.unlock)
 
178
        tree = b.basis_tree()
 
179
        export.export(tree, 'target', format='dir', subdir='subdir',
 
180
            per_file_timestamps=True)
 
181
        t = self.get_transport('target')
 
182
        self.assertEqual(foo_time, t.stat('foo.txt').st_mtime)
 
183
 
 
184
 
 
185
class TarExporterTests(tests.TestCaseWithTransport):
 
186
 
 
187
    def test_xz(self):
 
188
        self.requireFeature(features.lzma)
 
189
        import lzma
 
190
        wt = self.make_branch_and_tree('.')
 
191
        self.build_tree(['a'])
 
192
        wt.add(["a"])
 
193
        wt.commit("1")
 
194
        export.export(wt, 'target.tar.xz', format="txz")
 
195
        tf = tarfile.open(fileobj=lzma.LZMAFile('target.tar.xz'))
 
196
        self.assertEqual(["target/a"], tf.getnames())
 
197
 
 
198
    def test_lzma(self):
 
199
        self.requireFeature(features.lzma)
 
200
        import lzma
 
201
        wt = self.make_branch_and_tree('.')
 
202
        self.build_tree(['a'])
 
203
        wt.add(["a"])
 
204
        wt.commit("1")
 
205
        export.export(wt, 'target.tar.lzma', format="tlzma")
 
206
        tf = tarfile.open(fileobj=lzma.LZMAFile('target.tar.lzma'))
 
207
        self.assertEqual(["target/a"], tf.getnames())
 
208
 
 
209
    def test_tgz(self):
 
210
        wt = self.make_branch_and_tree('.')
 
211
        self.build_tree(['a'])
 
212
        wt.add(["a"])
 
213
        wt.commit("1")
 
214
        export.export(wt, 'target.tar.gz', format="tgz")
 
215
        tf = tarfile.open('target.tar.gz')
 
216
        self.assertEqual(["target/a"], tf.getnames())
 
217
 
 
218
    def test_tgz_ignores_dest_path(self):
 
219
        # The target path should not be a part of the target file.
 
220
        # (bug #102234)
 
221
        wt = self.make_branch_and_tree('.')
 
222
        self.build_tree(['a'])
 
223
        wt.add(["a"])
 
224
        wt.commit("1")
 
225
        os.mkdir("testdir1")
 
226
        os.mkdir("testdir2")
 
227
        export.export(wt, 'testdir1/target.tar.gz', format="tgz",
 
228
            per_file_timestamps=True)
 
229
        export.export(wt, 'testdir2/target.tar.gz', format="tgz",
 
230
            per_file_timestamps=True)
 
231
        file1 = open('testdir1/target.tar.gz', 'rb')
 
232
        self.addCleanup(file1.close)
 
233
        file2 = open('testdir1/target.tar.gz', 'rb')
 
234
        self.addCleanup(file2.close)
 
235
        content1 = file1.read()
 
236
        content2 = file2.read()
 
237
        self.assertEqualDiff(content1, content2)
 
238
        # the gzip module doesn't have a way to read back to the original
 
239
        # filename, but it's stored as-is in the tarfile.
 
240
        self.assertFalse(b"testdir1" in content1)
 
241
        self.assertFalse(b"target.tar.gz" in content1)
 
242
        self.assertTrue(b"target.tar" in content1)
 
243
 
 
244
    def test_tbz2(self):
 
245
        wt = self.make_branch_and_tree('.')
 
246
        self.build_tree(['a'])
 
247
        wt.add(["a"])
 
248
        wt.commit("1")
 
249
        export.export(wt, 'target.tar.bz2', format="tbz2")
 
250
        tf = tarfile.open('target.tar.bz2')
 
251
        self.assertEqual(["target/a"], tf.getnames())
 
252
 
 
253
    def test_export_tarball_generator(self):
 
254
        wt = self.make_branch_and_tree('.')
 
255
        self.build_tree(['a'])
 
256
        wt.add(["a"])
 
257
        wt.commit("1", timestamp=42)
 
258
        target = BytesIO()
 
259
        with wt.lock_read():
 
260
            target.writelines(tarball_generator(wt, "bar"))
 
261
        # Ball should now be closed.
 
262
        target.seek(0)
 
263
        ball2 = tarfile.open(None, "r", target)
 
264
        self.addCleanup(ball2.close)
 
265
        self.assertEqual(["bar/a"], ball2.getnames())
 
266
 
 
267
 
 
268
class ZipExporterTests(tests.TestCaseWithTransport):
 
269
 
 
270
    def test_per_file_timestamps(self):
 
271
        tree = self.make_branch_and_tree('.')
 
272
        self.build_tree_contents([('har', b'foo')])
 
273
        tree.add('har')
 
274
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
 
275
        timestamp = 347151600
 
276
        tree.commit('setup', timestamp=timestamp)
 
277
        export.export(tree.basis_tree(), 'test.zip', format='zip',
 
278
            per_file_timestamps=True)
 
279
        zfile = zipfile.ZipFile('test.zip')
 
280
        info = zfile.getinfo("test/har")
 
281
        self.assertEqual(time.localtime(timestamp)[:6], info.date_time)
 
282
 
 
283
 
 
284
class RootNameTests(tests.TestCase):
 
285
 
 
286
    def test_root_name(self):
 
287
        self.assertEqual('mytest', get_root_name('../mytest.tar'))
 
288
        self.assertEqual('mytar', get_root_name('mytar.tar'))
 
289
        self.assertEqual('mytar', get_root_name('mytar.tar.bz2'))
 
290
        self.assertEqual('tar.tar.tar', get_root_name('tar.tar.tar.tgz'))
 
291
        self.assertEqual('bzr-0.0.5', get_root_name('bzr-0.0.5.tar.gz'))
 
292
        self.assertEqual('bzr-0.0.5', get_root_name('bzr-0.0.5.zip'))
 
293
        self.assertEqual('bzr-0.0.5', get_root_name('bzr-0.0.5'))
 
294
        self.assertEqual('mytar', get_root_name('a/long/path/mytar.tgz'))
 
295
        self.assertEqual('other',
 
296
            get_root_name('../parent/../dir/other.tbz2'))
 
297
        self.assertEqual('', get_root_name('-'))