1
=== added file 'cli-app-demo.py'
2
--- cli-app-demo.py	1970-01-01 00:00:00 +0000
3
+++ cli-app-demo.py	2013-12-17 15:23:53 +0000
4
@@ -0,0 +1,52 @@
5
1
#!.venv/bin/python
6
2
7
3
# This file is part of the Juju Quickstart Plugin, which lets users set up a
8
4
# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
9
5
# Copyright (C) 2013 Canonical Ltd.
10
6
#
11
7
# This program is free software: you can redistribute it and/or modify it under
12
8
# the terms of the GNU Affero General Public License version 3, as published by
13
9
# the Free Software Foundation.
14
10
#
15
11
# This program is distributed in the hope that it will be useful, but WITHOUT
16
12
# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
17
13
# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
14
# Affero General Public License for more details.
19
15
#
20
16
# You should have received a copy of the GNU Affero General Public License
21
17
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
22
18
23
19
"""Juju Quickstart CLI application demo."""
24
20
25
21
# XXX frankban (2013-12-16): this file is only for demonstration/QA purposes.
26
22
# Remove this file when the environment management integration is completed.
27
23
# Run "make" before running this file.
28
24
29
25
from __future__ import (
30
26
    print_function,
31
27
    unicode_literals,
32
28
)
33
29
34
30
import urwid
35
31
36
32
from quickstart.cli import views
37
33
38
34
39
35
def example_view(app, message):
40
36
    """An example Quickstart view."""
41
37
    app.set_title('This is the title')
42
38
    widgets = [
43
39
        urwid.Text('These are the app contents. Press ^X to exit.'),
44
40
        urwid.Divider(),
45
41
        urwid.Text('Message: {}'.format(message)),
46
42
    ]
47
43
    contents = urwid.ListBox(urwid.SimpleFocusListWalker(widgets))
48
44
    app.set_contents(contents)
49
45
    app.set_status(('status error', '\u2622 Look! A toxic status! \u2622'))
50
46
    app.set_message('this notification will disappear in three seconds')
51
47
    return 'Goodbye, world'
52
48
53
49
54
50
if __name__ == '__main__':
55
51
    return_value = views.show(example_view, 'Hello, world')
56
52
    print(return_value)
57
0
53
58
=== added directory 'quickstart/cli'
59
=== added file 'quickstart/cli/__init__.py'
60
--- quickstart/cli/__init__.py	1970-01-01 00:00:00 +0000
61
+++ quickstart/cli/__init__.py	2013-12-17 15:23:53 +0000
62
@@ -0,0 +1,33 @@
63
1
# This file is part of the Juju Quickstart Plugin, which lets users set up a
64
2
# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
65
3
# Copyright (C) 2013 Canonical Ltd.
66
4
#
67
5
# This program is free software: you can redistribute it and/or modify it under
68
6
# the terms of the GNU Affero General Public License version 3, as published by
69
7
# the Free Software Foundation.
70
8
#
71
9
# This program is distributed in the hope that it will be useful, but WITHOUT
72
10
# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
73
11
# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
74
12
# Affero General Public License for more details.
75
13
#
76
14
# You should have received a copy of the GNU Affero General Public License
77
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
78
16
79
17
"""Juju Quickstart command line interface management.
80
18
81
19
The functions and objects included in this package can be used to build
82
20
rich command line interfaces using the Urwid console interface library
83
21
(see <http://excess.org/urwid/>).
84
22
85
23
This package is organized in several modules:
86
24
    - base: the base pieces used to set up Urwid applications;
87
25
    - views: view functions responsible for showing specific contents in the
88
26
      context of a Urwid app;
89
27
    - ui: Urwid related utility objects, including callback wrappers,
90
28
      customized widgets and style specific helpers.
91
29
92
30
Client code usually starts a Quickstart terminal application calling
93
31
views.show() with the view to display along with the view required arguments.
94
32
See the quickstart.cli.views module docstring for further details.
95
33
"""
96
0
34
97
=== added file 'quickstart/cli/base.py'
98
--- quickstart/cli/base.py	1970-01-01 00:00:00 +0000
99
+++ quickstart/cli/base.py	2013-12-17 15:23:53 +0000
100
@@ -0,0 +1,155 @@
101
1
# This file is part of the Juju Quickstart Plugin, which lets users set up a
102
2
# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
103
3
# Copyright (C) 2013 Canonical Ltd.
104
4
#
105
5
# This program is free software: you can redistribute it and/or modify it under
106
6
# the terms of the GNU Affero General Public License version 3, as published by
107
7
# the Free Software Foundation.
108
8
#
109
9
# This program is distributed in the hope that it will be useful, but WITHOUT
110
10
# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
111
11
# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
112
12
# Affero General Public License for more details.
113
13
#
114
14
# You should have received a copy of the GNU Affero General Public License
115
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
116
16
117
17
"""Juju Quickstart Urwid application base handling.
118
18
119
19
A collection of objects which help in building a Quickstart CLI application
120
20
skeleton. Views use these functions to set up the Urwid top widget and to start
121
21
the application main loop.
122
22
123
23
See the quickstart.cli.views module docstring for further details.
124
24
"""
125
25
126
26
from __future__ import unicode_literals
127
27
128
28
import urwid
129
29
130
30
from quickstart import (
131
31
    get_version,
132
32
    utils,
133
33
)
134
34
from quickstart.cli import ui
135
35
136
36
137
37
class _MainLoop(urwid.MainLoop):
138
38
    """A customized Urwid loop.
139
39
140
40
    Allow for setting the unhandled_input callable after the loop
141
41
    initialization.
142
42
    """
143
43
144
44
    def set_unhandled_input(self, unhandled_input):
145
45
        """Set the unhandled_input callable.
146
46
147
47
        The passed unhandled_input is a callable called when input is not
148
48
        handled by the application top widget.
149
49
        """
150
50
        self._unhandled_input = unhandled_input
151
51
152
52
    def get_alarms(self):
153
53
        """Return all the alarms set for this loop.
154
54
155
55
        Improves the level of event loop introspection so that code and tests
156
56
        can easily access the alarms list.
157
57
158
58
        The alarms list is a sequence of (time, callback) tuples.
159
59
        """
160
60
        return self.event_loop._alarms
161
61
162
62
163
63
def setup_urwid_app():
164
64
    """Configure a Urwid application suitable for being used by views.
165
65
166
66
    Build the Urwid top widget and instantiate a main loop. The top widget
167
67
    is basically a frame, composed by a header, some contents, and a footer.
168
68
    This application skeleton is Quickstart branded, and exposes functions
169
69
    that can be used by views to change the contents of the frame.
170
70
171
71
    Return a tuple (loop, app) where loop is the interactive session main loop
172
72
    (ready to be started invoking loop.run()) and app is an ObjectDict exposing
173
73
    an API to be used by views to customize the application.
174
74
175
75
    The API exposed by app is limited by design, and includes:
176
76
177
77
        - set_title(text): set/change the title displayed in the application
178
78
          header (e.g.: app.set_title('my title'));
179
79
        - get_title(): return the current application title;
180
80
181
81
        - set_contents(widget): set/change the application body contents. A
182
82
          Urwid ListBox widget instance is usually provided, which replaces the
183
83
          current application contents;
184
84
        - get_contents(): return the current application contents widget;
185
85
186
86
        - set_status(text): set/change the status text displayed in the
187
87
          application footer (e.g.: set_status('press play on tape')). The
188
88
          status message can also be passed as a (style, text) tuple, as usual
189
89
          in Urwid code, e.g.: app.set_status(('error', 'error message'));
190
90
        - get_status(): return the current status message;
191
91
192
92
        - set_message(text): set/change a notification message, which is
193
93
          displayed in the footer for a couple of seconds before disappearing;
194
94
        - get_message(): return the message currently displayed in the
195
95
          notifications area.
196
96
    """
197
97
    # Set up the application header.
198
98
    title = urwid.Text('\npreparing...')
199
99
    header_line = urwid.Divider('\N{LOWER ONE QUARTER BLOCK}')
200
100
    header = urwid.Pile([
201
101
        urwid.AttrMap(ui.padding(title), 'header'),
202
102
        urwid.AttrMap(header_line, 'line header'),
203
103
        urwid.Divider(),
204
104
    ])
205
105
    # Set up the application default contents.
206
106
    # View code is assumed to replace the placeholder widget using
207
107
    # app.set_contents(widget).
208
108
    placeholder = urwid.ListBox(urwid.SimpleFocusListWalker([]))
209
109
    contents = ui.padding(urwid.AttrMap(placeholder, None))
210
110
211
111
    def set_contents(widget):
212
112
        contents.original_widget = widget
213
113
214
114
    # Set up the application footer.
215
115
    # The CTRL-x shortcut is automatically set up by views.show().
216
116
    brand_message = 'juju-quickstart v{} - ^X exit '.format(get_version())
217
117
    brand = urwid.Text(brand_message)
218
118
    status = urwid.Text('')
219
119
    message = urwid.Text('', align='right')
220
120
    footer_line = urwid.Divider('\N{UPPER ONE EIGHTH BLOCK}')
221
121
    status_columns = urwid.Columns([('pack', brand), status, message])
222
122
    footer = urwid.Pile([
223
123
        urwid.Divider(),
224
124
        urwid.AttrMap(ui.padding(status_columns), 'footer'),
225
125
        urwid.AttrMap(footer_line, 'line footer'),
226
126
    ])
227
127
    # Compose the components in a frame, and set up the top widget. The top
228
128
    # widget is the topmost widget used for painting the screen.
229
129
    page = urwid.Frame(contents, header=header, footer=footer)
230
130
    top_widget = urwid.Overlay(
231
131
        page, urwid.SolidFill('\N{MEDIUM SHADE}'),
232
132
        align='center', width=('relative', 90),
233
133
        valign='middle', height=('relative', 90),
234
134
        min_width=78, min_height=20)
235
135
    # Instantiate the Urwid main loop.
236
136
    loop = _MainLoop(top_widget, palette=ui.PALETTE)
237
137
238
138
    def set_message(msg):
239
139
        message.set_text(('message', msg))
240
140
        loop.set_alarm_in(3, lambda *args: message.set_text(''))
241
141
242
142
    # Create the app ObjectDict. If in the future we will find a view to
243
143
    # require more capabilities/API access than the current one, this is the
244
144
    # place where to add new API functions.
245
145
    app = utils.ObjectDict(
246
146
        set_title=lambda msg: title.set_text('\n{}'.format(msg)),
247
147
        get_title=lambda: title.text.lstrip(),
248
148
        set_contents=set_contents,
249
149
        get_contents=lambda: contents.original_widget,
250
150
        set_status=lambda msg: status.set_text(msg),
251
151
        get_status=lambda: status.text,
252
152
        set_message=set_message,
253
153
        get_message=lambda: message.text,
254
154
    )
255
155
    return loop, app
256
0
156
257
=== added file 'quickstart/cli/ui.py'
258
--- quickstart/cli/ui.py	1970-01-01 00:00:00 +0000
259
+++ quickstart/cli/ui.py	2013-12-17 15:23:53 +0000
260
@@ -0,0 +1,118 @@
261
1
# This file is part of the Juju Quickstart Plugin, which lets users set up a
262
2
# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
263
3
# Copyright (C) 2013 Canonical Ltd.
264
4
#
265
5
# This program is free software: you can redistribute it and/or modify it under
266
6
# the terms of the GNU Affero General Public License version 3, as published by
267
7
# the Free Software Foundation.
268
8
#
269
9
# This program is distributed in the hope that it will be useful, but WITHOUT
270
10
# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
271
11
# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
272
12
# Affero General Public License for more details.
273
13
#
274
14
# You should have received a copy of the GNU Affero General Public License
275
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
276
16
277
17
"""Juju Quickstart Urwid related utility objects."""
278
18
279
19
from __future__ import unicode_literals
280
20
281
21
import functools
282
22
283
23
import urwid
284
24
285
25
286
26
# Define the shortcut used to quit the interactive session.
287
27
EXIT_KEY = 'ctrl x'
288
28
# Define the color palette used by the Urwid application.
289
29
PALETTE = [
290
30
    # Class name, foreground color, background color.
291
31
    # See <http://excess.org/urwid/docs/reference/constants.html
292
32
    # foreground-and-background-colors>.
293
33
    (None, 'light gray', 'black'),
294
34
    ('controls', 'dark gray', 'light gray'),
295
35
    ('edit', 'white,underline', 'black'),
296
36
    ('error', 'light red', 'black'),
297
37
    ('status error', 'light red', 'light gray'),
298
38
    ('footer', 'black', 'light gray'),
299
39
    ('message', 'white', 'dark green'),
300
40
    ('header', 'white', 'dark magenta'),
301
41
    ('highlight', 'white', 'black'),
302
42
    ('line header', 'dark gray', 'dark magenta'),
303
43
    ('line footer', 'light gray', 'light gray'),
304
44
    ('selected', 'white', 'dark blue'),
305
45
]
306
46
# Define a default padding for the Urwid application.
307
47
padding = functools.partial(urwid.Padding, left=2, right=2)
308
48
309
49
310
50
class AppExit(Exception):
311
51
    """Used by views to stop the interactive execution returning a value."""
312
52
313
53
    def __init__(self, return_value=None):
314
54
        """Set the value to return to the view caller (default is None)."""
315
55
        self.return_value = return_value
316
56
317
57
    def __str__(self):
318
58
        return b'{}: {!r}'.format(self.__class__.__name__, self.return_value)
319
59
320
60
321
61
def exit_and_return(return_value):
322
62
    """Return a function that can be used as unhandled_input for an Urwid app.
323
63
324
64
    The resulting function terminates the interactive session with the given
325
65
    return_value when the user hits CTRL-x.
326
66
    """
327
67
    def unhandled_input(key):
328
68
        if key == EXIT_KEY:
329
69
            raise AppExit(return_value)
330
70
    return unhandled_input
331
71
332
72
333
73
def create_controls(*args):
334
74
    """Create a row of control widgets surrounded by line boxes."""
335
75
    controls = urwid.Columns([padding(urwid.LineBox(arg)) for arg in args])
336
76
    return urwid.Pile([
337
77
        urwid.Divider(top=1, bottom=1),
338
78
        urwid.AttrMap(controls, 'controls')
339
79
    ])
340
80
341
81
342
82
class MenuButton(urwid.Button):
343
83
    """A customized Urwid button widget.
344
84
345
85
    This behaves like a regular button, but also takes a callback that is
346
86
    called when the button is clicked.
347
87
    """
348
88
349
89
    def __init__(self, caption, callback):
350
90
        super(MenuButton, self).__init__('')
351
91
        urwid.connect_signal(self, 'click', callback)
352
92
        icon = urwid.SelectableIcon(caption, 0)
353
93
        # Replace the original widget: it seems ugly but it is Urwid idiomatic.
354
94
        self._w = urwid.AttrMap(icon, None, 'selected')
355
95
356
96
357
97
def thunk(function, *args, **kwargs):
358
98
    """Create and return a callable binding the given method and args/kwargs.
359
99
360
100
    This is useful when the given function is used as a signal subscriber, e.g.
361
101
    as a callback to be called when an Urwid signal is sent. In most cases, the
362
102
    widget which generated the event is sent as first argument to the callback.
363
103
    Moreover, urwid.connect_signal handles only one user argument.
364
104
    See <http://excess.org/urwid/docs/reference/signals.html>.
365
105
366
106
    This function helps when the callback does not require the original widget
367
107
    and/or when it instead requires more than one argument, e.g.:
368
108
369
109
        def save(contents, commit=False):
370
110
            ...
371
111
372
112
        button = MenuButton('save and commit', ui.thunk(save, contents, True))
373
113
374
114
    This example uses the MenuButton widget defined above in this module.
375
115
    """
376
116
    def callback(*ignored_args, **ignored_kwargs):
377
117
        return function(*args, **kwargs)
378
118
    return callback
379
0
119
380
=== added file 'quickstart/cli/views.py'
381
--- quickstart/cli/views.py	1970-01-01 00:00:00 +0000
382
+++ quickstart/cli/views.py	2013-12-17 15:23:53 +0000
383
@@ -0,0 +1,119 @@
384
1
# This file is part of the Juju Quickstart Plugin, which lets users set up a
385
2
# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
386
3
# Copyright (C) 2013 Canonical Ltd.
387
4
#
388
5
# This program is free software: you can redistribute it and/or modify it under
389
6
# the terms of the GNU Affero General Public License version 3, as published by
390
7
# the Free Software Foundation.
391
8
#
392
9
# This program is distributed in the hope that it will be useful, but WITHOUT
393
10
# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
394
11
# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
395
12
# Affero General Public License for more details.
396
13
#
397
14
# You should have received a copy of the GNU Affero General Public License
398
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
399
16
400
17
"""Juju Quickstart CLI application views.
401
18
402
19
This module contains the Quickstart view implementations along with a function
403
20
(show) to easily start a view automatically creating an Urwid application.
404
21
405
22
To start a Quickstart interactive session, just run the following:
406
23
407
24
    show(view, *args)
408
25
409
26
The code above sets up a Quickstart branded CLI application, then calls the
410
27
given view callable passing the application object ready to be configured
411
28
and all the given optional arguments. Finally the interactive session is
412
29
started, and the show function blocks until the user or the view itself
413
30
request to exit the application.
414
31
415
32
A view is a callable receiving an app ObjectDict and other optional arguments
416
33
(based on specific view needs). A view function can configure the Urwid
417
34
application using the API exposed by the application object
418
35
(see quickstart.cli.base.setup_urwid_app).
419
36
420
37
Assume a view is defined like the following:
421
38
422
39
    def myview(app, title):
423
40
        app.set_title(title)
424
41
        return 42
425
42
426
43
The view above, requiring a title argument, can be started this way:
427
44
428
45
    show(myview, 'this title will be shown in the header')
429
46
430
47
At this point the application main loop is started, and the user can interact
431
48
with the CLI interface. There are two ways to stop the interactive session:
432
49
    1) the user explicitly requests to exit. The Urwid application is
433
50
       automatically configured to allow the user to quit whenever she wants by
434
51
       pressing a keyboard shortcut;
435
52
    2) a view decides it is time to quit (e.g. reacting to an event/input).
436
53
437
54
In both cases, the show function returns something to the caller:
438
55
    1) when the user explicitly requests to quit, the value returned by the
439
56
       view itself (the callable passed to show()) is returned. For instance,
440
57
       the show(myview...) call above would return 42;
441
58
    2) to force the end of the interactive session, a view can raise a
442
59
       quickstart.cli.ui.AppExit exception, passing a return value: if the
443
60
       application is exited this way, then show() returns the value
444
61
       encapsulated in the exception. Note that this exception can be raised
445
62
       as a reaction to an event, and not in the first execution of the view
446
63
       body, i.e. during the app configuration.
447
64
448
65
The above is better described by code:
449
66
450
67
    from quickstart.cli import views, ui
451
68
452
69
    def button_view(app):
453
70
454
71
        def exit():
455
72
            raise ui.AppExit(True)
456
73
457
74
        app.set_title('behold the button below')
458
75
        button = ui.MenuButton('press to exit', ui.thunk(exit))
459
76
        widgets = urwid.ListBox(urwid.SimpleFocusListWalker([button]))
460
77
        app.set_contents(widgets)
461
78
        return False
462
79
463
80
    pressed = views.show(button_view)
464
81
465
82
In this example the button_view function configures the app to show a button.
466
83
Clicking that button an AppExit(True) is raised. The view itself instead just
467
84
returns False. This means that "pressed" will be True if the user exited using
468
85
the button, or False if the user exited using the global shortcut.
469
86
470
87
As a final note, it is absolutely safe for a view to call, directly or
471
88
indirectly, other views, as long as all the arguments required by the other
472
89
views, including app, are properly provided. This is effectively the proposed
473
90
solution to build multi-views CLI applications in Quickstart.
474
91
"""
475
92
476
93
from __future__ import unicode_literals
477
94
478
95
from quickstart.cli import (
479
96
    base,
480
97
    ui,
481
98
)
482
99
483
100
484
101
def show(view, *args):
485
102
    """Start an Urwid interactive session showing the given view.
486
103
487
104
    The view is called passing an app ObjectDict and the provided *args.
488
105
489
106
    Block until the main loop is stopped, either by the user with the exit
490
107
    shortcut or by the view itself with the AppExit exception. In the former
491
108
    case, return what is returned by the view. In the AppExit case, return
492
109
    the value encapsulated in the exception.
493
110
    """
494
111
    loop, app = base.setup_urwid_app()
495
112
    default_return_value = view(app, *args)
496
113
    unhandled_input = ui.exit_and_return(default_return_value)
497
114
    loop.set_unhandled_input(unhandled_input)
498
115
    # Start the Urwid interactive session (main loop).
499
116
    try:
500
117
        loop.run()
501
118
    except ui.AppExit as err:
502
119
        return err.return_value
503
0
120
504
=== modified file 'quickstart/models/envs.py'
505
--- quickstart/models/envs.py	2013-12-16 08:21:57 +0000
506
+++ quickstart/models/envs.py	2013-12-17 15:23:53 +0000
507
@@ -321,7 +321,8 @@
508
321
        label='default series', required=False,
321
        label='default series', required=False,
509
322
        help='the default Ubuntu series to use for the bootstrap node')
322
        help='the default Ubuntu series to use for the bootstrap node')
510
323
    is_default_field = fields.BoolField(
323
    is_default_field = fields.BoolField(
512
324
        'is-default', help='make this the default environment', required=True)
324
        'is-default', label='default', allow_mixed=False, required=True,
513
325
        help='make this the default environment')
514
325
    # Define data structures used as part of the metadata below.
326
    # Define data structures used as part of the metadata below.
515
326
    ec2_regions = (
327
    ec2_regions = (
516
327
        'ap-northeast-1', 'ap-southeast-1', 'ap-southeast-2',
328
        'ap-northeast-1', 'ap-southeast-1', 'ap-southeast-2',
517
328
329
518
=== added directory 'quickstart/tests/cli'
519
=== added file 'quickstart/tests/cli/__init__.py'
520
--- quickstart/tests/cli/__init__.py	1970-01-01 00:00:00 +0000
521
+++ quickstart/tests/cli/__init__.py	2013-12-17 15:23:53 +0000
522
@@ -0,0 +1,15 @@
523
1
# This file is part of the Juju Quickstart Plugin, which lets users set up a
524
2
# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
525
3
# Copyright (C) 2013 Canonical Ltd.
526
4
#
527
5
# This program is free software: you can redistribute it and/or modify it under
528
6
# the terms of the GNU Affero General Public License version 3, as published by
529
7
# the Free Software Foundation.
530
8
#
531
9
# This program is distributed in the hope that it will be useful, but WITHOUT
532
10
# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
533
11
# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
534
12
# Affero General Public License for more details.
535
13
#
536
14
# You should have received a copy of the GNU Affero General Public License
537
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
538
0
16
539
=== added file 'quickstart/tests/cli/test_base.py'
540
--- quickstart/tests/cli/test_base.py	1970-01-01 00:00:00 +0000
541
+++ quickstart/tests/cli/test_base.py	2013-12-17 15:23:53 +0000
542
@@ -0,0 +1,174 @@
543
1
# This file is part of the Juju Quickstart Plugin, which lets users set up a
544
2
# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
545
3
# Copyright (C) 2013 Canonical Ltd.
546
4
#
547
5
# This program is free software: you can redistribute it and/or modify it under
548
6
# the terms of the GNU Affero General Public License version 3, as published by
549
7
# the Free Software Foundation.
550
8
#
551
9
# This program is distributed in the hope that it will be useful, but WITHOUT
552
10
# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
553
11
# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
554
12
# Affero General Public License for more details.
555
13
#
556
14
# You should have received a copy of the GNU Affero General Public License
557
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
558
16
559
17
"""Tests for the Juju Quickstart Urwid application base handling."""
560
18
561
19
from __future__ import unicode_literals
562
20
563
21
import unittest
564
22
565
23
import urwid
566
24
567
25
from quickstart import utils
568
26
from quickstart.cli import base
569
27
570
28
571
29
class TestMainLoop(unittest.TestCase):
572
30
573
31
    def setUp(self):
574
32
        # Create a loop instance.
575
33
        self.widget = urwid.ListBox(urwid.SimpleFocusListWalker([]))
576
34
        self.loop = base._MainLoop(self.widget)
577
35
578
36
    def test_initialization(self):
579
37
        # The customized loop is properly initialized, and it is an instance
580
38
        # of the Urwid loop.
581
39
        self.assertEqual(self.widget, self.loop.widget)
582
40
        self.assertIsInstance(self.loop, urwid.MainLoop)
583
41
584
42
    def test_unhandled_input(self):
585
43
        # The unhandled_input function can be set after the initialization.
586
44
        inputs = []
587
45
        self.loop.set_unhandled_input(inputs.append)
588
46
        self.loop.unhandled_input('ctrl z')
589
47
        self.assertEqual(['ctrl z'], inputs)
590
48
591
49
    def test_alarms(self):
592
50
        # It is possible to retrieve the list of event loop alarms.
593
51
        times_called = []
594
52
        self.assertEqual(0, len(self.loop.get_alarms()))
595
53
        callback = lambda *args: times_called.append(1)
596
54
        self.loop.set_alarm_in(3, callback)
597
55
        alarms = self.loop.get_alarms()
598
56
        self.assertEqual(1, len(alarms))
599
57
        alarms[0][1]()
600
58
        self.assertEqual(1, sum(times_called))
601
59
602
60
603
61
class TestSetupUrwidApp(unittest.TestCase):
604
62
605
63
    def setUp(self):
606
64
        # Set up the base Urwid application.
607
65
        self.loop, self.app = base.setup_urwid_app()
608
66
609
67
    def get_title_widget(self, loop):
610
68
        """Return the title widget given the application main loop."""
611
69
        # The frame is the main overlay's top widget.
612
70
        frame = loop.widget.top_w
613
71
        # Retrieve the header.
614
72
        header = frame.contents['header'][0]
615
73
        # The title widget is the first in the header pile.
616
74
        return header.contents[0][0].base_widget
617
75
618
76
    def get_contents_widget(self, loop):
619
77
        """Return the contents widget given the application main loop."""
620
78
        # The frame is the main overlay's top widget.
621
79
        frame = loop.widget.top_w
622
80
        # Retrieve the body.
623
81
        body = frame.contents['body'][0]
624
82
        # The contents widget is the body's original widget.
625
83
        return body.original_widget
626
84
627
85
    def _get_footer_columns(self, loop):
628
86
        # The frame is the main overlay's top widget.
629
87
        frame = loop.widget.top_w
630
88
        # Retrieve the footer.
631
89
        footer = frame.contents['footer'][0]
632
90
        # Return the columns widget.
633
91
        return footer.contents[1][0].base_widget
634
92
635
93
    def get_status_widget(self, loop):
636
94
        """Return the status widget given the application main loop."""
637
95
        columns = self._get_footer_columns(loop)
638
96
        # The status widget is the second one (brand, status, message).
639
97
        return columns.contents[1][0]
640
98
641
99
    def get_message_widget(self, loop):
642
100
        """Return the message widget given the application main loop."""
643
101
        columns = self._get_footer_columns(loop)
644
102
        # The message widget is the third one (brand, status, message).
645
103
        return columns.contents[2][0]
646
104
647
105
    def test_loop(self):
648
106
        # The returned loop is an instance of the base customized loop.
649
107
        self.assertIsInstance(self.loop, base._MainLoop)
650
108
651
109
    def test_app(self):
652
110
        # The returned app is an ObjectDict including the expected keys.
653
111
        expected_keys = set([
654
112
            'set_title', 'get_title',
655
113
            'set_contents', 'get_contents',
656
114
            'set_status', 'get_status',
657
115
            'set_message', 'get_message',
658
116
        ])
659
117
        self.assertIsInstance(self.app, utils.ObjectDict)
660
118
        self.assertEqual(expected_keys, set(self.app.keys()))
661
119
662
120
    def test_set_title(self):
663
121
        # The set_title API sets the application title.
664
122
        self.app.set_title('The Inner Light')
665
123
        title_widget = self.get_title_widget(self.loop)
666
124
        self.assertEqual('\nThe Inner Light', title_widget.text)
667
125
668
126
    def test_get_title(self):
669
127
        # The get_title API retrieves the application title.
670
128
        title_widget = self.get_title_widget(self.loop)
671
129
        title_widget.set_text('The Outer Space')
672
130
        self.assertEqual('The Outer Space', self.app.get_title())
673
131
674
132
    def test_set_contents(self):
675
133
        # The set_contents API changes the application main contents widget.
676
134
        text_widget = urwid.Text('my contents')
677
135
        self.app.set_contents(text_widget)
678
136
        contents_widget = self.get_contents_widget(self.loop)
679
137
        self.assertEqual('my contents', contents_widget.text)
680
138
681
139
    def test_get_contents(self):
682
140
        # The get_contents API returns the contents widget.
683
141
        contents_widget = self.get_contents_widget(self.loop)
684
142
        self.assertEqual(contents_widget, self.app.get_contents())
685
143
686
144
    def test_set_status(self):
687
145
        # The set_status API sets the status message displayed in the footer.
688
146
        self.app.set_status('press play on tape')
689
147
        status_widget = self.get_status_widget(self.loop)
690
148
        self.assertEqual('press play on tape', status_widget.text)
691
149
692
150
    def test_get_status(self):
693
151
        # The get_status API returns the current status message.
694
152
        status_widget = self.get_status_widget(self.loop)
695
153
        status_widget.set_text('hit space to continue')
696
154
        self.assertEqual('hit space to continue', self.app.get_status())
697
155
698
156
    def test_set_message(self):
699
157
        # The set_message API sets the message to be displayed in the
700
158
        # notification area.
701
159
        self.app.set_message('this will disappear')
702
160
        message_widget = self.get_message_widget(self.loop)
703
161
        self.assertEqual('this will disappear', message_widget.text)
704
162
        # An alarm is set to make this message disappear.
705
163
        alarms = self.loop.get_alarms()
706
164
        self.assertEqual(1, len(alarms))
707
165
        # Calling the callback makes the message go away.
708
166
        _, callback = alarms[0]
709
167
        callback()
710
168
        self.assertEqual('', message_widget.text)
711
169
712
170
    def test_get_message(self):
713
171
        # The get_message API returns the current notification message.
714
172
        message_widget = self.get_message_widget(self.loop)
715
173
        message_widget.set_text('42')
716
174
        self.assertEqual('42', self.app.get_message())
717
0
175
718
=== added file 'quickstart/tests/cli/test_ui.py'
719
--- quickstart/tests/cli/test_ui.py	1970-01-01 00:00:00 +0000
720
+++ quickstart/tests/cli/test_ui.py	2013-12-17 15:23:53 +0000
721
@@ -0,0 +1,117 @@
722
1
# This file is part of the Juju Quickstart Plugin, which lets users set up a
723
2
# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
724
3
# Copyright (C) 2013 Canonical Ltd.
725
4
#
726
5
# This program is free software: you can redistribute it and/or modify it under
727
6
# the terms of the GNU Affero General Public License version 3, as published by
728
7
# the Free Software Foundation.
729
8
#
730
9
# This program is distributed in the hope that it will be useful, but WITHOUT
731
10
# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
732
11
# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
733
12
# Affero General Public License for more details.
734
13
#
735
14
# You should have received a copy of the GNU Affero General Public License
736
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
737
16
738
17
"""Tests for the Juju Quickstart Urwid related utility objects."""
739
18
740
19
from __future__ import unicode_literals
741
20
742
21
import unittest
743
22
744
23
import mock
745
24
import urwid
746
25
747
26
from quickstart.cli import ui
748
27
749
28
750
29
class TestAppExit(unittest.TestCase):
751
30
752
31
    def test_no_return_value(self):
753
32
        # The exception accepts a return value argument.
754
33
        exception = ui.AppExit(42)
755
34
        self.assertEqual(42, exception.return_value)
756
35
757
36
    def test_return_value(self):
758
37
        # The exception's return value defaults to None.
759
38
        exception = ui.AppExit()
760
39
        self.assertIsNone(exception.return_value)
761
40
762
41
    def test_string_representation(self):
763
42
        # The exception is correctly represented as a byte string.
764
43
        exception = ui.AppExit(42)
765
44
        str_exception = str(exception)
766
45
        self.assertIsInstance(str_exception, bytes)
767
46
        self.assertEqual(b'AppExit: 42', str_exception)
768
47
769
48
770
49
class TestExitAndReturn(unittest.TestCase):
771
50
772
51
    def test_app_exit(self):
773
52
        # The function returned raises an AppExit error if CTRL-x is passed.
774
53
        function = ui.exit_and_return(42)
775
54
        with self.assertRaises(ui.AppExit) as context_manager:
776
55
            function(ui.EXIT_KEY)
777
56
        self.assertEqual(42, context_manager.exception.return_value)
778
57
779
58
    def test_unhandled(self):
780
59
        # Passing other keys, the resulting function is a no-op.
781
60
        function = ui.exit_and_return(42)
782
61
        self.assertIsNone(function('alt z'))
783
62
784
63
785
64
class TestCreateControls(unittest.TestCase):
786
65
787
66
    def test_resulting_pile(self):
788
67
        # The resulting pile is properly structured: it includes a columns
789
68
        # widget containing the provided widgets.
790
69
        widget0 = urwid.Text('w0')
791
70
        widget1 = urwid.Text('w1')
792
71
        pile = ui.create_controls(widget0, widget1)
793
72
        divider_contents, columns_contents = pile.contents
794
73
        self.assertIsInstance(divider_contents[0], urwid.Divider)
795
74
        columns = columns_contents[0].original_widget
796
75
        widgets = [content[0].base_widget for content in columns.contents]
797
76
        self.assertIs(widget0, widgets[0])
798
77
        self.assertIs(widget1, widgets[1])
799
78
800
79
801
80
class TestMenuButton(unittest.TestCase):
802
81
803
82
    def test_caption(self):
804
83
        # The button's caption is properly set up.
805
84
        button = ui.MenuButton('my caption', mock.Mock())
806
85
        self.assertEqual('my caption', button._w.base_widget.text)
807
86
808
87
    def test_signals(self):
809
88
        # The given callback is called when the click signal is emitted.
810
89
        callback = mock.Mock()
811
90
        button = ui.MenuButton('my caption', callback)
812
91
        urwid.emit_signal(button, 'click', button)
813
92
        callback.assert_called_once_with(button)
814
93
815
94
816
95
class TestThunk(unittest.TestCase):
817
96
818
97
    widget = 'test-widget'
819
98
820
99
    def test_no_args(self):
821
100
        # A callback can be set up without arguments.
822
101
        function = mock.Mock()
823
102
        thunk_function = ui.thunk(function)
824
103
        thunk_function(self.widget)
825
104
        function.assert_called_once_with()
826
105
827
106
    def test_args(self):
828
107
        # It is possible to bind arguments to the callback function.
829
108
        function = mock.Mock()
830
109
        thunk_function = ui.thunk(function, 'arg1', 'arg2')
831
110
        thunk_function(self.widget)
832
111
        function.assert_called_once_with('arg1', 'arg2')
833
112
834
113
    def test_return_value(self):
835
114
        # The closure returns the value returned by the original callback.
836
115
        sqr = lambda value: value * value
837
116
        thunk_function = ui.thunk(sqr, 3)
838
117
        self.assertEqual(9, thunk_function(self.widget))
839
0
118
840
=== added file 'quickstart/tests/cli/test_views.py'
841
--- quickstart/tests/cli/test_views.py	1970-01-01 00:00:00 +0000
842
+++ quickstart/tests/cli/test_views.py	2013-12-17 15:23:53 +0000
843
@@ -0,0 +1,86 @@
844
1
# This file is part of the Juju Quickstart Plugin, which lets users set up a
845
2
# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
846
3
# Copyright (C) 2013 Canonical Ltd.
847
4
#
848
5
# This program is free software: you can redistribute it and/or modify it under
849
6
# the terms of the GNU Affero General Public License version 3, as published by
850
7
# the Free Software Foundation.
851
8
#
852
9
# This program is distributed in the hope that it will be useful, but WITHOUT
853
10
# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
854
11
# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
855
12
# Affero General Public License for more details.
856
13
#
857
14
# You should have received a copy of the GNU Affero General Public License
858
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
859
16
860
17
"""Tests for the Juju Quickstart CLI application views."""
861
18
862
19
from __future__ import unicode_literals
863
20
864
21
from contextlib import contextmanager
865
22
import unittest
866
23
867
24
import mock
868
25
869
26
from quickstart.cli import (
870
27
    ui,
871
28
    views,
872
29
)
873
30
874
31
875
32
class TestShow(unittest.TestCase):
876
33
877
34
    @contextmanager
878
35
    def patch_setup_urwid_app(self, run_side_effect=None):
879
36
        """Patch the base.setup_urwid_app function.
880
37
881
38
        The context manager returns a tuple (mock_loop, mock_app) containing
882
39
        the two mock objects returned by the mock call.
883
40
884
41
        The run_side_effect argument can be provided to specify the side
885
42
        effects of the mock_loop.run call.
886
43
        """
887
44
        mock_loop = mock.Mock()
888
45
        mock_loop.run = mock.Mock(side_effect=run_side_effect)
889
46
        mock_setup_urwid_app = mock.Mock(return_value=(mock_loop, mock.Mock()))
890
47
        setup_urwid_app_path = 'quickstart.cli.views.base.setup_urwid_app'
891
48
        with mock.patch(setup_urwid_app_path, mock_setup_urwid_app):
892
49
            yield mock_setup_urwid_app()
893
50
894
51
    def test_show_view(self):
895
52
        # The loop and app objects are properly used by the show function:
896
53
        # the loop is run and the app is passed to the view.
897
54
        view = mock.Mock()
898
55
        with self.patch_setup_urwid_app() as (mock_loop, mock_app):
899
56
            views.show(view)
900
57
        view.assert_called_once_with(mock_app)
901
58
        mock_loop.run.assert_called_once_with()
902
59
903
60
    def test_view_exit(self):
904
61
        # An ui.AppExit correctly quits the application. The return value
905
62
        # encapsulated on the exception is also returned by the show function.
906
63
        view = mock.Mock()
907
64
        run_side_effect = ui.AppExit('bad wolf')
908
65
        with self.patch_setup_urwid_app(run_side_effect=run_side_effect):
909
66
            return_value = views.show(view)
910
67
        self.assertEqual('bad wolf', return_value)
911
68
912
69
    def test_unhandled_input(self):
913
70
        # The unhandled_input callable is properly set up and registered to
914
71
        # the main loop.
915
72
        view = mock.Mock(return_value=42)
916
73
        with self.patch_setup_urwid_app() as (mock_loop, mock_app):
917
74
            views.show(view)
918
75
        unhandled_input = mock_loop.set_unhandled_input.call_args[0][0]
919
76
        with self.assertRaises(ui.AppExit) as context_manager:
920
77
            unhandled_input(ui.EXIT_KEY)
921
78
        self.assertEqual(42, context_manager.exception.return_value)
922
79
923
80
    def test_view_arguments(self):
924
81
        # The view is invoked passing the app and all the optional show
925
82
        # function arguments.
926
83
        view = mock.Mock()
927
84
        with self.patch_setup_urwid_app() as (mock_loop, mock_app):
928
85
            views.show(view, 'arg1', 'arg2')
929
86
        view.assert_called_once_with(mock_app, 'arg1', 'arg2')
930
0
87
931
=== modified file 'quickstart/tests/test_utils.py'
932
--- quickstart/tests/test_utils.py	2013-12-10 14:37:58 +0000
933
+++ quickstart/tests/test_utils.py	2013-12-17 15:23:53 +0000
934
@@ -349,6 +349,31 @@
935
349
        mock_call.assert_called_once_with('lsb_release', '-cs')
349
        mock_call.assert_called_once_with('lsb_release', '-cs')
936
350
350
937
351
351
938
352
class TestObjectDict(unittest.TestCase):
939
353
940
354
    def setUp(self):
941
355
        self.object_dict = utils.ObjectDict(mykey='myvalue')
942
356
943
357
    def test_get_attribute(self):
944
358
        # A value can be retrieved accessing the key as an attribute.
945
359
        self.assertEqual('myvalue', self.object_dict.mykey)
946
360
947
361
    def test_get_attribute_error(self):
948
362
        # An AttributeError is raised if the key is not in the dictionary.
949
363
        with self.assertRaises(AttributeError):
950
364
            self.object_dict.no_such_key
951
365
952
366
    def test_set_attribute(self):
953
367
        # A key can be added by setting the corresponding attribute.
954
368
        self.object_dict.another_key = 42
955
369
        self.assertEqual(42, self.object_dict['another_key'])
956
370
957
371
    def test_update_attribute(self):
958
372
        # It is possible to update an attribute.
959
373
        self.object_dict.mykey = 47
960
374
        self.assertEqual(47, self.object_dict.mykey)
961
375
962
376
963
352
class TestParseBundle(
377
class TestParseBundle(
964
353
        helpers.BundleFileTestsMixin, helpers.ValueErrorTestsMixin,
378
        helpers.BundleFileTestsMixin, helpers.ValueErrorTestsMixin,
965
354
        unittest.TestCase):
379
        unittest.TestCase):
966
355
380
967
=== modified file 'quickstart/utils.py'
968
--- quickstart/utils.py	2013-12-10 14:37:58 +0000
969
+++ quickstart/utils.py	2013-12-17 15:23:53 +0000
970
@@ -14,6 +14,22 @@
971
14
# You should have received a copy of the GNU Affero General Public License
14
# You should have received a copy of the GNU Affero General Public License
972
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
15
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
973
16
16
974
17
# The ObjectDict code:
975
18
#
976
19
# Copyright 2009 Facebook
977
20
#
978
21
# Licensed under the Apache License, Version 2.0 (the "License"); you may
979
22
# not use this file except in compliance with the License. You may obtain
980
23
# a copy of the License at
981
24
#
982
25
#     http://www.apache.org/licenses/LICENSE-2.0
983
26
#
984
27
# Unless required by applicable law or agreed to in writing, software
985
28
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
986
29
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
987
30
# License for the specific language governing permissions and limitations
988
31
# under the License.
989
32
990
17
"""Juju Quickstart utility functions and classes."""
33
"""Juju Quickstart utility functions and classes."""
991
18
34
992
19
from __future__ import (
35
from __future__ import (
993
@@ -187,6 +203,23 @@
994
187
    return output.strip()
203
    return output.strip()
995
188
204
996
189
205
997
206
class ObjectDict(dict):
998
207
    """Makes a dictionary behave like an object, with attribute-style access.
999
208
1000
209
    Original:
1001
210
    http://www.tornadoweb.org/en/stable/_modules/tornado/util.html#ObjectDict
1002
211
    """
1003
212
1004
213
    def __getattr__(self, name):
1005
214
        try:
1006
215
            return self[name]
1007
216
        except KeyError:
1008
217
            raise AttributeError(name)
1009
218
1010
219
    def __setattr__(self, name, value):
1011
220
        self[name] = value
1012
221
1013
222
1014
190
def parse_bundle(bundle_yaml, bundle_name=None):
223
def parse_bundle(bundle_yaml, bundle_name=None):
1015
191
    """Parse the provided bundle YAML encoded contents.
224
    """Parse the provided bundle YAML encoded contents.
1016
192
225
1017
193
226
1018
=== modified file 'requirements.pip'
1019
--- requirements.pip	2013-11-14 10:37:29 +0000
1020
+++ requirements.pip	2013-12-17 15:23:53 +0000
1021
@@ -23,3 +23,4 @@
1022
23
23
1023
24
jujuclient==0.11
24
jujuclient==0.11
1024
25
PyYAML==3.10
25
PyYAML==3.10
1025
26
urwid==1.1.1
Status:	Merged
Merged at revision:	35
Proposed branch:	lp:~frankban/juju-quickstart/env-manage-base-views
Merge into:	lp:juju-quickstart
Diff against target:	1025 lines (+930/-1) 13 files modified cli-app-demo.py (+52/-0) quickstart/cli/__init__.py (+33/-0) quickstart/cli/base.py (+155/-0) quickstart/cli/ui.py (+118/-0) quickstart/cli/views.py (+119/-0) quickstart/models/envs.py (+2/-1) quickstart/tests/cli/__init__.py (+15/-0) quickstart/tests/cli/test_base.py (+174/-0) quickstart/tests/cli/test_ui.py (+117/-0) quickstart/tests/cli/test_views.py (+86/-0) quickstart/tests/test_utils.py (+25/-0) quickstart/utils.py (+33/-0) requirements.pip (+1/-0)
To merge this branch:	bzr merge lp:~frankban/juju-quickstart/env-manage-base-views
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Juju GUI Hackers		2013-12-17	Pending
Review via email: mp+199254@code.launchpad.net