← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_export.py

  • Committer: Jelmer Vernooij
  • Date: 2011-05-10 07:46:15 UTC
  • mfrom: (5844 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5845.
  • Revision ID: jelmer@samba.org-20110510074615-eptod049ndjxc4i7
Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/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 bzrlib.export."""
 
18
 
 
19
from cStringIO import StringIO
17
20
import os
 
21
import tarfile
18
22
import time
 
23
import zipfile
19
24
 
20
25
from bzrlib import (
21
26
    errors,
22
27
    export,
23
28
    tests,
24
29
    )
25
 
 
26
 
 
27
 
class TestExport(tests.TestCaseWithTransport):
28
 
 
29
 
    def test_dir_export_missing_file(self):
 
30
from bzrlib.export import get_root_name
 
31
from bzrlib.export.tar_exporter import export_tarball
 
32
from bzrlib.tests import features
 
33
 
 
34
 
 
35
class TestDirExport(tests.TestCaseWithTransport):
 
36
 
 
37
    def test_missing_file(self):
30
38
        self.build_tree(['a/', 'a/b', 'a/c'])
31
39
        wt = self.make_branch_and_tree('.')
32
40
        wt.add(['a', 'a/b', 'a/c'])
33
41
        os.unlink('a/c')
34
42
        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):
 
43
        self.assertPathExists('target/a/b')
 
44
        self.assertPathDoesNotExist('target/a/c')
 
45
 
 
46
    def test_empty(self):
 
47
        wt = self.make_branch_and_tree('.')
 
48
        export.export(wt, 'target', format="dir")
 
49
        self.assertEquals([], os.listdir("target"))
 
50
 
 
51
    def test_symlink(self):
39
52
        self.requireFeature(tests.SymlinkFeature)
40
53
        wt = self.make_branch_and_tree('.')
41
54
        os.symlink('source', 'link')
42
55
        wt.add(['link'])
43
56
        export.export(wt, 'target', format="dir")
44
 
        self.failUnlessExists('target/link')
 
57
        self.assertPathExists('target/link')
45
58
 
46
 
    def test_dir_export_to_existing_empty_dir_success(self):
 
59
    def test_to_existing_empty_dir_success(self):
47
60
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
48
61
        wt = self.make_branch_and_tree('source')
49
62
        wt.add(['a', 'b', 'b/c'])
50
63
        wt.commit('1')
51
64
        self.build_tree(['target/'])
52
65
        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):
 
66
        self.assertPathExists('target/a')
 
67
        self.assertPathExists('target/b')
 
68
        self.assertPathExists('target/b/c')
 
69
 
 
70
    def test_empty_subdir(self):
 
71
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
 
72
        wt = self.make_branch_and_tree('source')
 
73
        wt.add(['a', 'b', 'b/c'])
 
74
        wt.commit('1')
 
75
        self.build_tree(['target/'])
 
76
        export.export(wt, 'target', format="dir", subdir='')
 
77
        self.assertPathExists('target/a')
 
78
        self.assertPathExists('target/b')
 
79
        self.assertPathExists('target/b/c')
 
80
 
 
81
    def test_to_existing_nonempty_dir_fail(self):
58
82
        self.build_tree(['source/', 'source/a', 'source/b/', 'source/b/c'])
59
83
        wt = self.make_branch_and_tree('source')
60
84
        wt.add(['a', 'b', 'b/c'])
62
86
        self.build_tree(['target/', 'target/foo'])
63
87
        self.assertRaises(errors.BzrError, export.export, wt, 'target', format="dir")
64
88
 
65
 
    def test_dir_export_existing_single_file(self):
 
89
    def test_existing_single_file(self):
66
90
        self.build_tree(['dir1/', 'dir1/dir2/', 'dir1/first', 'dir1/dir2/second'])
67
91
        wtree = self.make_branch_and_tree('dir1')
68
92
        wtree.add(['dir2', 'first', 'dir2/second'])
69
93
        wtree.commit('1')
70
94
        export.export(wtree, 'target1', format='dir', subdir='first')
71
 
        self.failUnlessExists('target1/first')
 
95
        self.assertPathExists('target1/first')
72
96
        export.export(wtree, 'target2', format='dir', subdir='dir2/second')
73
 
        self.failUnlessExists('target2/second')
74
 
        
75
 
    def test_dir_export_files_same_timestamp(self):
 
97
        self.assertPathExists('target2/second')
 
98
 
 
99
    def test_files_same_timestamp(self):
76
100
        builder = self.make_branch_builder('source')
77
101
        builder.start_series()
78
102
        builder.build_snapshot(None, None, [
99
123
        # All files must be given the same mtime.
100
124
        self.assertEqual(st_a.st_mtime, st_b.st_mtime)
101
125
 
102
 
    def test_dir_export_files_per_file_timestamps(self):
 
126
    def test_files_per_file_timestamps(self):
103
127
        builder = self.make_branch_builder('source')
104
128
        builder.start_series()
105
129
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
121
145
        t = self.get_transport('target')
122
146
        self.assertEqual(a_time, t.stat('a').st_mtime)
123
147
        self.assertEqual(b_time, t.stat('b').st_mtime)
 
148
 
 
149
 
 
150
class TarExporterTests(tests.TestCaseWithTransport):
 
151
 
 
152
    def test_xz(self):
 
153
        self.requireFeature(features.lzma)
 
154
        import lzma
 
155
        wt = self.make_branch_and_tree('.')
 
156
        self.build_tree(['a'])
 
157
        wt.add(["a"])
 
158
        wt.commit("1")
 
159
        export.export(wt, 'target.tar.xz', format="txz")
 
160
        tf = tarfile.open(fileobj=lzma.LZMAFile('target.tar.xz'))
 
161
        self.assertEquals(["target/a"], tf.getnames())
 
162
 
 
163
    def test_lzma(self):
 
164
        self.requireFeature(features.lzma)
 
165
        import lzma
 
166
        wt = self.make_branch_and_tree('.')
 
167
        self.build_tree(['a'])
 
168
        wt.add(["a"])
 
169
        wt.commit("1")
 
170
        export.export(wt, 'target.tar.lzma', format="tlzma")
 
171
        tf = tarfile.open(fileobj=lzma.LZMAFile('target.tar.lzma'))
 
172
        self.assertEquals(["target/a"], tf.getnames())
 
173
 
 
174
    def test_tgz(self):
 
175
        wt = self.make_branch_and_tree('.')
 
176
        self.build_tree(['a'])
 
177
        wt.add(["a"])
 
178
        wt.commit("1")
 
179
        export.export(wt, 'target.tar.gz', format="tgz")
 
180
        tf = tarfile.open('target.tar.gz')
 
181
        self.assertEquals(["target/a"], tf.getnames())
 
182
 
 
183
    def test_tgz_ignores_dest_path(self):
 
184
        # The target path should not be a part of the target file.
 
185
        # (bug #102234)
 
186
        wt = self.make_branch_and_tree('.')
 
187
        self.build_tree(['a'])
 
188
        wt.add(["a"])
 
189
        wt.commit("1")
 
190
        os.mkdir("testdir1")
 
191
        os.mkdir("testdir2")
 
192
        export.export(wt, 'testdir1/target.tar.gz', format="tgz",
 
193
            per_file_timestamps=True)
 
194
        export.export(wt, 'testdir2/target.tar.gz', format="tgz",
 
195
            per_file_timestamps=True)
 
196
        file1 = open('testdir1/target.tar.gz', 'r')
 
197
        self.addCleanup(file1.close)
 
198
        file2 = open('testdir1/target.tar.gz', 'r')
 
199
        self.addCleanup(file2.close)
 
200
        content1 = file1.read()
 
201
        content2 = file2.read()
 
202
        self.assertEqualDiff(content1, content2)
 
203
        # the gzip module doesn't have a way to read back to the original
 
204
        # filename, but it's stored as-is in the tarfile.
 
205
        self.assertFalse("testdir1" in content1)
 
206
        self.assertFalse("target.tar.gz" in content1)
 
207
        self.assertTrue("target.tar" in content1)
 
208
 
 
209
    def test_tbz2(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.bz2', format="tbz2")
 
215
        tf = tarfile.open('target.tar.bz2')
 
216
        self.assertEquals(["target/a"], tf.getnames())
 
217
 
 
218
    def test_xz_stdout(self):
 
219
        wt = self.make_branch_and_tree('.')
 
220
        self.assertRaises(errors.BzrError, export.export, wt, '-',
 
221
            format="txz")
 
222
 
 
223
    def test_export_tarball(self):
 
224
        wt = self.make_branch_and_tree('.')
 
225
        self.build_tree(['a'])
 
226
        wt.add(["a"])
 
227
        wt.commit("1", timestamp=42)
 
228
        target = StringIO()
 
229
        ball = tarfile.open(None, "w|", target)
 
230
        wt.lock_read()
 
231
        try:
 
232
            export_tarball(wt, ball, "bar")
 
233
        finally:
 
234
            wt.unlock()
 
235
        self.assertEquals(["bar/a"], ball.getnames())
 
236
        ball.close()
 
237
 
 
238
 
 
239
class ZipExporterTests(tests.TestCaseWithTransport):
 
240
 
 
241
    def test_per_file_timestamps(self):
 
242
        tree = self.make_branch_and_tree('.')
 
243
        self.build_tree_contents([('har', 'foo')])
 
244
        tree.add('har')
 
245
        # Earliest allowable date on FAT32 filesystems is 1980-01-01
 
246
        timestamp = 347151600
 
247
        tree.commit('setup', timestamp=timestamp)
 
248
        export.export(tree.basis_tree(), 'test.zip', format='zip',
 
249
            per_file_timestamps=True)
 
250
        zfile = zipfile.ZipFile('test.zip')
 
251
        info = zfile.getinfo("test/har")
 
252
        self.assertEquals(time.localtime(timestamp)[:6], info.date_time)
 
253
 
 
254
 
 
255
class RootNameTests(tests.TestCase):
 
256
 
 
257
    def test_root_name(self):
 
258
        self.assertEquals('mytest', get_root_name('../mytest.tar'))
 
259
        self.assertEquals('mytar', get_root_name('mytar.tar'))
 
260
        self.assertEquals('mytar', get_root_name('mytar.tar.bz2'))
 
261
        self.assertEquals('tar.tar.tar', get_root_name('tar.tar.tar.tgz'))
 
262
        self.assertEquals('bzr-0.0.5', get_root_name('bzr-0.0.5.tar.gz'))
 
263
        self.assertEquals('bzr-0.0.5', get_root_name('bzr-0.0.5.zip'))
 
264
        self.assertEquals('bzr-0.0.5', get_root_name('bzr-0.0.5'))
 
265
        self.assertEquals('mytar', get_root_name('a/long/path/mytar.tgz'))
 
266
        self.assertEquals('other',
 
267
            get_root_name('../parent/../dir/other.tbz2'))
 
268
        self.assertEquals('', get_root_name('-'))