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

  • Committer: Jelmer Vernooij
  • Date: 2017-05-21 12:41:27 UTC
  • mto: This revision was merged to the branch mainline in revision 6623.
  • Revision ID: jelmer@jelmer.uk-20170521124127-iv8etg0vwymyai6y
s/bzr/brz/ in apport config.

Show diffs side-by-side

added added

removed removed

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