← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/testfetch.py

  • Committer: Robert Collins
  • Date: 2005-10-11 03:19:29 UTC
  • Revision ID: robertc@robertcollins.net-20051011031929-2d523107133c43be
further tuning of pull, do not do a local merge or fetch at all, if the remote branch is no newer than we are

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/testfetch.py
18
18
import sys
19
19
 
20
20
import bzrlib.errors
21
 
from bzrlib.tests.test_revision import make_branches
 
21
from bzrlib.selftest.testrevision import make_branches
22
22
from bzrlib.trace import mutter
23
23
from bzrlib.branch import Branch
24
24
from bzrlib.fetch import greedy_fetch
25
 
from bzrlib.merge import merge
26
 
from bzrlib.clone import copy_branch
27
25
 
28
 
from bzrlib.tests import TestCaseInTempDir
29
 
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
 
26
from bzrlib.selftest import TestCaseInTempDir
 
27
from bzrlib.selftest.HTTPTestUtil import TestCaseWithWebserver
30
28
 
31
29
 
32
30
def has_revision(branch, revision_id):
33
31
    try:
34
 
        branch.get_revision_xml(revision_id)
 
32
        branch.get_revision_xml_file(revision_id)
35
33
        return True
36
34
    except bzrlib.errors.NoSuchRevision:
37
35
        return False
38
36
 
39
 
 
40
37
def fetch_steps(self, br_a, br_b, writable_a):
41
38
    """A foreign test method for testing fetch locally and remotely."""
42
39
    def new_branch(name):
43
40
        os.mkdir(name)
44
41
        return Branch.initialize(name)
45
42
            
46
 
    self.assertFalse(has_revision(br_b, br_a.revision_history()[3]))
47
 
    self.assert_(has_revision(br_b, br_a.revision_history()[2]))
48
 
    self.assertEquals(len(br_b.revision_history()), 7)
49
 
    self.assertEquals(greedy_fetch(br_b, br_a, br_a.revision_history()[2])[0], 0)
 
43
    assert not has_revision(br_b, br_a.revision_history()[3])
 
44
    assert has_revision(br_b, br_a.revision_history()[2])
 
45
    assert len(br_b.revision_history()) == 7
 
46
    assert greedy_fetch(br_b, br_a, br_a.revision_history()[2])[0] == 0
50
47
 
51
48
    # greedy_fetch is not supposed to alter the revision history
52
 
    self.assertEquals(len(br_b.revision_history()), 7)
53
 
    self.assertFalse(has_revision(br_b, br_a.revision_history()[3]))
 
49
    assert len(br_b.revision_history()) == 7
 
50
    assert not has_revision(br_b, br_a.revision_history()[3])
54
51
 
55
 
    self.assertEquals(len(br_b.revision_history()), 7)
56
 
    self.assertEquals(greedy_fetch(br_b, br_a, br_a.revision_history()[3])[0], 1)
57
 
    self.assert_(has_revision(br_b, br_a.revision_history()[3]))
58
 
    self.assertFalse(has_revision(br_a, br_b.revision_history()[6]))
59
 
    self.assert_(has_revision(br_a, br_b.revision_history()[5]))
 
52
    assert len(br_b.revision_history()) == 7
 
53
    assert greedy_fetch(br_b, br_a, br_a.revision_history()[3])[0] == 1
 
54
    assert has_revision(br_b, br_a.revision_history()[3])
 
55
    assert not has_revision(br_a, br_b.revision_history()[6])
 
56
    assert has_revision(br_a, br_b.revision_history()[5])
60
57
 
61
58
    # When a non-branch ancestor is missing, it should be unlisted...
62
59
    # as its not reference from the inventory weave.
66
63
    self.assertEqual(failures, [])
67
64
 
68
65
    self.assertEqual(greedy_fetch(writable_a, br_b)[0], 1)
69
 
    self.assert_(has_revision(br_a, br_b.revision_history()[3]))
70
 
    self.assert_(has_revision(br_a, br_b.revision_history()[4]))
 
66
    assert has_revision(br_a, br_b.revision_history()[3])
 
67
    assert has_revision(br_a, br_b.revision_history()[4])
71
68
        
72
69
    br_b2 = new_branch('br_b2')
73
 
    self.assertEquals(greedy_fetch(br_b2, br_b)[0], 7)
74
 
    self.assert_(has_revision(br_b2, br_b.revision_history()[4]))
75
 
    self.assert_(has_revision(br_b2, br_a.revision_history()[2]))
76
 
    self.assertFalse(has_revision(br_b2, br_a.revision_history()[3]))
 
70
    assert greedy_fetch(br_b2, br_b)[0] == 7
 
71
    assert has_revision(br_b2, br_b.revision_history()[4])
 
72
    assert has_revision(br_b2, br_a.revision_history()[2])
 
73
    assert not has_revision(br_b2, br_a.revision_history()[3])
77
74
 
78
75
    br_a2 = new_branch('br_a2')
79
 
    self.assertEquals(greedy_fetch(br_a2, br_a)[0], 9)
80
 
    self.assert_(has_revision(br_a2, br_b.revision_history()[4]))
81
 
    self.assert_(has_revision(br_a2, br_a.revision_history()[3]))
82
 
    self.assert_(has_revision(br_a2, br_a.revision_history()[2]))
 
76
    assert greedy_fetch(br_a2, br_a)[0] == 9
 
77
    assert has_revision(br_a2, br_b.revision_history()[4])
 
78
    assert has_revision(br_a2, br_a.revision_history()[3])
 
79
    assert has_revision(br_a2, br_a.revision_history()[2])
83
80
 
84
81
    br_a3 = new_branch('br_a3')
85
 
    self.assertEquals(greedy_fetch(br_a3, br_a2)[0], 0)
 
82
    assert greedy_fetch(br_a3, br_a2)[0] == 0
86
83
    for revno in range(4):
87
 
        self.assertFalse(has_revision(br_a3, br_a.revision_history()[revno]))
 
84
        assert not has_revision(br_a3, br_a.revision_history()[revno])
88
85
    self.assertEqual(greedy_fetch(br_a3, br_a2, br_a.revision_history()[2])[0], 3)
89
86
    fetched = greedy_fetch(br_a3, br_a2, br_a.revision_history()[3])[0]
90
 
    self.assertEquals(fetched, 3, "fetched %d instead of 3" % fetched)
 
87
    assert fetched == 3, "fetched %d instead of 3" % fetched
91
88
    # InstallFailed should be raised if the branch is missing the revision
92
89
    # that was requested.
93
90
    self.assertRaises(bzrlib.errors.InstallFailed, greedy_fetch, br_a3,
105
102
 
106
103
    def test_fetch(self):
107
104
        #highest indices a: 5, b: 7
108
 
        br_a, br_b = make_branches(self)
 
105
        br_a, br_b = make_branches()
109
106
        fetch_steps(self, br_a, br_b, br_a)
110
107
 
111
108
 
112
 
class TestMergeFetch(TestCaseInTempDir):
113
 
 
114
 
    def test_merge_fetches_unrelated(self):
115
 
        """Merge brings across history from unrelated source"""
116
 
        os.mkdir('br1')
117
 
        br1 = Branch.initialize('br1')
118
 
        br1.working_tree().commit(message='rev 1-1', rev_id='1-1')
119
 
        br1.working_tree().commit(message='rev 1-2', rev_id='1-2')
120
 
        os.mkdir('br2')
121
 
        br2 = Branch.initialize('br2')
122
 
        br2.working_tree().commit(message='rev 2-1', rev_id='2-1')
123
 
        merge(other_revision=['br1', -1], base_revision=['br1', 0],
124
 
              this_dir='br2')
125
 
        self._check_revs_present(br2)
126
 
 
127
 
    def test_merge_fetches(self):
128
 
        """Merge brings across history from source"""
129
 
        os.mkdir('br1')
130
 
        br1 = Branch.initialize('br1')
131
 
        br1.working_tree().commit(message='rev 1-1', rev_id='1-1')
132
 
        copy_branch(br1, 'br2')
133
 
        br2 = Branch.open('br2')
134
 
        br1.working_tree().commit(message='rev 1-2', rev_id='1-2')
135
 
        br2.working_tree().commit(message='rev 2-1', rev_id='2-1')
136
 
        merge(other_revision=['br1', -1], base_revision=[None, None], 
137
 
              this_dir='br2')
138
 
        self._check_revs_present(br2)
139
 
 
140
 
    def _check_revs_present(self, br2):
141
 
        for rev_id in '1-1', '1-2', '2-1':
142
 
            self.assertTrue(br2.has_revision(rev_id))
143
 
            rev = br2.get_revision(rev_id)
144
 
            self.assertEqual(rev.revision_id, rev_id)
145
 
            self.assertTrue(br2.get_inventory(rev_id))
146
 
 
147
 
 
148
 
 
149
 
class TestMergeFileHistory(TestCaseInTempDir):
 
109
class TestHttpFetch(TestCaseWithWebserver):
 
110
 
150
111
    def setUp(self):
151
 
        TestCaseInTempDir.setUp(self)
152
 
        os.mkdir('br1')
153
 
        br1 = Branch.initialize('br1')
154
 
        self.build_tree_contents([('br1/file', 'original contents\n')])
155
 
        br1.working_tree().add(['file'], ['this-file-id'])
156
 
        br1.working_tree().commit(message='rev 1-1', rev_id='1-1')
157
 
        copy_branch(br1, 'br2')
158
 
        br2 = Branch.open('br2')
159
 
        self.build_tree_contents([('br1/file', 'original from 1\n')])
160
 
        br1.working_tree().commit(message='rev 1-2', rev_id='1-2')
161
 
        self.build_tree_contents([('br1/file', 'agreement\n')])
162
 
        br1.working_tree().commit(message='rev 1-3', rev_id='1-3')
163
 
        self.build_tree_contents([('br2/file', 'contents in 2\n')])
164
 
        br2.working_tree().commit(message='rev 2-1', rev_id='2-1')
165
 
        self.build_tree_contents([('br2/file', 'agreement\n')])
166
 
        br2.working_tree().commit(message='rev 2-2', rev_id='2-2')
167
 
 
168
 
    def test_merge_fetches_file_history(self):
169
 
        """Merge brings across file histories"""
170
 
        br2 = Branch.open('br2')
171
 
        merge(other_revision=['br1', -1], base_revision=[None, None], 
172
 
              this_dir='br2')
173
 
        for rev_id, text in [('1-2', 'original from 1\n'),
174
 
                             ('1-3', 'agreement\n'),
175
 
                             ('2-1', 'contents in 2\n'),
176
 
                             ('2-2', 'agreement\n')]:
177
 
            self.assertEqualDiff(br2.revision_tree(rev_id).get_file_text('this-file-id'),
178
 
                                 text)
179
 
 
180
 
 
181
 
 
182
 
 
183
 
class TestHttpFetch(TestCaseWithWebserver):
 
112
        super(TestHttpFetch, self).setUp()
 
113
        self.weblogs = []
184
114
 
185
115
    def test_fetch(self):
186
116
        #highest indices a: 5, b: 7
187
 
        br_a, br_b = make_branches(self)
 
117
        br_a, br_b = make_branches()
188
118
        br_rem_a = Branch.open(self.get_remote_url(br_a._transport.base))
189
119
        fetch_steps(self, br_rem_a, br_b, br_a)
190
120
 
 
121
    def log(self, *args):
 
122
        """Capture web server log messages for introspection."""
 
123
        super(TestHttpFetch, self).log(*args)
 
124
        if args[0].startswith("webserver"):
 
125
            self.weblogs.append(args[0])
 
126
 
191
127
    def test_weaves_are_retrieved_once(self):
192
128
        self.build_tree(("source/", "source/file", "target/"))
193
129
        branch = Branch.initialize("source")
194
 
        branch.working_tree().add(["file"], ["id"])
195
 
        branch.working_tree().commit("added file")
 
130
        branch.add(["file"], ["id"])
 
131
        branch.commit("added file")
196
132
        print >>open("source/file", 'w'), "blah"
197
 
        branch.working_tree().commit("changed file")
 
133
        branch.commit("changed file")
198
134
        target = Branch.initialize("target/")
199
135
        source = Branch.open(self.get_remote_url("source/"))
200
136
        self.assertEqual(greedy_fetch(target, source), (2, []))
203
139
        # path.
204
140
        weave_suffix = 'weaves/ce/id.weave HTTP/1.1" 200 -'
205
141
        self.assertEqual(1,
206
 
            len([log for log in self.server.logs if log.endswith(weave_suffix)]))
 
142
            len([log for log in self.weblogs if log.endswith(weave_suffix)]))
207
143
        inventory_weave_suffix = 'inventory.weave HTTP/1.1" 200 -'
208
144
        self.assertEqual(1,
209
 
            len([log for log in self.server.logs if log.endswith(
 
145
            len([log for log in self.weblogs if log.endswith(
210
146
                inventory_weave_suffix)]))
211
147
        # this r-h check test will prevent regressions, but it currently already 
212
148
        # passes, before the patch to cache-rh is applied :[
213
149
        revision_history_suffix = 'revision-history HTTP/1.1" 200 -'
214
150
        self.assertEqual(1,
215
 
            len([log for log in self.server.logs if log.endswith(
 
151
            len([log for log in self.weblogs if log.endswith(
216
152
                revision_history_suffix)]))
217
 
        # FIXME naughty poking in there.
218
 
        self.server.logs = []
 
153
        for log in self.weblogs:
 
154
            print log
 
155
        self.weblogs = []
219
156
        # check there is nothing more to fetch
220
157
        source = Branch.open(self.get_remote_url("source/"))
221
158
        self.assertEqual(greedy_fetch(target, source), (0, []))
222
 
        self.failUnless(self.server.logs[0].endswith('branch-format HTTP/1.1" 200 -'))
223
 
        self.failUnless(self.server.logs[1].endswith('revision-history HTTP/1.1" 200 -'))
224
 
        self.assertEqual(2, len(self.server.logs))
 
159
        self.failUnless(self.weblogs[0].endswith('branch-format HTTP/1.1" 200 -'))
 
160
        self.failUnless(self.weblogs[1].endswith('revision-history HTTP/1.1" 200 -'))
 
161
        self.assertEqual(2, len(self.weblogs))