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

  • Committer: Jelmer Vernooij
  • Date: 2010-05-02 18:32:55 UTC
  • mto: (0.200.912 trunk)
  • mto: This revision was merged to the branch mainline in revision 6960.
  • Revision ID: jelmer@samba.org-20100502183255-vdvzcj2sb66cga3p
Fix file id map (de)serialization.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_builder.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Test our ability to build up test repositories"""
18
18
 
19
 
from io import BytesIO
20
 
 
21
 
from dulwich.repo import Repo as GitRepo
22
 
 
23
 
from .. import tests
 
19
from cStringIO import StringIO
 
20
 
 
21
from bzrlib.plugins.git import tests
24
22
 
25
23
 
26
24
class TestGitBranchBuilder(tests.TestCase):
27
25
 
28
26
    def test__create_blob(self):
29
 
        stream = BytesIO()
 
27
        stream = StringIO()
30
28
        builder = tests.GitBranchBuilder(stream)
31
 
        self.assertEqual(1, builder._create_blob(b'foo\nbar\n'))
32
 
        self.assertEqualDiff(b'blob\nmark :1\ndata 8\nfoo\nbar\n\n',
 
29
        self.assertEqual(1, builder._create_blob('foo\nbar\n'))
 
30
        self.assertEqualDiff('blob\nmark :1\ndata 8\nfoo\nbar\n\n',
33
31
                             stream.getvalue())
34
32
 
35
33
    def test_set_file(self):
36
 
        stream = BytesIO()
 
34
        stream = StringIO()
37
35
        builder = tests.GitBranchBuilder(stream)
38
 
        builder.set_file('foobar', b'foo\nbar\n', False)
39
 
        self.assertEqualDiff(b'blob\nmark :1\ndata 8\nfoo\nbar\n\n',
 
36
        builder.set_file('foobar', 'foo\nbar\n', False)
 
37
        self.assertEqualDiff('blob\nmark :1\ndata 8\nfoo\nbar\n\n',
40
38
                             stream.getvalue())
41
 
        self.assertEqual([b'M 100644 :1 foobar\n'], builder.commit_info)
 
39
        self.assertEqual(['M 100644 :1 foobar\n'], builder.commit_info)
42
40
 
43
41
    def test_set_file_unicode(self):
44
 
        stream = BytesIO()
 
42
        stream = StringIO()
45
43
        builder = tests.GitBranchBuilder(stream)
46
 
        builder.set_file(u'f\xb5/bar', b'contents\nbar\n', False)
47
 
        self.assertEqualDiff(b'blob\nmark :1\ndata 13\ncontents\nbar\n\n',
 
44
        builder.set_file(u'f\xb5/bar', 'contents\nbar\n', False)
 
45
        self.assertEqualDiff('blob\nmark :1\ndata 13\ncontents\nbar\n\n',
48
46
                             stream.getvalue())
49
 
        self.assertEqual([b'M 100644 :1 f\xc2\xb5/bar\n'], builder.commit_info)
 
47
        self.assertEqual(['M 100644 :1 f\xc2\xb5/bar\n'], builder.commit_info)
50
48
 
51
49
    def test_set_file_newline(self):
52
 
        stream = BytesIO()
 
50
        stream = StringIO()
53
51
        builder = tests.GitBranchBuilder(stream)
54
 
        builder.set_file(u'foo\nbar', b'contents\nbar\n', False)
55
 
        self.assertEqualDiff(b'blob\nmark :1\ndata 13\ncontents\nbar\n\n',
 
52
        builder.set_file(u'foo\nbar', 'contents\nbar\n', False)
 
53
        self.assertEqualDiff('blob\nmark :1\ndata 13\ncontents\nbar\n\n',
56
54
                             stream.getvalue())
57
 
        self.assertEqual([b'M 100644 :1 "foo\\nbar"\n'], builder.commit_info)
 
55
        self.assertEqual(['M 100644 :1 "foo\\nbar"\n'], builder.commit_info)
58
56
 
59
57
    def test_set_file_executable(self):
60
 
        stream = BytesIO()
61
 
        builder = tests.GitBranchBuilder(stream)
62
 
        builder.set_file(u'f\xb5/bar', b'contents\nbar\n', True)
63
 
        self.assertEqualDiff(b'blob\nmark :1\ndata 13\ncontents\nbar\n\n',
64
 
                             stream.getvalue())
65
 
        self.assertEqual([b'M 100755 :1 f\xc2\xb5/bar\n'], builder.commit_info)
66
 
 
67
 
    def test_set_symlink(self):
68
 
        stream = BytesIO()
69
 
        builder = tests.GitBranchBuilder(stream)
70
 
        builder.set_symlink(u'f\xb5/bar', b'link/contents')
71
 
        self.assertEqualDiff(b'blob\nmark :1\ndata 13\nlink/contents\n',
72
 
                             stream.getvalue())
73
 
        self.assertEqual([b'M 120000 :1 f\xc2\xb5/bar\n'], builder.commit_info)
74
 
 
75
 
    def test_set_symlink_newline(self):
76
 
        stream = BytesIO()
77
 
        builder = tests.GitBranchBuilder(stream)
78
 
        builder.set_symlink(u'foo\nbar', 'link/contents')
79
 
        self.assertEqualDiff(b'blob\nmark :1\ndata 13\nlink/contents\n',
80
 
                             stream.getvalue())
81
 
        self.assertEqual([b'M 120000 :1 "foo\\nbar"\n'], builder.commit_info)
 
58
        stream = StringIO()
 
59
        builder = tests.GitBranchBuilder(stream)
 
60
        builder.set_file(u'f\xb5/bar', 'contents\nbar\n', True)
 
61
        self.assertEqualDiff('blob\nmark :1\ndata 13\ncontents\nbar\n\n',
 
62
                             stream.getvalue())
 
63
        self.assertEqual(['M 100755 :1 f\xc2\xb5/bar\n'], builder.commit_info)
 
64
 
 
65
    def test_set_link(self):
 
66
        stream = StringIO()
 
67
        builder = tests.GitBranchBuilder(stream)
 
68
        builder.set_link(u'f\xb5/bar', 'link/contents')
 
69
        self.assertEqualDiff('blob\nmark :1\ndata 13\nlink/contents\n',
 
70
                             stream.getvalue())
 
71
        self.assertEqual(['M 120000 :1 f\xc2\xb5/bar\n'], builder.commit_info)
 
72
 
 
73
    def test_set_link_newline(self):
 
74
        stream = StringIO()
 
75
        builder = tests.GitBranchBuilder(stream)
 
76
        builder.set_link(u'foo\nbar', 'link/contents')
 
77
        self.assertEqualDiff('blob\nmark :1\ndata 13\nlink/contents\n',
 
78
                             stream.getvalue())
 
79
        self.assertEqual(['M 120000 :1 "foo\\nbar"\n'], builder.commit_info)
82
80
 
83
81
    def test_delete_entry(self):
84
 
        stream = BytesIO()
 
82
        stream = StringIO()
85
83
        builder = tests.GitBranchBuilder(stream)
86
84
        builder.delete_entry(u'path/to/f\xb5')
87
 
        self.assertEqual([b'D path/to/f\xc2\xb5\n'], builder.commit_info)
 
85
        self.assertEqual(['D path/to/f\xc2\xb5\n'], builder.commit_info)
88
86
 
89
87
    def test_delete_entry_newline(self):
90
 
        stream = BytesIO()
 
88
        stream = StringIO()
91
89
        builder = tests.GitBranchBuilder(stream)
92
90
        builder.delete_entry(u'path/to/foo\nbar')
93
 
        self.assertEqual([b'D "path/to/foo\\nbar"\n'], builder.commit_info)
 
91
        self.assertEqual(['D "path/to/foo\\nbar"\n'], builder.commit_info)
94
92
 
95
93
    def test_encode_path(self):
96
94
        encode = tests.GitBranchBuilder._encode_path
97
95
        # Unicode is encoded to utf-8
98
 
        self.assertEqual(encode(u'f\xb5'), b'f\xc2\xb5')
 
96
        self.assertEqual(encode(u'f\xb5'), 'f\xc2\xb5')
99
97
        # The name must be quoted if it starts by a double quote or contains a
100
98
        # newline.
101
 
        self.assertEqual(encode(u'"foo'), b'"\\"foo"')
102
 
        self.assertEqual(encode(u'fo\no'), b'"fo\\no"')
 
99
        self.assertEqual(encode(u'"foo'), '"\\"foo"')
 
100
        self.assertEqual(encode(u'fo\no'), '"fo\\no"')
103
101
        # When the name is quoted, all backslash and quote chars must be
104
102
        # escaped.
105
 
        self.assertEqual(encode(u'fo\\o\nbar'), b'"fo\\\\o\\nbar"')
106
 
        self.assertEqual(encode(u'fo"o"\nbar'), b'"fo\\"o\\"\\nbar"')
 
103
        self.assertEqual(encode(u'fo\\o\nbar'), '"fo\\\\o\\nbar"')
 
104
        self.assertEqual(encode(u'fo"o"\nbar'), '"fo\\"o\\"\\nbar"')
107
105
        # Other control chars, such as \r, need not be escaped.
108
 
        self.assertEqual(encode(u'foo\r\nbar'), b'"foo\r\\nbar"')
 
106
        self.assertEqual(encode(u'foo\r\nbar'), '"foo\r\\nbar"')
109
107
 
110
108
    def test_add_and_commit(self):
111
 
        stream = BytesIO()
 
109
        stream = StringIO()
112
110
        builder = tests.GitBranchBuilder(stream)
113
111
 
114
 
        builder.set_file(u'f\xb5/bar', b'contents\nbar\n', False)
115
 
        self.assertEqual(b'2', builder.commit(b'Joe Foo <joe@foo.com>',
116
 
                                              u'committing f\xb5/bar',
117
 
                                              timestamp=1194586400,
118
 
                                              timezone=b'+0100'))
119
 
        self.assertEqualDiff(b'blob\nmark :1\ndata 13\ncontents\nbar\n\n'
120
 
                             b'commit refs/heads/master\n'
121
 
                             b'mark :2\n'
122
 
                             b'committer Joe Foo <joe@foo.com> 1194586400 +0100\n'
123
 
                             b'data 18\n'
124
 
                             b'committing f\xc2\xb5/bar'
125
 
                             b'\n'
126
 
                             b'M 100644 :1 f\xc2\xb5/bar\n'
127
 
                             b'\n',
 
112
        builder.set_file(u'f\xb5/bar', 'contents\nbar\n', False)
 
113
        self.assertEqual(2, builder.commit('Joe Foo <joe@foo.com>',
 
114
                                           u'committing f\xb5/bar',
 
115
                                           timestamp=1194586400,
 
116
                                           timezone='+0100'))
 
117
        self.assertEqualDiff('blob\nmark :1\ndata 13\ncontents\nbar\n\n'
 
118
                             'commit refs/heads/master\n'
 
119
                             'mark :2\n'
 
120
                             'committer Joe Foo <joe@foo.com> 1194586400 +0100\n'
 
121
                             'data 18\n'
 
122
                             'committing f\xc2\xb5/bar'
 
123
                             '\n'
 
124
                             'M 100644 :1 f\xc2\xb5/bar\n'
 
125
                             '\n',
128
126
                             stream.getvalue())
129
127
 
130
128
    def test_commit_base(self):
131
 
        stream = BytesIO()
 
129
        stream = StringIO()
132
130
        builder = tests.GitBranchBuilder(stream)
133
131
 
134
 
        builder.set_file(u'foo', b'contents\nfoo\n', False)
135
 
        r1 = builder.commit(b'Joe Foo <joe@foo.com>', u'first',
 
132
        builder.set_file(u'foo', 'contents\nfoo\n', False)
 
133
        r1 = builder.commit('Joe Foo <joe@foo.com>', u'first',
136
134
                            timestamp=1194586400)
137
 
        r2 = builder.commit(b'Joe Foo <joe@foo.com>', u'second',
 
135
        r2 = builder.commit('Joe Foo <joe@foo.com>', u'second',
138
136
                            timestamp=1194586405)
139
 
        r3 = builder.commit(b'Joe Foo <joe@foo.com>', u'third',
 
137
        r3 = builder.commit('Joe Foo <joe@foo.com>', u'third',
140
138
                            timestamp=1194586410,
141
139
                            base=r1)
142
140
 
143
 
        self.assertEqualDiff(b'blob\nmark :1\ndata 13\ncontents\nfoo\n\n'
144
 
                             b'commit refs/heads/master\n'
145
 
                             b'mark :2\n'
146
 
                             b'committer Joe Foo <joe@foo.com> 1194586400 +0000\n'
147
 
                             b'data 5\n'
148
 
                             b'first'
149
 
                             b'\n'
150
 
                             b'M 100644 :1 foo\n'
151
 
                             b'\n'
152
 
                             b'commit refs/heads/master\n'
153
 
                             b'mark :3\n'
154
 
                             b'committer Joe Foo <joe@foo.com> 1194586405 +0000\n'
155
 
                             b'data 6\n'
156
 
                             b'second'
157
 
                             b'\n'
158
 
                             b'\n'
159
 
                             b'commit refs/heads/master\n'
160
 
                             b'mark :4\n'
161
 
                             b'committer Joe Foo <joe@foo.com> 1194586410 +0000\n'
162
 
                             b'data 5\n'
163
 
                             b'third'
164
 
                             b'\n'
165
 
                             b'from :2\n'
166
 
                             b'\n', stream.getvalue())
 
141
        self.assertEqualDiff('blob\nmark :1\ndata 13\ncontents\nfoo\n\n'
 
142
                             'commit refs/heads/master\n'
 
143
                             'mark :2\n'
 
144
                             'committer Joe Foo <joe@foo.com> 1194586400 +0000\n'
 
145
                             'data 5\n'
 
146
                             'first'
 
147
                             '\n'
 
148
                             'M 100644 :1 foo\n'
 
149
                             '\n'
 
150
                             'commit refs/heads/master\n'
 
151
                             'mark :3\n'
 
152
                             'committer Joe Foo <joe@foo.com> 1194586405 +0000\n'
 
153
                             'data 6\n'
 
154
                             'second'
 
155
                             '\n'
 
156
                             '\n'
 
157
                             'commit refs/heads/master\n'
 
158
                             'mark :4\n'
 
159
                             'committer Joe Foo <joe@foo.com> 1194586410 +0000\n'
 
160
                             'data 5\n'
 
161
                             'third'
 
162
                             '\n'
 
163
                             'from :2\n'
 
164
                             '\n', stream.getvalue())
167
165
 
168
166
    def test_commit_merge(self):
169
 
        stream = BytesIO()
 
167
        stream = StringIO()
170
168
        builder = tests.GitBranchBuilder(stream)
171
169
 
172
 
        builder.set_file(u'foo', b'contents\nfoo\n', False)
173
 
        r1 = builder.commit(b'Joe Foo <joe@foo.com>', u'first',
 
170
        builder.set_file(u'foo', 'contents\nfoo\n', False)
 
171
        r1 = builder.commit('Joe Foo <joe@foo.com>', u'first',
174
172
                            timestamp=1194586400)
175
 
        r2 = builder.commit(b'Joe Foo <joe@foo.com>', u'second',
 
173
        r2 = builder.commit('Joe Foo <joe@foo.com>', u'second',
176
174
                            timestamp=1194586405)
177
 
        r3 = builder.commit(b'Joe Foo <joe@foo.com>', u'third',
 
175
        r3 = builder.commit('Joe Foo <joe@foo.com>', u'third',
178
176
                            timestamp=1194586410,
179
177
                            base=r1)
180
 
        r4 = builder.commit(b'Joe Foo <joe@foo.com>', u'Merge',
 
178
        r4 = builder.commit('Joe Foo <joe@foo.com>', u'Merge',
181
179
                            timestamp=1194586415,
182
180
                            merge=[r2])
183
181
 
184
 
        self.assertEqualDiff(b'blob\nmark :1\ndata 13\ncontents\nfoo\n\n'
185
 
                             b'commit refs/heads/master\n'
186
 
                             b'mark :2\n'
187
 
                             b'committer Joe Foo <joe@foo.com> 1194586400 +0000\n'
188
 
                             b'data 5\n'
189
 
                             b'first'
190
 
                             b'\n'
191
 
                             b'M 100644 :1 foo\n'
192
 
                             b'\n'
193
 
                             b'commit refs/heads/master\n'
194
 
                             b'mark :3\n'
195
 
                             b'committer Joe Foo <joe@foo.com> 1194586405 +0000\n'
196
 
                             b'data 6\n'
197
 
                             b'second'
198
 
                             b'\n'
199
 
                             b'\n'
200
 
                             b'commit refs/heads/master\n'
201
 
                             b'mark :4\n'
202
 
                             b'committer Joe Foo <joe@foo.com> 1194586410 +0000\n'
203
 
                             b'data 5\n'
204
 
                             b'third'
205
 
                             b'\n'
206
 
                             b'from :2\n'
207
 
                             b'\n'
208
 
                             b'commit refs/heads/master\n'
209
 
                             b'mark :5\n'
210
 
                             b'committer Joe Foo <joe@foo.com> 1194586415 +0000\n'
211
 
                             b'data 5\n'
212
 
                             b'Merge'
213
 
                             b'\n'
214
 
                             b'merge :3\n'
215
 
                             b'\n', stream.getvalue())
 
182
        self.assertEqualDiff('blob\nmark :1\ndata 13\ncontents\nfoo\n\n'
 
183
                             'commit refs/heads/master\n'
 
184
                             'mark :2\n'
 
185
                             'committer Joe Foo <joe@foo.com> 1194586400 +0000\n'
 
186
                             'data 5\n'
 
187
                             'first'
 
188
                             '\n'
 
189
                             'M 100644 :1 foo\n'
 
190
                             '\n'
 
191
                             'commit refs/heads/master\n'
 
192
                             'mark :3\n'
 
193
                             'committer Joe Foo <joe@foo.com> 1194586405 +0000\n'
 
194
                             'data 6\n'
 
195
                             'second'
 
196
                             '\n'
 
197
                             '\n'
 
198
                             'commit refs/heads/master\n'
 
199
                             'mark :4\n'
 
200
                             'committer Joe Foo <joe@foo.com> 1194586410 +0000\n'
 
201
                             'data 5\n'
 
202
                             'third'
 
203
                             '\n'
 
204
                             'from :2\n'
 
205
                             '\n'
 
206
                             'commit refs/heads/master\n'
 
207
                             'mark :5\n'
 
208
                             'committer Joe Foo <joe@foo.com> 1194586415 +0000\n'
 
209
                             'data 5\n'
 
210
                             'Merge'
 
211
                             '\n'
 
212
                             'merge :3\n'
 
213
                             '\n', stream.getvalue())
216
214
 
217
215
    def test_auto_timestamp(self):
218
 
        stream = BytesIO()
 
216
        stream = StringIO()
219
217
        builder = tests.GitBranchBuilder(stream)
220
 
        builder.commit(b'Joe Foo <joe@foo.com>', u'message')
 
218
        builder.commit('Joe Foo <joe@foo.com>', u'message')
221
219
        self.assertContainsRe(stream.getvalue(),
222
 
                              br'committer Joe Foo <joe@foo\.com> \d+ \+0000')
 
220
                              r'committer Joe Foo <joe@foo\.com> \d+ \+0000')
223
221
 
224
222
    def test_reset(self):
225
 
        stream = BytesIO()
 
223
        stream = StringIO()
226
224
        builder = tests.GitBranchBuilder(stream)
227
225
        builder.reset()
228
 
        self.assertEqualDiff(b'reset refs/heads/master\n\n', stream.getvalue())
 
226
        self.assertEqualDiff('reset refs/heads/master\n\n', stream.getvalue())
229
227
 
230
228
    def test_reset_named_ref(self):
231
 
        stream = BytesIO()
 
229
        stream = StringIO()
232
230
        builder = tests.GitBranchBuilder(stream)
233
 
        builder.reset(b'refs/heads/branch')
234
 
        self.assertEqualDiff(b'reset refs/heads/branch\n\n', stream.getvalue())
 
231
        builder.reset('refs/heads/branch')
 
232
        self.assertEqualDiff('reset refs/heads/branch\n\n', stream.getvalue())
235
233
 
236
234
    def test_reset_revision(self):
237
 
        stream = BytesIO()
 
235
        stream = StringIO()
238
236
        builder = tests.GitBranchBuilder(stream)
239
 
        builder.reset(mark=b'123')
 
237
        builder.reset(mark=123)
240
238
        self.assertEqualDiff(
241
 
            b'reset refs/heads/master\n'
242
 
            b'from :123\n'
243
 
            b'\n', stream.getvalue())
 
239
            'reset refs/heads/master\n'
 
240
            'from :123\n'
 
241
            '\n', stream.getvalue())
244
242
 
245
243
 
246
244
class TestGitBranchBuilderReal(tests.TestCaseInTempDir):
247
245
 
248
246
    def test_create_real_branch(self):
249
 
        GitRepo.init(".")
 
247
        tests.run_git('init')
250
248
 
251
249
        builder = tests.GitBranchBuilder()
252
 
        builder.set_file(u'foo', b'contents\nfoo\n', False)
253
 
        r1 = builder.commit(b'Joe Foo <joe@foo.com>', u'first',
 
250
        builder.set_file(u'foo', 'contents\nfoo\n', False)
 
251
        r1 = builder.commit('Joe Foo <joe@foo.com>', u'first',
254
252
                            timestamp=1194586400)
255
253
        mapping = builder.finish()
256
 
        self.assertEqual({b'1': b'44411e8e9202177dd19b6599d7a7991059fa3cb4',
257
 
                          b'2': b'b0b62e674f67306fddcf72fa888c3b56df100d64',
258
 
                          }, mapping)
 
254
        self.assertEqual({1:'44411e8e9202177dd19b6599d7a7991059fa3cb4',
 
255
                          2: 'b0b62e674f67306fddcf72fa888c3b56df100d64',
 
256
                         }, mapping)