def test_handle_response__action__is_ran(self, renderer, controller):
response = mock.Mock()
response.event = KeywordQueryEvent(Query('test'))
renderer.active_event = response.event
renderer.active_controller = controller
renderer.handle_response(response, controller)
response.action.run.assert_called_once_with()
def test_is_enabled__controller_is_running__returns_true(self, extServer):
controller = mock.create_autospec(ExtensionController)
extServer.get_controller_by_keyword.return_value = controller
mode = ExtensionSearchMode()
query = Query('kw something')
assert mode.is_enabled(query), 'Mode is not enabled'
def test_is_enabled__keyword__is_used_to_get_controller(self, extServer):
controller = mock.create_autospec(ExtensionController)
extServer.get_controller_by_keyword.return_value = controller
mode = ExtensionSearchMode()
query = Query('kw something')
mode.is_enabled(query)
extServer.get_controller_by_keyword.assert_called_with('kw')
def test_on_enter__run_without_arguments(self, item, ActionList,
OpenUrlAction,
SetUserQueryAction):
item.run_without_argument = True
assert item.on_enter(Query('kw')) is ActionList.return_value
# it doesn't replace %s if run_without_argument = True
OpenUrlAction.assert_called_once_with('http://site/?q=%s')
assert not SetUserQueryAction.called
def test_handle_query__handle_query__is_called(self, controller,
result_renderer):
query = Query('def ulauncher')
controller.extension_id = 'test_extension'
controller.manifest = mock.Mock()
assert controller.handle_query(
query) == result_renderer.handle_event.return_value
result_renderer.handle_event.assert_called_with(mock.ANY, controller)
def xtest_is_enabled__query_only_contains_keyword__returns_false(
self, extServer):
controller = mock.create_autospec(ExtensionController)
extServer.get_controller_by_keyword.return_value = controller
mode = ExtensionSearchMode()
query = Query('kw')
assert not mode.is_enabled(query), 'Mode is enabled'
def test_handle_query__KeywordQueryEvent__is_sent_with_query(
self, controller):
query = Query('def ulauncher')
controller.handle_query(query)
keywordEvent = pickle.loads(
controller.sendMessage.call_args_list[0][0][0])
assert isinstance(keywordEvent, KeywordQueryEvent)
assert keywordEvent.get_query() == 'def ulauncher'
def test_on_enter(self, item, mocker, app_queries, app_stat_db):
LaunchAppAction = mocker.patch(
'ulauncher.search.apps.AppResultItem.LaunchAppAction')
assert item.on_enter(Query('query')) is LaunchAppAction.return_value
LaunchAppAction.assert_called_with('path/to/desktop_file.desktop')
app_queries.put.assert_called_with('query', 'TestAppResultItem')
app_queries.commit.assert_called_with()
app_stat_db.inc_count.assert_called_with(
'path/to/desktop_file.desktop')
def test_handle_response__keep_app_open_is_False__hide_is_called(
self, renderer, controller, GLib, mocker):
UlauncherWindow = mocker.patch(
'ulauncher.ui.windows.UlauncherWindow.UlauncherWindow')
response = mock.Mock()
response.event = KeywordQueryEvent(Query('test'))
response.action.keep_app_open.return_value = False
renderer.active_event = response.event
renderer.active_controller = controller
renderer.handle_response(response, controller)
GLib.idle_add.assert_called_with(
UlauncherWindow.get_instance.return_value.hide_and_clear_input)
def get_name_highlighted(self, query: Query, color: str) -> Optional[str]:
"""
:param ~ulauncher.search.Query.Query query:
:param str color:
:rtype: str
"""
if query and self._highlightable:
return highlight_text(
query if not self._is_extension else query.get_argument(''),
self.get_name(),
open_tag='<span foreground="%s">' % color,
close_tag='</span>')
# don't highlight if query is empty
return self.get_name()
def test_on_enter(self, item, mocker, ActionList, OpenUrlAction,
SetUserQueryAction):
assert item.on_enter(Query('kw test')) is ActionList.return_value
OpenUrlAction.assert_called_once_with('http://site/?q=test')
assert not SetUserQueryAction.called
def test_get_description(self, item):
assert item.get_description(Query('kw test')) == 'http://site/?q=test'
assert item.get_description(
Query('keyword test')) == 'http://site/?q=...'
assert item.get_description(Query('goo')) == 'http://site/?q=...'
class ResultItemWidget(Gtk.EventBox):
__gtype_name__ = "ResultItemWidget"
shortcut = '' # type: str
index = 0 # type: int
builder = None # type: Any
name = '' # type: str
query = Query('') # type: Query
item_object = None # type: Any
item_box = None # type: Any
def initialize(self, builder: Any, item_object: Any, index: int,
query: Query) -> None:
self.builder = builder
item_frame = self.builder.get_object('item-frame')
item_frame.connect("button-release-event", self.on_click)
item_frame.connect("enter_notify_event", self.on_mouse_hover)
self.item_box = builder.get_object('item-box')
self.item_object = item_object
self.query = query
self.set_index(index)
self.set_icon(item_object.get_icon())
self.set_description(item_object.get_description(query))
self.set_name_highlighted()
def set_index(self, index):
"""
Set index for the item and assign shortcut
"""
self.index = index
# Alt+1..9, then Alt+a..z
index_text = index + 1 if index < 9 else chr(97 + index - 9)
self.shortcut = 'Alt+%s' % index_text
self.set_shortcut(self.shortcut)
def select(self):
self.set_name_highlighted(True)
self.item_box.get_style_context().add_class('selected')
def deselect(self):
self.set_name_highlighted(False)
self.item_box.get_style_context().remove_class('selected')
def set_icon(self, icon):
"""
:param PixBuf icon:
"""
if not icon:
return
iconWgt = self.builder.get_object('item-icon')
scale_factor = get_monitor_scale_factor()
if scale_factor == 1:
iconWgt.set_from_pixbuf(icon)
return
try:
surface = Gdk.cairo_surface_create_from_pixbuf(
icon, scale_factor, self.get_window())
iconWgt.set_from_surface(surface)
except AttributeError: # Fallback for GTK+ older than 3.10
iconWgt.set_from_pixbuf(icon)
def set_name_highlighted(self, is_selected: bool = False) -> None:
colors = Theme.get_current().get_matched_text_hl_colors()
color = colors['when_selected'] if is_selected else colors[
'when_not_selected']
self.set_name(
self.item_object.get_name_highlighted(self.query, color)
or self.item_object.get_name())
# pylint: disable=arguments-differ
def set_name(self, name: str) -> None:
item = self.builder.get_object('item-name')
if '<span' in name: # dealing with markup
item.set_markup(name)
else:
item.set_text(name)
self.name = name
def get_name(self):
return self.name
# pylint: disable=unused-argument
def on_click(self, widget, event=None):
self.get_toplevel().select_result_item(self.index)
alt_enter = bool(event and event.button != 1)
self.get_toplevel().enter_result_item(alt=alt_enter)
def on_mouse_hover(self, widget, event):
self.get_toplevel().select_result_item(self.index, onHover=True)
def set_description(self, description):
description_obj = self.builder.get_object('item-descr')
if not description_obj:
return
if description:
description_obj.set_text(description)
else:
description_obj.destroy() # remove description label
self.builder.get_object('item-name').set_margin_top(
8) # shift name label down to the center
def set_shortcut(self, text):
self.builder.get_object('item-shortcut').set_text(text)
def on_enter(self, query):
return self.item_object.on_enter(query)
def on_alt_enter(self, query):
return self.item_object.on_alt_enter(query)
def get_keyword(self):
return self.item_object.get_keyword()
def selected_by_default(self, query):
return self.item_object.selected_by_default(query)
def test_get_argument(self):
assert Query('kw arg text').get_argument() == 'arg text'
assert not Query('kw').get_argument()
assert not Query('').get_argument()
def test_on_enter__run_file(self, ActionList, RunScriptAction):
item = ShortcutResultItem('kw', 'name', '/usr/bin/something',
'icon_path')
assert item.on_enter(Query('kw query')) is ActionList.return_value
RunScriptAction.assert_called_once_with('/usr/bin/something', 'query')
def test_is_mode_active(self):
assert not Query('kw').is_mode_active()
assert Query('kw ').is_mode_active()
assert Query('kw arg').is_mode_active()
def test_get_description(self, item):
assert item.get_description(
Query('q')) == 'Description of TestAppResultItem'
def _get_user_query(self):
# get_text() returns str, so we need to convert it to unicode
return Query(force_unicode(self.input.get_text()))
def test_on_enter__default_search(self, item, mocker, ActionList,
OpenUrlAction, SetUserQueryAction):
item.is_default_search = True
assert item.on_enter(Query('search query')) is ActionList.return_value
OpenUrlAction.assert_called_once_with('http://site/?q=search query')
assert not SetUserQueryAction.called
def query(self, query: str):
query = Query("ti " + query)
query_event = KeywordQueryEvent(query)
self.timer.trigger_event(query_event)
results = self.client.response.action.result_list
return [ResultItem(item, query, self) for item in results]
def test_on_enter__misspelled_kw(self, item, mocker, ActionList,
OpenUrlAction, SetUserQueryAction):
assert item.on_enter(Query('keyword query')) is ActionList.return_value
assert not OpenUrlAction.called
SetUserQueryAction.assert_called_once_with('kw ')
def test_get_keyword(self):
assert Query('kw arg').get_keyword() == 'kw'
assert Query('kw').get_keyword() == 'kw'
assert not Query('').get_keyword()
def _get_user_query(self):
return Query(self.input.get_text())
def test_on_enter__save_query_to_history(self, item, query_history):
item.on_enter(Query('my-query'))
query_history.save_query.assert_called_once_with('my-query', 'name')
