← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_fetch.py

first cut at merge from integration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_fetch.py
18
18
import sys
19
19
 
20
20
from bzrlib.branch import Branch
21
 
from bzrlib.bzrdir import BzrDir
22
21
from bzrlib.builtins import merge
23
22
import bzrlib.errors
 
23
from bzrlib.fetch import greedy_fetch
24
24
from bzrlib.tests import TestCaseWithTransport
25
25
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
26
26
from bzrlib.tests.test_revision import make_branches
29
29
 
30
30
 
31
31
def has_revision(branch, revision_id):
32
 
    return branch.repository.has_revision(revision_id)
 
32
    try:
 
33
        branch.repository.get_revision_xml_file(revision_id)
 
34
        return True
 
35
    except bzrlib.errors.NoSuchRevision:
 
36
        return False
 
37
 
33
38
 
34
39
def fetch_steps(self, br_a, br_b, writable_a):
35
40
    """A foreign test method for testing fetch locally and remotely."""
36
 
     
37
 
    # TODO RBC 20060201 make this a repository test.
38
 
    repo_b = br_b.repository
39
 
    self.assertFalse(repo_b.has_revision(br_a.revision_history()[3]))
40
 
    self.assertTrue(repo_b.has_revision(br_a.revision_history()[2]))
41
 
    self.assertEquals(len(br_b.revision_history()), 7)
42
 
    self.assertEquals(br_b.fetch(br_a, br_a.revision_history()[2])[0], 0)
43
 
    # branch.fetch is not supposed to alter the revision history
44
 
    self.assertEquals(len(br_b.revision_history()), 7)
45
 
    self.assertFalse(repo_b.has_revision(br_a.revision_history()[3]))
46
 
 
47
 
    # fetching the next revision up in sample data copies one revision
48
 
    self.assertEquals(br_b.fetch(br_a, br_a.revision_history()[3])[0], 1)
49
 
    self.assertTrue(repo_b.has_revision(br_a.revision_history()[3]))
 
41
    def new_branch(name):
 
42
        os.mkdir(name)
 
43
        return WorkingTree.create_standalone(name).branch
 
44
            
 
45
    self.assertFalse(has_revision(br_b, br_a.revision_history()[3]))
 
46
    self.assert_(has_revision(br_b, br_a.revision_history()[2]))
 
47
    self.assertEquals(len(br_b.revision_history()), 7)
 
48
    self.assertEquals(greedy_fetch(br_b, br_a, br_a.revision_history()[2])[0], 0)
 
49
 
 
50
    # greedy_fetch is not supposed to alter the revision history
 
51
    self.assertEquals(len(br_b.revision_history()), 7)
 
52
    self.assertFalse(has_revision(br_b, br_a.revision_history()[3]))
 
53
 
 
54
    self.assertEquals(len(br_b.revision_history()), 7)
 
55
    self.assertEquals(greedy_fetch(br_b, br_a, br_a.revision_history()[3])[0], 1)
 
56
    self.assert_(has_revision(br_b, br_a.revision_history()[3]))
50
57
    self.assertFalse(has_revision(br_a, br_b.revision_history()[6]))
51
 
    self.assertTrue(br_a.repository.has_revision(br_b.revision_history()[5]))
 
58
    self.assert_(has_revision(br_a, br_b.revision_history()[5]))
52
59
 
53
60
    # When a non-branch ancestor is missing, it should be unlisted...
54
61
    # as its not reference from the inventory weave.
55
 
    br_b4 = self.make_branch('br_4')
56
 
    count, failures = br_b4.fetch(br_b)
 
62
    br_b4 = new_branch('br_4')
 
63
    count, failures = greedy_fetch(br_b4, br_b)
57
64
    self.assertEqual(count, 7)
58
65
    self.assertEqual(failures, [])
59
66
 
60
 
    self.assertEqual(writable_a.fetch(br_b)[0], 1)
61
 
    self.assertTrue(has_revision(br_a, br_b.revision_history()[3]))
62
 
    self.assertTrue(has_revision(br_a, br_b.revision_history()[4]))
 
67
    self.assertEqual(greedy_fetch(writable_a, br_b)[0], 1)
 
68
    self.assert_(has_revision(br_a, br_b.revision_history()[3]))
 
69
    self.assert_(has_revision(br_a, br_b.revision_history()[4]))
63
70
        
64
 
    br_b2 = self.make_branch('br_b2')
65
 
    self.assertEquals(br_b2.fetch(br_b)[0], 7)
66
 
    self.assertTrue(has_revision(br_b2, br_b.revision_history()[4]))
67
 
    self.assertTrue(has_revision(br_b2, br_a.revision_history()[2]))
 
71
    br_b2 = new_branch('br_b2')
 
72
    self.assertEquals(greedy_fetch(br_b2, br_b)[0], 7)
 
73
    self.assert_(has_revision(br_b2, br_b.revision_history()[4]))
 
74
    self.assert_(has_revision(br_b2, br_a.revision_history()[2]))
68
75
    self.assertFalse(has_revision(br_b2, br_a.revision_history()[3]))
69
76
 
70
 
    br_a2 = self.make_branch('br_a2')
71
 
    self.assertEquals(br_a2.fetch(br_a)[0], 9)
72
 
    self.assertTrue(has_revision(br_a2, br_b.revision_history()[4]))
73
 
    self.assertTrue(has_revision(br_a2, br_a.revision_history()[3]))
74
 
    self.assertTrue(has_revision(br_a2, br_a.revision_history()[2]))
 
77
    br_a2 = new_branch('br_a2')
 
78
    self.assertEquals(greedy_fetch(br_a2, br_a)[0], 9)
 
79
    self.assert_(has_revision(br_a2, br_b.revision_history()[4]))
 
80
    self.assert_(has_revision(br_a2, br_a.revision_history()[3]))
 
81
    self.assert_(has_revision(br_a2, br_a.revision_history()[2]))
75
82
 
76
 
    br_a3 = self.make_branch('br_a3')
77
 
    # pulling a branch with no revisions grabs nothing, regardless of 
78
 
    # whats in the inventory.
79
 
    self.assertEquals(br_a3.fetch(br_a2)[0], 0)
 
83
    br_a3 = new_branch('br_a3')
 
84
    self.assertEquals(greedy_fetch(br_a3, br_a2)[0], 0)
80
85
    for revno in range(4):
81
 
        self.assertFalse(
82
 
            br_a3.repository.has_revision(br_a.revision_history()[revno]))
83
 
    self.assertEqual(br_a3.fetch(br_a2, br_a.revision_history()[2])[0], 3)
84
 
    # pull the 3 revisions introduced by a@u-0-3
85
 
    fetched = br_a3.fetch(br_a2, br_a.revision_history()[3])[0]
86
 
    self.assertEquals(fetched, 3, "fetched %d instead of 3" % fetched)
 
86
        self.assertFalse(has_revision(br_a3, br_a.revision_history()[revno]))
 
87
    self.assertEqual(greedy_fetch(br_a3, br_a2, br_a.revision_history()[2])[0], 3)
 
88
    fetched = greedy_fetch(br_a3, br_a2, br_a.revision_history()[3])[0]
 
89
    self.assertEquals(fetched, 6, "fetched %d instead of 6" % fetched)
87
90
    # InstallFailed should be raised if the branch is missing the revision
88
91
    # that was requested.
89
 
    self.assertRaises(bzrlib.errors.InstallFailed, br_a3.fetch, br_a2, 'pizza')
 
92
    self.assertRaises(bzrlib.errors.InstallFailed, greedy_fetch, br_a3,
 
93
                      br_a2, 'pizza')
90
94
    # InstallFailed should be raised if the branch is missing a revision
91
95
    # from its own revision history
92
96
    br_a2.append_revision('a-b-c')
93
 
    self.assertRaises(bzrlib.errors.InstallFailed, br_a3.fetch, br_a2)
 
97
    self.assertRaises(bzrlib.errors.InstallFailed, greedy_fetch, br_a3,
 
98
                      br_a2)
94
99
 
95
 
    # TODO: jam 20051218 Branch should no longer allow append_revision for revisions
96
 
    #       which don't exist. So this test needs to be rewritten
97
 
    #       RBC 20060403 the way to do this is to uncommit the revision from the
98
 
    #           repository after the commit
99
100
 
100
101
    #TODO: test that fetch correctly does reweaving when needed. RBC 20051008
101
 
    # Note that this means - updating the weave when ghosts are filled in to 
102
 
    # add the right parents.
103
 
 
104
102
 
105
103
class TestFetch(TestCaseWithTransport):
106
104
 
109
107
        br_a, br_b = make_branches(self)
110
108
        fetch_steps(self, br_a, br_b, br_a)
111
109
 
112
 
    def test_fetch_self(self):
113
 
        wt = self.make_branch_and_tree('br')
114
 
        self.assertEqual(wt.branch.fetch(wt.branch), (0, []))
115
 
 
116
110
 
117
111
class TestMergeFetch(TestCaseWithTransport):
118
112
 
134
128
        wt1 = self.make_branch_and_tree('br1')
135
129
        br1 = wt1.branch
136
130
        wt1.commit(message='rev 1-1', rev_id='1-1')
137
 
        dir_2 = br1.bzrdir.sprout('br2')
138
 
        br2 = dir_2.open_branch()
 
131
        br2 = br1.clone('br2')
139
132
        wt1.commit(message='rev 1-2', rev_id='1-2')
140
 
        dir_2.open_workingtree().commit(message='rev 2-1', rev_id='2-1')
 
133
        WorkingTree('br2', br2).commit(message='rev 2-1', rev_id='2-1')
141
134
        merge(other_revision=['br1', -1], base_revision=[None, None], 
142
135
              this_dir='br2')
143
136
        self._check_revs_present(br2)
159
152
        self.build_tree_contents([('br1/file', 'original contents\n')])
160
153
        wt1.add('file', 'this-file-id')
161
154
        wt1.commit(message='rev 1-1', rev_id='1-1')
162
 
        dir_2 = br1.bzrdir.sprout('br2')
163
 
        br2 = dir_2.open_branch()
164
 
        wt2 = dir_2.open_workingtree()
 
155
        br2 = br1.clone('br2')
 
156
        wt2 = WorkingTree('br2', br2)
165
157
        self.build_tree_contents([('br1/file', 'original from 1\n')])
166
158
        wt1.commit(message='rev 1-2', rev_id='1-2')
167
159
        self.build_tree_contents([('br1/file', 'agreement\n')])
192
184
 
193
185
    def test_fetch(self):
194
186
        #highest indices a: 5, b: 7
 
187
        print "TestHttpFetch.test_fetch disabled during transition."
 
188
        return
195
189
        br_a, br_b = make_branches(self)
196
 
        br_rem_a = Branch.open(self.get_readonly_url('branch1'))
 
190
        br_rem_a = Branch.open(self.get_remote_url(br_a.base))
197
191
        fetch_steps(self, br_rem_a, br_b, br_a)
198
192
 
199
 
    def _count_log_matches(self, target, logs):
200
 
        """Count the number of times the target file pattern was fetched in an http log"""
201
 
        log_pattern = '%s HTTP/1.1" 200 - "-" "bzr/%s' % \
202
 
            (target, bzrlib.__version__)
203
 
        c = 0
204
 
        for line in logs:
205
 
            # TODO: perhaps use a regexp instead so we can match more
206
 
            # precisely?
207
 
            if line.find(log_pattern) > -1:
208
 
                c += 1
209
 
        return c
210
 
 
211
193
    def test_weaves_are_retrieved_once(self):
212
194
        self.build_tree(("source/", "source/file", "target/"))
213
 
        wt = self.make_branch_and_tree('source')
 
195
        wt = WorkingTree.create_standalone('source')
214
196
        branch = wt.branch
215
197
        wt.add(["file"], ["id"])
216
198
        wt.commit("added file")
217
199
        print >>open("source/file", 'w'), "blah"
218
200
        wt.commit("changed file")
219
 
        target = BzrDir.create_branch_and_repo("target/")
220
 
        source = Branch.open(self.get_readonly_url("source/"))
221
 
        self.assertEqual(target.fetch(source), (2, []))
222
 
        log_pattern = '%%s HTTP/1.1" 200 - "-" "bzr/%s' % bzrlib.__version__
 
201
        target = Branch.create("target/")
 
202
        source = Branch.open(self.get_remote_url("source/"))
 
203
        self.assertEqual(greedy_fetch(target, source), (2, []))
223
204
        # this is the path to the literal file. As format changes 
224
205
        # occur it needs to be updated. FIXME: ask the store for the
225
206
        # path.
226
 
        self.log("web server logs are:")
227
 
        http_logs = self.get_readonly_server().logs
228
 
        self.log('\n'.join(http_logs))
229
 
        # unfortunately this log entry is branch format specific. We could 
230
 
        # factor out the 'what files does this format use' to a method on the 
231
 
        # repository, which would let us to this generically. RBC 20060419
232
 
        self.assertEqual(1, self._count_log_matches('/ce/id.kndx', http_logs))
233
 
        self.assertEqual(1, self._count_log_matches('/ce/id.knit', http_logs))
234
 
        self.assertEqual(1, self._count_log_matches('inventory.kndx', http_logs))
235
 
        self.assertEqual(1, self._count_log_matches('inventory.knit', http_logs))
 
207
        weave_suffix = 'weaves/ce/id.weave HTTP/1.1" 200 -'
 
208
        self.assertEqual(1,
 
209
            len([log for log in self.server.logs if log.endswith(weave_suffix)]))
 
210
        inventory_weave_suffix = 'inventory.weave HTTP/1.1" 200 -'
 
211
        self.assertEqual(1,
 
212
            len([log for log in self.server.logs if log.endswith(
 
213
                inventory_weave_suffix)]))
236
214
        # this r-h check test will prevent regressions, but it currently already 
237
215
        # passes, before the patch to cache-rh is applied :[
238
 
        self.assertEqual(1, self._count_log_matches('revision-history', http_logs))
 
216
        revision_history_suffix = 'revision-history HTTP/1.1" 200 -'
 
217
        self.assertEqual(1,
 
218
            len([log for log in self.server.logs if log.endswith(
 
219
                revision_history_suffix)]))
239
220
        # FIXME naughty poking in there.
240
 
        self.get_readonly_server().logs = []
 
221
        self.server.logs = []
241
222
        # check there is nothing more to fetch
242
 
        source = Branch.open(self.get_readonly_url("source/"))
243
 
        self.assertEqual(target.fetch(source), (0, []))
244
 
        # should make just two requests
245
 
        http_logs = self.get_readonly_server().logs
246
 
        self.log("web server logs are:")
247
 
        self.log('\n'.join(http_logs))
248
 
        self.assertEqual(1, self._count_log_matches('branch-format', http_logs))
249
 
        self.assertEqual(1, self._count_log_matches('branch/format', http_logs))
250
 
        self.assertEqual(1, self._count_log_matches('repository/format', http_logs))
251
 
        self.assertEqual(1, self._count_log_matches('revision-history', http_logs))
252
 
        self.assertEqual(4, len(http_logs))
 
223
        source = Branch.open(self.get_remote_url("source/"))
 
224
        self.assertEqual(greedy_fetch(target, source), (0, []))
 
225
        self.failUnless(self.server.logs[0].endswith('branch-format HTTP/1.1" 200 -'))
 
226
        self.failUnless(self.server.logs[1].endswith('revision-history HTTP/1.1" 200 -'))
 
227
        self.assertEqual(2, len(self.server.logs))