def test_wraps_prereq_without_clobbering_name(self):
wiz = wizard.Wizard('test:test3', self.steps)
wiz.steps = dict(self.steps)
wiz._current_step = 'fourth'
self.assertEqual('prereq', wiz.current_step_object.prereq.__name__)
def on_item_login_activate(self, item, data=None):
if self.notification.window.get_property("visible"):
self.notification.window.hide()
for k in self.notification.comments:
self.notification.comments[k].window.hide()
self.wizard = wizard.Wizard()
self.wizard.assistant.connect("apply", self.wizard_finish, None)
def __init__(self):
self.status_icon = None
self.activate_id = None
self.popup_id = None
bus = dbus.SessionBus()
obj = bus.get_object ("org.wallbox.PostOfficeService", \
"/org/wallbox/PostOfficeObject")
self.office = dbus.Interface \
(obj, "org.wallbox.PostOfficeInterface")
self.builder = gtk.Builder()
ui_file = "%s/wallbox.ui" % defs.WALLBOX_DATA_DIR
self.builder.add_from_file(ui_file)
self.menu = self.builder.get_object("menu")
self.about = self.builder.get_object("aboutdialog")
self.setting = self.builder.get_object("dialog_setting")
self.builder.connect_signals(self, None)
status = self.office.get_office_status()
if status == defs.NO_LOGIN:
self.wizard = wizard.Wizard()
self.wizard.assistant.connect("apply", self.wizard_finish, None)
else:
self.setup_configuration()
self.make_ui()
def test_does_not_send_post_save_signal_in_post_on_save_step_exception(
self, send_postsave):
wiz = wizard.Wizard('test:test3', self.steps)
wiz.set_redirect_args(1234, 'asdf')
self.mock_request.method = 'POST'
self.mock_request.POST = {}
wiz.handle_request(self.mock_request, 'first')
self.assertFalse(send_postsave.called)
def test_get_steps_returns_step_key_and_instantiated_steps(self):
wiz = wizard.Wizard('test:test3', self.steps)
wiz.initialize_steps()
zipped_steps = zip(self.steps, wiz.get_steps())
for declared_steps, instantiated_steps in zipped_steps:
self.assertEqual(declared_steps[0], instantiated_steps[0])
self.assertIsInstance(instantiated_steps[1], declared_steps[1])
def test_current_step_instance_returns_step_by_key(self, get_step):
step_key = "One"
my_wizard = wizard.Wizard('test:test2', self.steps)
my_wizard._current_step = step_key
self.assertEqual(get_step.return_value, my_wizard.current_step_object)
get_step.assert_called_once_with(step_key)
def test_sends_pre_prereq_signal_in_prereq(self, send_pre_prereq):
wiz = wizard.Wizard('test:test3', self.steps)
wiz.request = self.mock_request
wiz.steps = dict(self.steps)
wiz._current_step = 'fourth'
wiz.current_step_object.prereq()
send_pre_prereq.assert_called_once_with(wiz,
step_key='fourth',
request=self.mock_request)
def test_should_set_wizard_instance_on_step_instance(self):
step_key = 'fifth'
my_wizard = wizard.Wizard('test:test2', self.steps)
my_wizard.set_step_init_args('asdf', 9999, abc=123, xyz=987)
my_wizard.handle_request(self.mock_request, step_key)
step = my_wizard.steps[step_key]
self.assertEqual(my_wizard, step._wizard)
def test_sends_post_save_signal_in_post(self, send_postsave):
wiz = wizard.Wizard('test:test3', self.steps)
wiz.set_redirect_args(1234, 'asdf')
self.mock_request.method = 'POST'
self.mock_request.POST = {}
wiz.handle_request(self.mock_request, 'first')
send_postsave.assert_called_once_with(wiz,
step_key='first',
request=self.mock_request)
def test_prereq_exceptions_are_not_caught_when_raised_by_pre_prereq_signal(
self, send_pre_prereq):
send_pre_prereq.side_effect = wizard.PrereqMissing
wiz = wizard.Wizard('test:test3', self.steps)
wiz.steps = dict(self.steps)
wiz._current_step = 'fourth'
with self.assertRaises(wizard.PrereqMissing):
wiz.current_step_object.prereq()
def test_should_set_current_step_on_instance(self):
current_step = 'fifth'
my_wizard = wizard.Wizard('test:test2', self.steps)
my_wizard._current_step = current_step
my_wizard.set_step_init_args('asdf', 9999, abc=123, xyz=987)
my_wizard.handle_request(self.mock_request, current_step)
self.assertEqual(current_step,
my_wizard.steps[current_step]._current_step)
def test_should_allow_url_args_to_be_passed_positionally(self):
"""
the wizard should also automatically add a step as the last positional argument as well as accepting the
step as a keyword argument
"""
self.mock_request.method = 'POST'
wiz = wizard.Wizard('test:test3', self.steps)
wiz.set_redirect_args(1234, 'asdf')
response = wiz.handle_request(self.mock_request, 'first')
self.assertEqual(response['Location'], '/test/1234/asdf/first')
def test_should_still_send_pre_preq_signal_even_if_prereq_raises_exception(
self, send_pre_prereq, mock_prereq):
mock_prereq.side_effect = wizard.PrereqMissing
wiz = wizard.Wizard('test:test3', self.steps)
wiz.steps = dict(self.steps)
wiz._current_step = 'fourth'
with self.assertRaises(wizard.PrereqMissing):
wiz.current_step_object.prereq()
self.assertTrue(send_pre_prereq.called)
def test_should_allow_url_args_and_kwargs_to_be_passed_through_on_redirects(
self):
"""
if you're capturing arguments or keyword arguments in your url patterns (besides 'step' used by the wizard)
then you should be able to pass thouse through to the wizard when it does the url lookups
"""
self.mock_request.method = 'POST'
my_wizard = wizard.Wizard('test:test2', self.steps)
my_wizard.set_redirect_args(asdf=1234)
response = my_wizard.handle_request(self.mock_request, 'first')
self.assertEqual(response['Location'], '/test/1234/first')
def test_should_be_able_to_get_any_step_by_request_in_any_order(self):
"""
This test should mimic doing a GET on a url ending in each of
the step_number's listed below where X is the step_number
http://localhost/wizard/X/
"""
wiz = wizard.Wizard('test:test1', self.steps)
wiz.set_step_init_args(self.mock_request)
for step in ['fourth', 'third', 'first', 'fifth', 'second']:
response = wiz.handle_request(self.mock_request, step)
self.assertEqual(200, response.status_code)
def test_does_not_send_post_prereq_signal_when_prereq_raises_exception(
self, send_post_prereq, mock_prereq):
mock_prereq.side_effect = wizard.PrereqMissing
wiz = wizard.Wizard('test:test3', self.steps)
wiz.steps = dict(self.steps)
wiz._current_step = 'fourth'
with self.assertRaises(wizard.PrereqMissing):
wiz.current_step_object.prereq()
self.assertFalse(send_post_prereq.called)
def test_prereq_calls_original_prereq_defined_on_step(self):
wiz = wizard.Wizard('test:test3', self.steps)
wiz.steps = dict(self.steps)
wiz._current_step = 'fourth'
with mock.patch.object(TestStepFour, 'prereq',
mocksignature=True) as original_prereq:
wiz.current_step_object.prereq()
original_prereq.assert_called_once_with(wiz.current_step_object)
def add_player(self, id):
'''
(int) -> Wizard
Creates player in core list with passed id. Creates Wizard for
this player and returns this wizard instance.
'''
new_player = players.Player(id)
self.players.append(new_player)
new_wiz = wizard.Wizard(new_player)
self.wizards.append(new_wiz)
return new_wiz
def test_should_pass_args_and_kwargs_on_to_steps(self):
"""
make sure that when the wizard intantiates a step that it passes the corrects args and kwargs to
the constructor
"""
my_wizard = wizard.Wizard('test:test2', self.steps)
my_wizard.set_step_init_args('asdf', 9999, abc=123, xyz=987)
my_wizard.handle_request(self.mock_request, 'fifth')
self.assertEqual(('asdf', 9999), my_wizard.steps['fifth'].args)
self.assertEqual({
'abc': 123,
'xyz': 987
}, my_wizard.steps['fifth'].kwargs)
def test_allows_navigation_to_be_overwritten_for_not_advancing_form(self):
"""
the wizard should allow you to "continue" to the next step
"""
self.mock_request.method = 'POST'
self.mock_request.POST = {'remain': 'VVVVDSFSDFSDF SDF SDF SDF'}
my_wizard = wizard.Wizard('test:test1', self.steps, {
'next': 1,
'remain': 0
})
my_wizard.set_step_init_args(self.mock_request)
response = my_wizard.handle_request(self.mock_request)
self.assertEqual(302, response.status_code)
self.assertEqual(response['Location'], '/test/first')
def get(self, **kw):
params, data = TinyDict.split(kw)
params.ids = None
source = (params.source or '') and str(params.source)
params.view_type = 'form'
if source == '_terp_list':
params.view_type = 'tree'
if params.search_domain:
params.domain += params.search_domain
# default_get context
current = params.chain_get(source)
if current and params.source_default_get:
current.context = current.context or {}
current.context.update(params.source_default_get)
if params.wiz_id:
res = wizard.Wizard().execute(params)
frm = res['form']
else:
frm = form.Form().create_form(params)
wid = frm.screen.get_widgets_by_name(source, kind=tw.listgrid.List)[0]
ids = wid.ids
count = wid.count
if params.edit_inline:
wid.edit_inline = params.edit_inline
info = {}
if params.concurrency_info:
for m, v in getattr(cherrypy.request, 'terp_concurrency_info',
{}).items():
for i, d in v.items():
info['%s,%s' % (m, i)] = d
return dict(ids=ids, count=count, view=ustr(wid.render()), info=info)
def setUp(self):
"""
build some 'fake' wizard steps (wrapped by a proxy in order to moniter what they're doing)
as well as a 'fake' wizard also proxied
"""
self.steps = [
('first', TestStepOne),
('second', TestStepTwo),
('third', TestStepThree),
('fourth', TestStepFour),
('fifth', TestStepFive),
]
self.wizard = wizard.Wizard('test:test1', self.steps)
self.mock_request = mock.MagicMock()
self.mock_request.method = 'GET'
self.wizard.set_step_init_args(self.mock_request)
self._signals = {}
for attr_name in dir(wizard.signals):
attr = getattr(wizard.signals, attr_name)
if isinstance(attr, Signal):
self._signals[attr_name] = copy.copy(attr.receivers)
attr.receivers = []
def get(self, **kw):
params, data = TinyDict.split(kw)
groupby = params.get('_terp_group_by_ctx')
if groupby and isinstance(groupby, basestring):
groupby = groupby.split(',')
if params.get('_terp_filters_context'):
if isinstance(params.filters_context, (list, tuple)):
for filter_ctx in params.filters_context:
params.context.update(filter_ctx)
else:
params.context.update(params.filters_context)
params['_terp_group_by_ctx'] = groupby
if not params.search_text:
params.ids = None
source = (params.source or '') and str(params.source)
if not params.view_type == 'graph':
params.view_type = 'form'
if params.view_type == 'form':
params['_terp_nodefault'] = True
if params.get('_terp_clear'):
params.search_domain, params.filter_domain, params.ids = [], [], []
params.search_data = {}
for k, v in params.context.items():
if k.startswith('search_default'):
del params.context[k]
if 'group_by' in params.context:
del params.context['group_by']
params.group_by_ctx = []
if source == '_terp_list':
if not params.view_type == 'graph':
params.view_type = 'tree'
if params.search_domain:
params.domain += params.search_domain
params.domain = params.domain or []
if params.filter_domain:
params.domain += params.filter_domain
# default_get context
current = params.chain_get(source)
if current and params.source_default_get:
current.context = current.context or {}
current.context.update(params.source_default_get)
if params.wiz_id:
res = wizard.Wizard().execute(params)
frm = res['form']
else:
frm = form.Form().create_form(params)
if params.view_type == 'graph':
wid = frm.screen.widget
else:
wid = frm.screen.get_widgets_by_name(source, kind=listgrid.List)[0]
ids = wid.ids
count = wid.count
if params.edit_inline:
wid.edit_inline = params.edit_inline
if params.get('_terp_clear'):
view = ustr(frm.render())
else:
view = ustr(wid.render())
server_logs = ''
if frm.logs and frm.screen.view_type == 'tree':
server_logs = ustr(frm.logs.render())
concurrency_info = getattr(cherrypy.request, 'terp_concurrency_info',
None)
return dict(ids=ids,
count=count,
view=view,
logs=server_logs,
concurrency_info=concurrency_info)
import wizard
w = wizard.Wizard('../glade/gui.glade')
w.add_tab('welcome')
w.add_tab('root_pass')
w.add_tab('parts')
w.add_tab('finish')
import pprint
try:
pprint.pprint(w.show_and_run())
except wizard.WizardCancel:
print 'Asistente cancelado'
def test_request_is_set_after_handle_request(self):
wiz = wizard.Wizard('test:test3', self.steps)
request = mock.Mock()
wiz.handle_request(request, 'first')
self.assertEqual(request, wiz.request)
def test_request_is_none_before_handle_request(self):
wiz = wizard.Wizard('test:test3', self.steps)
self.assertEqual(None, wiz.request)
def test_should_return_previous_step_url(self):
wiz = wizard.Wizard('test:test3', self.steps)
wiz.set_redirect_args(1234, 'asdf')
wiz.handle_request(self.mock_request, 'second')
self.assertEqual(wiz.prev_step_url(), '/test/1234/asdf/first')
def test_should_skip_steps_with_missing_prereqs_when_moving_forward(self):
self.steps[1] = ('second', get_class_with_missing_prereq('first'))
wiz = wizard.Wizard('test:test3', self.steps)
wiz.set_redirect_args(1234, 'asdf')
wiz.handle_request(self.mock_request, 'first')
self.assertEqual(wiz.next_step_url(), '/test/1234/asdf/third')
def test_sends_post_display_signal_in_do_display(self, send_postdisplay):
wiz = wizard.Wizard('test:test3', self.steps)
wiz.handle_request(self.mock_request, 'first')
send_postdisplay.assert_called_once_with(wiz,
step_key='first',
request=self.mock_request)
def test_should_return_none_when_next_step_has_not_changed(self):
wiz = wizard.Wizard('test:test3', self.steps)
wiz.set_redirect_args(1234, 'asdf')
wiz.handle_request(self.mock_request, 'fifth')
self.assertEqual(wiz.next_step_url(), None)
