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

  • Committer: John Arbash Meinel
  • Date: 2008-07-09 21:42:24 UTC
  • mto: This revision was merged to the branch mainline in revision 3543.
  • Revision ID: john@arbash-meinel.com-20080709214224-r75k87r6a01pfc3h
Restore a real weave merge to 'bzr merge --weave'.

To do so efficiently, we only add the simple LCAs to the final weave
object, unless we run into complexities with the merge graph.
This gives the same effective result as adding all the texts,
with the advantage of not having to extract all of them.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_progress.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 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
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
16
 
 
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
16
 
18
17
import os
19
18
from StringIO import StringIO
20
19
 
21
20
from bzrlib import errors
22
21
from bzrlib.progress import (
23
 
    ProgressTask,
24
 
    )
25
 
from bzrlib.symbol_versioning import (
26
 
    deprecated_in,
27
 
    )
 
22
        DummyProgress,
 
23
        ChildProgress,
 
24
        TTYProgressBar,
 
25
        DotsProgressBar,
 
26
        ProgressBarStack,
 
27
        InstrumentedProgress,
 
28
        )
28
29
from bzrlib.tests import TestCase
29
 
from bzrlib.ui.text import (
30
 
    TextProgressView,
31
 
    )
 
30
 
 
31
 
 
32
class FakeStack:
 
33
 
 
34
    def __init__(self, top):
 
35
        self.__top = top
 
36
 
 
37
    def top(self):
 
38
        return self.__top
32
39
 
33
40
 
34
41
class _TTYStringIO(StringIO):
45
52
        return False
46
53
 
47
54
 
48
 
class TestTextProgressView(TestCase):
49
 
    """Tests for text display of progress bars.
50
 
 
51
 
    These try to exercise the progressview independently of its construction,
52
 
    which is arranged by the TextUIFactory.
53
 
    """
54
 
    # The ProgressTask now connects directly to the ProgressView, so we can
55
 
    # check them independently of the factory or of the determination of what
56
 
    # view to use.
57
 
    
58
 
    def make_view(self):
59
 
        out = StringIO()
60
 
        view = TextProgressView(out)
61
 
        view._width = 80
62
 
        return out, view
63
 
    
64
 
    def make_task(self, parent_task, view, msg, curr, total):
65
 
        # would normally be done by UIFactory; is done here so that we don't
66
 
        # have to have one.
67
 
        task = ProgressTask(parent_task, progress_view=view)
68
 
        task.msg = msg
69
 
        task.current_cnt = curr
70
 
        task.total_cnt = total
71
 
        return task
72
 
 
73
 
    def test_render_progress_no_bar(self):
74
 
        """The default view now has a spinner but no bar."""
75
 
        out, view = self.make_view()
76
 
        # view.enable_bar = False
77
 
        task = self.make_task(None, view, 'reticulating splines', 5, 20)
78
 
        view.show_progress(task)
79
 
        self.assertEqual(
80
 
'\r/ reticulating splines 5/20                                                    \r'
81
 
            , out.getvalue())
82
 
 
83
 
    def test_render_progress_easy(self):
84
 
        """Just one task and one quarter done"""
85
 
        out, view = self.make_view()
86
 
        view.enable_bar = True
87
 
        task = self.make_task(None, view, 'reticulating splines', 5, 20)
88
 
        view.show_progress(task)
89
 
        self.assertEqual(
90
 
'\r[####/               ] reticulating splines 5/20                               \r'
91
 
            , out.getvalue())
92
 
 
93
 
    def test_render_progress_nested(self):
94
 
        """Tasks proportionally contribute to overall progress"""
95
 
        out, view = self.make_view()
96
 
        task = self.make_task(None, view, 'reticulating splines', 0, 2)
97
 
        task2 = self.make_task(task, view, 'stage2', 1, 2)
98
 
        view.show_progress(task2)
99
 
        view.enable_bar = True
100
 
        # so we're in the first half of the main task, and half way through
101
 
        # that
102
 
        self.assertEqual(
103
 
r'[####-               ] reticulating splines:stage2 1/2'
104
 
            , view._render_line())
105
 
        # if the nested task is complete, then we're all the way through the
106
 
        # first half of the overall work
107
 
        task2.update('stage2', 2, 2)
108
 
        self.assertEqual(
109
 
r'[#########\          ] reticulating splines:stage2 2/2'
110
 
            , view._render_line())
111
 
 
112
 
    def test_render_progress_sub_nested(self):
113
 
        """Intermediate tasks don't mess up calculation."""
114
 
        out, view = self.make_view()
115
 
        view.enable_bar = True
116
 
        task_a = ProgressTask(None, progress_view=view)
117
 
        task_a.update('a', 0, 2)
118
 
        task_b = ProgressTask(task_a, progress_view=view)
119
 
        task_b.update('b')
120
 
        task_c = ProgressTask(task_b, progress_view=view)
121
 
        task_c.update('c', 1, 2)
122
 
        # the top-level task is in its first half; the middle one has no
123
 
        # progress indication, just a label; and the bottom one is half done,
124
 
        # so the overall fraction is 1/4
125
 
        self.assertEqual(
126
 
            r'[####|               ] a:b:c 1/2'
127
 
            , view._render_line())
 
55
class TestProgress(TestCase):
 
56
 
 
57
    def setUp(self):
 
58
        q = DummyProgress()
 
59
        self.top = ChildProgress(_stack=FakeStack(q))
 
60
 
 
61
    def test_propogation(self):
 
62
        self.top.update('foobles', 1, 2)
 
63
        self.assertEqual(self.top.message, 'foobles')
 
64
        self.assertEqual(self.top.current, 1)
 
65
        self.assertEqual(self.top.total, 2)
 
66
        self.assertEqual(self.top.child_fraction, 0)
 
67
        child = ChildProgress(_stack=FakeStack(self.top))
 
68
        child.update('baubles', 2, 4)
 
69
        self.assertEqual(self.top.message, 'foobles')
 
70
        self.assertEqual(self.top.current, 1)
 
71
        self.assertEqual(self.top.total, 2)
 
72
        self.assertEqual(self.top.child_fraction, 0.5)
 
73
        grandchild = ChildProgress(_stack=FakeStack(child))
 
74
        grandchild.update('barbells', 1, 2)
 
75
        self.assertEqual(self.top.child_fraction, 0.625)
 
76
        self.assertEqual(child.child_fraction, 0.5)
 
77
        child.update('baubles', 3, 4)
 
78
        self.assertEqual(child.child_fraction, 0)
 
79
        self.assertEqual(self.top.child_fraction, 0.75)
 
80
        grandchild.update('barbells', 1, 2)
 
81
        self.assertEqual(self.top.child_fraction, 0.875)
 
82
        grandchild.update('barbells', 2, 2)
 
83
        self.assertEqual(self.top.child_fraction, 1)
 
84
        child.update('baubles', 4, 4)
 
85
        self.assertEqual(self.top.child_fraction, 1)
 
86
        #test clamping
 
87
        grandchild.update('barbells', 2, 2)
 
88
        self.assertEqual(self.top.child_fraction, 1)
 
89
 
 
90
    def test_implementations(self):
 
91
        for implementation in (TTYProgressBar, DotsProgressBar, 
 
92
                               DummyProgress):
 
93
            self.check_parent_handling(implementation)
 
94
 
 
95
    def check_parent_handling(self, parentclass):
 
96
        top = parentclass(to_file=StringIO())
 
97
        top.update('foobles', 1, 2)
 
98
        child = ChildProgress(_stack=FakeStack(top))
 
99
        child.update('baubles', 4, 4)
 
100
        top.update('lala', 2, 2)
 
101
        child.update('baubles', 4, 4)
 
102
 
 
103
    def test_stacking(self):
 
104
        self.check_stack(TTYProgressBar, ChildProgress)
 
105
        self.check_stack(DotsProgressBar, ChildProgress)
 
106
        self.check_stack(DummyProgress, DummyProgress)
 
107
 
 
108
    def check_stack(self, parent_class, child_class):
 
109
        stack = ProgressBarStack(klass=parent_class, to_file=StringIO())
 
110
        parent = stack.get_nested()
 
111
        try:
 
112
            self.assertIs(parent.__class__, parent_class)
 
113
            child = stack.get_nested()
 
114
            try:
 
115
                self.assertIs(child.__class__, child_class)
 
116
            finally:
 
117
                child.finished()
 
118
        finally:
 
119
            parent.finished()
 
120
 
 
121
    def test_throttling(self):
 
122
        pb = InstrumentedProgress(to_file=StringIO())
 
123
        # instantaneous updates should be squelched
 
124
        pb.update('me', 1, 1)
 
125
        self.assertTrue(pb.always_throttled)
 
126
        pb = InstrumentedProgress(to_file=StringIO())
 
127
        # It's like an instant sleep(1)!
 
128
        pb.start_time -= 1
 
129
        # Updates after a second should not be squelched
 
130
        pb.update('me', 1, 1)
 
131
        self.assertFalse(pb.always_throttled)
 
132
 
 
133
    def test_clear(self):
 
134
        sio = StringIO()
 
135
        pb = TTYProgressBar(to_file=sio, show_eta=False)
 
136
        pb.width = 20 # Just make it easier to test
 
137
        # This should not output anything
 
138
        pb.clear()
 
139
        # These two should not be displayed because
 
140
        # of throttling
 
141
        pb.update('foo', 1, 3)
 
142
        pb.update('bar', 2, 3)
 
143
        # So pb.clear() has nothing to do
 
144
        pb.clear()
 
145
 
 
146
        # Make sure the next update isn't throttled
 
147
        pb.start_time -= 1
 
148
        pb.update('baz', 3, 3)
 
149
        pb.clear()
 
150
 
 
151
        self.assertEqual('\r[=========] baz 3/3'
 
152
                         '\r                   \r',
 
153
                         sio.getvalue())
 
154
 
 
155
    def test_no_eta(self):
 
156
        # An old version of the progress bar would
 
157
        # store every update if show_eta was false
 
158
        # because the eta routine was where it was
 
159
        # cleaned out
 
160
        pb = InstrumentedProgress(to_file=StringIO(), show_eta=False)
 
161
        # Just make sure this first few are throttled
 
162
        pb.start_time += 5
 
163
 
 
164
        # These messages are throttled, and don't contribute
 
165
        for count in xrange(100):
 
166
            pb.update('x', count, 300)
 
167
        self.assertEqual(0, len(pb.last_updates))
 
168
 
 
169
        # Unthrottle by time
 
170
        pb.start_time -= 10
 
171
 
 
172
        # These happen too fast, so only one gets through
 
173
        for count in xrange(100):
 
174
            pb.update('x', count+100, 200)
 
175
        self.assertEqual(1, len(pb.last_updates))
 
176
 
 
177
        pb.MIN_PAUSE = 0.0
 
178
 
 
179
        # But all of these go through, don't let the
 
180
        # last_update list grow without bound
 
181
        for count in xrange(100):
 
182
            pb.update('x', count+100, 200)
 
183
 
 
184
        self.assertEqual(pb._max_last_updates, len(pb.last_updates))
 
185
 
 
186
 
 
187
class TestProgressTypes(TestCase):
 
188
    """Test that the right ProgressBar gets instantiated at the right time."""
 
189
 
 
190
    def get_nested(self, outf, term, env_progress=None):
 
191
        """Setup so that ProgressBar thinks we are in the supplied terminal."""
 
192
        orig_term = os.environ.get('TERM')
 
193
        orig_progress = os.environ.get('BZR_PROGRESS_BAR')
 
194
        os.environ['TERM'] = term
 
195
        if env_progress is not None:
 
196
            os.environ['BZR_PROGRESS_BAR'] = env_progress
 
197
        elif orig_progress is not None:
 
198
            del os.environ['BZR_PROGRESS_BAR']
 
199
 
 
200
        def reset():
 
201
            if orig_term is None:
 
202
                del os.environ['TERM']
 
203
            else:
 
204
                os.environ['TERM'] = orig_term
 
205
            # We may have never created BZR_PROGRESS_BAR
 
206
            # So we can't just delete like we can 'TERM' (which is always set)
 
207
            if orig_progress is None:
 
208
                if 'BZR_PROGRESS_BAR' in os.environ:
 
209
                    del os.environ['BZR_PROGRESS_BAR']
 
210
            else:
 
211
                os.environ['BZR_PROGRESS_BAR'] = orig_progress
 
212
 
 
213
        self.addCleanup(reset)
 
214
 
 
215
        stack = ProgressBarStack(to_file=outf)
 
216
        pb = stack.get_nested()
 
217
        pb.start_time -= 1 # Make sure it is ready to write
 
218
        pb.width = 20 # And it is of reasonable size
 
219
        return pb
 
220
 
 
221
    def test_tty_progress(self):
 
222
        # Make sure the ProgressBarStack thinks it is
 
223
        # writing out to a terminal, and thus uses a TTYProgressBar
 
224
        out = _TTYStringIO()
 
225
        pb = self.get_nested(out, 'xterm')
 
226
        self.assertIsInstance(pb, TTYProgressBar)
 
227
        try:
 
228
            pb.update('foo', 1, 2)
 
229
            pb.update('bar', 2, 2)
 
230
        finally:
 
231
            pb.finished()
 
232
 
 
233
        self.assertEqual('\r/ [====   ] foo 1/2'
 
234
                         '\r- [=======] bar 2/2'
 
235
                         '\r                   \r',
 
236
                         out.getvalue())
 
237
 
 
238
    def test_noninteractive_progress(self):
 
239
        out = _NonTTYStringIO()
 
240
        pb = self.get_nested(out, 'xterm')
 
241
        self.assertIsInstance(pb, DummyProgress)
 
242
        try:
 
243
            pb.update('foo', 1, 2)
 
244
            pb.update('bar', 2, 2)
 
245
        finally:
 
246
            pb.finished()
 
247
        self.assertEqual('', out.getvalue())
 
248
 
 
249
    def test_dots_progress(self):
 
250
        # make sure we get the right progress bar when not on a terminal
 
251
        out = _NonTTYStringIO()
 
252
        pb = self.get_nested(out, 'xterm', 'dots')
 
253
        self.assertIsInstance(pb, DotsProgressBar)
 
254
        try:
 
255
            pb.update('foo', 1, 2)
 
256
            pb.update('bar', 2, 2)
 
257
        finally:
 
258
            pb.finished()
 
259
        self.assertEqual('foo: .'
 
260
                         '\nbar: .'
 
261
                         '\n',
 
262
                         out.getvalue())
 
263
 
 
264
    def test_no_isatty_progress(self):
 
265
        # Make sure ProgressBarStack handles a plain StringIO()
 
266
        import cStringIO
 
267
        out = cStringIO.StringIO()
 
268
        pb = self.get_nested(out, 'xterm')
 
269
        pb.finished()
 
270
        self.assertIsInstance(pb, DummyProgress)
 
271
 
 
272
    def test_dumb_progress(self):
 
273
        # using a terminal that can't do cursor movement
 
274
        out = _TTYStringIO()
 
275
        pb = self.get_nested(out, 'dumb')
 
276
        pb.finished()
 
277
        self.assertIsInstance(pb, DummyProgress)
 
278
 
 
279
    def test_progress_env_tty(self):
 
280
        # The environ variable BZR_PROGRESS_BAR controls what type of
 
281
        # progress bar we will get, even if it wouldn't usually be that type
 
282
        import cStringIO
 
283
 
 
284
        # Usually, this would be a DotsProgressBar
 
285
        out = cStringIO.StringIO()
 
286
        pb = self.get_nested(out, 'dumb', 'tty')
 
287
        pb.finished()
 
288
        # Even though we are not a tty, the env_var will override
 
289
        self.assertIsInstance(pb, TTYProgressBar)
 
290
 
 
291
    def test_progress_env_none(self):
 
292
        # Even though we are in a valid tty, no progress
 
293
        out = _TTYStringIO()
 
294
        pb = self.get_nested(out, 'xterm', 'none')
 
295
        pb.finished()
 
296
        self.assertIsInstance(pb, DummyProgress)
 
297
 
 
298
    def test_progress_env_invalid(self):
 
299
        out = _TTYStringIO()
 
300
        self.assertRaises(errors.InvalidProgressBarType, self.get_nested,
 
301
            out, 'xterm', 'nonexistant')