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

  • Committer: Marius Kruger
  • Date: 2010-07-10 21:28:56 UTC
  • mto: (5384.1.1 integration)
  • mto: This revision was merged to the branch mainline in revision 5385.
  • Revision ID: marius.kruger@enerweb.co.za-20100710212856-uq4ji3go0u5se7hx
* Update documentation
* add NEWS

Show diffs side-by-side

added added

removed removed

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