← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_url_policy_open.py

  • Committer: Ross Lagerwall
  • Date: 2012-08-07 06:32:51 UTC
  • mto: (6437.63.5 2.5)
  • mto: This revision was merged to the branch mainline in revision 6558.
  • Revision ID: rosslagerwall@gmail.com-20120807063251-x9p03ghg2ws8oqjc
Add bzrlib/locale to .bzrignore

bzrlib/locale is generated with ./setup.py build_mo which is in turn called
by ./setup.py build

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_url_policy_open.py
1
 
# Copyright (C) 2011, 2012, 2016 Canonical Ltd
 
1
# Copyright (C) 2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
22
22
    BranchReferenceFormat,
23
23
    )
24
24
from bzrlib.bzrdir import (
 
25
    BzrDir,
25
26
    BzrProber,
26
27
    )
27
 
from bzrlib.controldir import (
28
 
    ControlDir,
29
 
    ControlDirFormat,
30
 
    )
 
28
from bzrlib.controldir import ControlDirFormat
31
29
from bzrlib.errors import NotBranchError
32
30
from bzrlib.url_policy_open import (
33
31
    BadUrl,
89
87
        # When branch references are forbidden, check_and_follow_branch_reference
90
88
        # does not raise on non-references.
91
89
        opener = self.make_branch_opener(False, ['a', None])
92
 
        self.assertEqual(
 
90
        self.assertEquals(
93
91
            'a', opener.check_and_follow_branch_reference('a'))
94
 
        self.assertEqual(['a'], opener.follow_reference_calls)
 
92
        self.assertEquals(['a'], opener.follow_reference_calls)
95
93
 
96
94
    def test_branch_reference_forbidden(self):
97
95
        # check_and_follow_branch_reference raises BranchReferenceForbidden if
101
99
        self.assertRaises(
102
100
            BranchReferenceForbidden,
103
101
            opener.check_and_follow_branch_reference, 'a')
104
 
        self.assertEqual(['a'], opener.follow_reference_calls)
 
102
        self.assertEquals(['a'], opener.follow_reference_calls)
105
103
 
106
104
    def test_allowed_reference(self):
107
105
        # check_and_follow_branch_reference does not raise if following references
108
106
        # is allowed and the source URL points to a branch reference to a
109
107
        # permitted location.
110
108
        opener = self.make_branch_opener(True, ['a', 'b', None])
111
 
        self.assertEqual(
 
109
        self.assertEquals(
112
110
            'b', opener.check_and_follow_branch_reference('a'))
113
 
        self.assertEqual(['a', 'b'], opener.follow_reference_calls)
 
111
        self.assertEquals(['a', 'b'], opener.follow_reference_calls)
114
112
 
115
113
    def test_check_referenced_urls(self):
116
114
        # check_and_follow_branch_reference checks if the URL a reference points
119
117
            True, ['a', 'b', None], unsafe_urls=set('b'))
120
118
        self.assertRaises(
121
119
            BadUrl, opener.check_and_follow_branch_reference, 'a')
122
 
        self.assertEqual(['a'], opener.follow_reference_calls)
 
120
        self.assertEquals(['a'], opener.follow_reference_calls)
123
121
 
124
122
    def test_self_referencing_branch(self):
125
123
        # check_and_follow_branch_reference raises BranchReferenceLoopError if
128
126
        opener = self.make_branch_opener(True, ['a', 'a'])
129
127
        self.assertRaises(
130
128
            BranchLoopError, opener.check_and_follow_branch_reference, 'a')
131
 
        self.assertEqual(['a'], opener.follow_reference_calls)
 
129
        self.assertEquals(['a'], opener.follow_reference_calls)
132
130
 
133
131
    def test_branch_reference_loop(self):
134
132
        # check_and_follow_branch_reference raises BranchReferenceLoopError if
138
136
        opener = self.make_branch_opener(True, references)
139
137
        self.assertRaises(
140
138
            BranchLoopError, opener.check_and_follow_branch_reference, 'a')
141
 
        self.assertEqual(['a', 'b'], opener.follow_reference_calls)
 
139
        self.assertEquals(['a', 'b'], opener.follow_reference_calls)
142
140
 
143
141
 
144
142
class TrackingProber(BzrProber):
168
166
        opener = self.make_branch_opener([b.base], probers=[])
169
167
        self.assertRaises(NotBranchError, opener.open, b.base)
170
168
        opener = self.make_branch_opener([b.base], probers=[BzrProber])
171
 
        self.assertEqual(b.base, opener.open(b.base).base)
 
169
        self.assertEquals(b.base, opener.open(b.base).base)
172
170
 
173
171
    def test_default_probers(self):
174
172
        # If no probers are specified to the constructor
182
180
        TrackingProber.seen_urls = []
183
181
        opener = self.make_branch_opener(["."], probers=[TrackingProber])
184
182
        self.assertRaises(NotBranchError, opener.open, ".")
185
 
        self.assertEqual(1, len(TrackingProber.seen_urls))
 
183
        self.assertEquals(1, len(TrackingProber.seen_urls))
186
184
        TrackingProber.seen_urls = []
187
 
        # And make sure it's registered in such a way that ControlDir.open would
 
185
        # And make sure it's registered in such a way that BzrDir.open would
188
186
        # use it.
189
 
        self.assertRaises(NotBranchError, ControlDir.open, ".")
190
 
        self.assertEqual(1, len(TrackingProber.seen_urls))
 
187
        self.assertRaises(NotBranchError, BzrDir.open, ".")
 
188
        self.assertEquals(1, len(TrackingProber.seen_urls))
191
189
 
192
190
    def test_allowed_url(self):
193
191
        # the opener does not raise an exception for branches stacked on
287
285
        opener = self.make_branch_opener(
288
286
            [a.base, b.base], probers=[TrackingProber])
289
287
        opener.open(b.base)
290
 
        self.assertEqual(
 
288
        self.assertEquals(
291
289
            set(TrackingProber.seen_urls), set([b.base, a.base]))
292
290
 
293
291
    def test_custom_opener_with_branch_reference(self):
299
297
        opener = self.make_branch_opener(
300
298
            [a.base, b.base], probers=[TrackingProber])
301
299
        opener.open(b.base)
302
 
        self.assertEqual(
 
300
        self.assertEquals(
303
301
            set(TrackingProber.seen_urls), set([b.base, a.base]))
304
302
 
305
303