← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_export.py

Merge bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_export.py
19
19
"""
20
20
 
21
21
import os
 
22
import stat
 
23
import sys
 
24
import tarfile
 
25
import zipfile
22
26
 
23
 
from bzrlib.branch import Branch
 
27
from bzrlib.export import (
 
28
    zip_exporter,
 
29
    )
 
30
from bzrlib.tests import TestSkipped
24
31
from bzrlib.tests.blackbox import ExternalBase
25
 
import tarfile, zipfile
 
32
 
26
33
 
27
34
class TestExport(ExternalBase):
28
35
 
29
36
    def test_tar_export(self):
 
37
        tree = self.make_branch_and_tree('tar')
 
38
        self.build_tree(['tar/a'])
 
39
        tree.add('a')
30
40
 
31
 
        os.mkdir('tar')
32
41
        os.chdir('tar')
 
42
        self.run_bzr('ignore', 'something')
 
43
        tree.commit('1')
33
44
 
34
 
        self.runbzr('init')
35
 
        open('a', 'wb').write('foo\n')
36
 
        self.runbzr('add a')
37
 
        self.runbzr('ignore something')
38
 
        self.runbzr('commit -m 1')
39
 
        self.runbzr('export test.tar.gz')
 
45
        self.failUnless(tree.has_filename('.bzrignore'))
 
46
        self.run_bzr('export', 'test.tar.gz')
40
47
        ball = tarfile.open('test.tar.gz')
41
 
        for m in ball.getnames():
42
 
            #print m
43
 
            self.failIf(os.path.basename(m) == '.bzrignore', 'tar export contains .bzrignore')
 
48
        # Make sure the tarball contains 'a', but does not contain
 
49
        # '.bzrignore'.
 
50
        self.assertEqual(['test/a'], sorted(ball.getnames()))
 
51
 
 
52
    def test_tar_export_unicode(self):
 
53
        tree = self.make_branch_and_tree('tar')
 
54
        fname = u'\xe5.txt'
 
55
        try:
 
56
            self.build_tree(['tar/' + fname])
 
57
        except UnicodeError:
 
58
            raise TestSkipped('Unable to represent path %r' % (fname,))
 
59
        tree.add([fname])
 
60
        tree.commit('first')
 
61
 
 
62
        os.chdir('tar')
 
63
        self.run_bzr('export', 'test.tar')
 
64
        ball = tarfile.open('test.tar')
 
65
        # all paths are prefixed with the base name of the tarball
 
66
        self.assertEqual(['test/' + fname.encode('utf8')],
 
67
                         sorted(ball.getnames()))
44
68
 
45
69
    def test_zip_export(self):
46
 
 
47
 
        os.mkdir('zip')
48
 
        os.chdir('zip')
49
 
 
50
 
        self.runbzr('init')
51
 
        open('a', 'wb').write('foo\n')
52
 
        self.runbzr('add a')
53
 
        self.runbzr('ignore something')
54
 
        self.runbzr('commit -m 1')
55
 
        self.runbzr('export test.zip')
56
 
        ball = zipfile.ZipFile('test.zip')
57
 
        for m in ball.namelist():
58
 
            #print m
59
 
            self.failIf(os.path.basename(m) == '.bzrignore', 'zip export contains .bzrignore')
 
70
        tree = self.make_branch_and_tree('zip')
 
71
        self.build_tree(['zip/a'])
 
72
        tree.add('a')
 
73
 
 
74
        os.chdir('zip')
 
75
        self.run_bzr('ignore', 'something')
 
76
        tree.commit('1')
 
77
 
 
78
        self.failUnless(tree.has_filename('.bzrignore'))
 
79
        self.run_bzr('export', 'test.zip')
 
80
 
 
81
        zfile = zipfile.ZipFile('test.zip')
 
82
        # Make sure the zipfile contains 'a', but does not contain
 
83
        # '.bzrignore'.
 
84
        self.assertEqual(['test/a'], sorted(zfile.namelist()))
 
85
 
 
86
    def test_zip_export_unicode(self):
 
87
        tree = self.make_branch_and_tree('zip')
 
88
        fname = u'\xe5.txt'
 
89
        try:
 
90
            self.build_tree(['zip/' + fname])
 
91
        except UnicodeError:
 
92
            raise TestSkipped('Unable to represent path %r' % (fname,))
 
93
        tree.add([fname])
 
94
        tree.commit('first')
 
95
 
 
96
        os.chdir('zip')
 
97
        self.run_bzr('export', 'test.zip')
 
98
        zfile = zipfile.ZipFile('test.zip')
 
99
        # all paths are prefixed with the base name of the zipfile
 
100
        self.assertEqual(['test/' + fname.encode('utf8')],
 
101
                         sorted(zfile.namelist()))
 
102
 
 
103
    def test_zip_export_directories(self):
 
104
        tree = self.make_branch_and_tree('zip')
 
105
        self.build_tree(['zip/a', 'zip/b/', 'zip/b/c', 'zip/d/'])
 
106
        tree.add(['a', 'b', 'b/c', 'd'])
 
107
        tree.commit('init')
 
108
 
 
109
        os.chdir('zip')
 
110
        self.run_bzr('export', 'test.zip')
 
111
        zfile = zipfile.ZipFile('test.zip')
 
112
        names = sorted(zfile.namelist())
 
113
 
 
114
        # even on win32, zipfile.ZipFile changes all names to use
 
115
        # forward slashes
 
116
        self.assertEqual(['test/a', 'test/b/', 'test/b/c', 'test/d/'], names)
 
117
 
 
118
        file_attr = stat.S_IFREG
 
119
        dir_attr = stat.S_IFDIR | zip_exporter.ZIP_DIRECTORY_BIT
 
120
 
 
121
        a_info = zfile.getinfo(names[0])
 
122
        self.assertEqual(file_attr, a_info.external_attr)
 
123
 
 
124
        b_info = zfile.getinfo(names[1])
 
125
        self.assertEqual(dir_attr, b_info.external_attr)
 
126
 
 
127
        c_info = zfile.getinfo(names[2])
 
128
        self.assertEqual(file_attr, c_info.external_attr)
 
129
 
 
130
        d_info = zfile.getinfo(names[3])
 
131
        self.assertEqual(dir_attr, d_info.external_attr)
60
132
 
61
133
    def test_dir_export(self):
 
134
        tree = self.make_branch_and_tree('dir')
 
135
        self.build_tree(['dir/a'])
 
136
        tree.add('a')
62
137
 
63
 
        os.mkdir('dir')
64
138
        os.chdir('dir')
 
139
        self.run_bzr('ignore', 'something')
 
140
        tree.commit('1')
65
141
 
66
 
        self.runbzr('init')
67
 
        open('a', 'wb').write('foo\n')
68
 
        self.runbzr('add a')
69
 
        self.runbzr('ignore something')
70
 
        self.runbzr('commit -m 1')
71
 
        self.runbzr('export direxport')
 
142
        self.failUnless(tree.has_filename('.bzrignore'))
 
143
        self.run_bzr('export', 'direxport')
72
144
 
73
145
        files = sorted(os.listdir('direxport'))
74
 
        self.assertEqual(['a'], files, 'dir contains .bzrignore')
 
146
        # Make sure the exported directory contains 'a', but does not contain
 
147
        # '.bzrignore'.
 
148
        self.assertEqual(['a'], files)
 
149
 
 
150
    def example_branch(self):
 
151
        tree = self.make_branch_and_tree('branch')
 
152
        self.build_tree_contents([('branch/hello', 'foo')])
 
153
        tree.add('hello')
 
154
        tree.commit('setup')
 
155
 
 
156
        self.build_tree_contents([('branch/goodbye', 'baz')])
 
157
        tree.add('goodbye')
 
158
        tree.commit('setup')
 
159
        return tree
 
160
        
 
161
    def test_basic_directory_export(self):
 
162
        self.example_branch()
 
163
        os.chdir('branch')
 
164
 
 
165
        # Directory exports
 
166
        self.run_bzr('export', '../latest')
 
167
        self.assertEqual(['goodbye', 'hello'], sorted(os.listdir('../latest')))
 
168
        self.check_file_contents('../latest/goodbye', 'baz')
 
169
        self.run_bzr('export', '../first', '-r', '1')
 
170
        self.assertEqual(['hello'], sorted(os.listdir('../first')))
 
171
        self.check_file_contents('../first/hello', 'foo')
 
172
 
 
173
        # Even with .gz and .bz2 it is still a directory
 
174
        self.run_bzr('export', '../first.gz', '-r', '1')
 
175
        self.check_file_contents('../first.gz/hello', 'foo')
 
176
        self.run_bzr('export', '../first.bz2', '-r', '1')
 
177
        self.check_file_contents('../first.bz2/hello', 'foo')
 
178
 
 
179
    def test_basic_tarfile_export(self):
 
180
        self.example_branch()
 
181
        os.chdir('branch')
 
182
 
 
183
        self.run_bzr('export', '../first.tar', '-r', '1')
 
184
        self.failUnless(os.path.isfile('../first.tar'))
 
185
        tf = tarfile.open('../first.tar')
 
186
        try:
 
187
            self.assertEqual(['first/hello'], sorted(tf.getnames()))
 
188
            self.assertEqual('foo', tf.extractfile('first/hello').read())
 
189
        finally:
 
190
            tf.close()
 
191
 
 
192
        self.run_bzr('export', '../first.tar.gz', '-r', '1')
 
193
        self.failUnless(os.path.isfile('../first.tar.gz'))
 
194
        self.run_bzr('export', '../first.tbz2', '-r', '1')
 
195
        self.failUnless(os.path.isfile('../first.tbz2'))
 
196
        self.run_bzr('export', '../first.tar.bz2', '-r', '1')
 
197
        self.failUnless(os.path.isfile('../first.tar.bz2'))
 
198
        self.run_bzr('export', '../first.tar.tbz2', '-r', '1')
 
199
        self.failUnless(os.path.isfile('../first.tar.tbz2'))
 
200
 
 
201
        tf = tarfile.open('../first.tar.tbz2', 'r:bz2')
 
202
        try:
 
203
            self.assertEqual(['first.tar/hello'], sorted(tf.getnames()))
 
204
            self.assertEqual('foo', tf.extractfile('first.tar/hello').read())
 
205
        finally:
 
206
            tf.close()
 
207
        self.run_bzr('export', '../first2.tar', '-r', '1', '--root', 'pizza')
 
208
        tf = tarfile.open('../first2.tar')
 
209
        try:
 
210
            self.assertEqual(['pizza/hello'], sorted(tf.getnames()))
 
211
            self.assertEqual('foo', tf.extractfile('pizza/hello').read())
 
212
        finally:
 
213
            tf.close()
 
214
 
 
215
    def test_basic_zipfile_export(self):
 
216
        self.example_branch()
 
217
        os.chdir('branch')
 
218
 
 
219
        self.run_bzr('export', '../first.zip', '-r', '1')
 
220
        self.failUnlessExists('../first.zip')
 
221
        zf = zipfile.ZipFile('../first.zip')
 
222
        try:
 
223
            self.assertEqual(['first/hello'], sorted(zf.namelist()))
 
224
            self.assertEqual('foo', zf.read('first/hello'))
 
225
        finally:
 
226
            zf.close()
 
227
 
 
228
        self.run_bzr('export', '../first2.zip', '-r', '1', '--root', 'pizza')
 
229
        zf = zipfile.ZipFile('../first2.zip')
 
230
        try:
 
231
            self.assertEqual(['pizza/hello'], sorted(zf.namelist()))
 
232
            self.assertEqual('foo', zf.read('pizza/hello'))
 
233
        finally:
 
234
            zf.close()
 
235
        
 
236
        self.run_bzr('export', '../first-zip', '--format=zip', '-r', '1')
 
237
        zf = zipfile.ZipFile('../first-zip')
 
238
        try:
 
239
            self.assertEqual(['first-zip/hello'], sorted(zf.namelist()))
 
240
            self.assertEqual('foo', zf.read('first-zip/hello'))
 
241
        finally:
 
242
            zf.close()
 
243