def test_subcatview_recommended_for_you_display_recommendations(self, mock_query):
# patch the recommender UUID value to insure that we are not opted-in for this test
get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
self.addCleanup(get_recommender_opted_in_patcher.stop)
mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
mock_get_recommender_opted_in.return_value = False
from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
# get the widgets we need
win = get_test_window_catview()
lobby = win.get_data("lobby")
rec_panel = lobby.recommended_for_you_panel
self._p()
# click the opt-in button to initiate the process, this will show the spinner
rec_panel.opt_in_button.emit('clicked')
self._p()
rec_panel._update_recommended_for_you_content()
self._p()
# we fake the callback from the agent here
lobby.recommended_for_you_panel.recommended_for_you_cat._recommend_me_result(
None,
make_recommender_agent_recommend_me_dict())
self.assertNotEqual(
lobby.recommended_for_you_panel.recommended_for_you_cat.get_documents(self.db), [])
from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
self.assertTrue(rec_panel.spinner_notebook.get_current_page() == SpinnerNotebook.CONTENT_PAGE)
self._p()
# test clicking recommended_for_you More button
lobby.connect("category-selected", self._on_category_selected)
lobby.recommended_for_you_panel.more.clicked()
self._p()
self.assertNotEqual(self._cat, None)
self.assertEqual(self._cat.name, "Recommended For You")
win.destroy()
def test_recommended_for_you_display_recommendations(
self, mock_query, mock_get_recommender_opted_in):
# patch the recommender UUID value to insure that we are not opted-in
# for this test
mock_get_recommender_opted_in.return_value = False
# click the opt-in button to initiate the process,
# this will show the spinner
self.rec_panel.opt_in_button.emit('clicked')
do_events()
self.rec_panel._update_recommended_for_you_content()
do_events()
# we fake the callback from the agent here
for_you = self.lobby.recommended_for_you_panel.recommended_for_you_cat
for_you._recommend_me_result(
None, make_recommender_agent_recommend_me_dict())
self.assertNotEqual(for_you.get_documents(self.db), [])
self.assertEqual(self.rec_panel.spinner_notebook.get_current_page(),
SpinnerNotebook.CONTENT_PAGE)
do_events()
# test clicking recommended_for_you More button
self.lobby.connect("category-selected", self._on_category_selected)
self.lobby.recommended_for_you_panel.more.clicked()
# this is delayed for some reason so we need to sleep here
do_events_with_sleep()
self.assertNotEqual(self._cat, None)
self.assertEqual(self._cat.name, "Recommended For You")
def test_recommended_for_you_display_recommendations(self,
mock_query, mock_get_recommender_opted_in):
# patch the recommender UUID value to insure that we are not opted-in
# for this test
mock_get_recommender_opted_in.return_value = False
# click the opt-in button to initiate the process,
# this will show the spinner
self.rec_panel.opt_in_button.emit('clicked')
do_events()
self.rec_panel._update_recommended_for_you_content()
do_events()
# we fake the callback from the agent here
for_you = self.lobby.recommended_for_you_panel.recommended_for_you_cat
for_you._recommend_me_result(None,
make_recommender_agent_recommend_me_dict())
self.assertNotEqual(for_you.get_documents(self.db), [])
self.assertEqual(self.rec_panel.spinner_notebook.get_current_page(),
SpinnerNotebook.CONTENT_PAGE)
do_events()
# test clicking recommended_for_you More button
self.lobby.connect("category-selected", self._on_category_selected)
self.lobby.recommended_for_you_panel.more.clicked()
# this is delayed for some reason so we need to sleep here
do_events_with_sleep()
self.assertNotEqual(self._cat, None)
self.assertEqual(self._cat.name, "Recommended For You")
def test_recommended_for_you_display_recommendations_opted_in(self, mock_query, mock_get_recommender_opted_in):
# patch the recommender UUID value to insure that we are not opted-in
# for this test
mock_get_recommender_opted_in.return_value = True
# we want to work in the "subcat" view
self.notebook.next_page()
rec_cat_panel = self.subcat_view.recommended_for_you_in_cat
rec_cat_panel._update_recommended_for_you_content()
do_events()
# we fake the callback from the agent here
rec_cat_panel.recommended_for_you_cat._recommend_me_result(None, make_recommender_agent_recommend_me_dict())
result_docs = rec_cat_panel.recommended_for_you_cat.get_documents(self.db)
self.assertNotEqual(result_docs, [])
# check that we are getting the correct number of results,
# corresponding to the following Internet items:
# Mangler, Midori, Midori Private Browsing, Psi
self.assertTrue(len(result_docs) == 4)
self.assertEqual(rec_cat_panel.spinner_notebook.get_current_page(), SpinnerNotebook.CONTENT_PAGE)
# check that the tiles themselves are visible
do_events()
self.assertTrue(rec_cat_panel.recommended_for_you_content.get_property("visible"))
self.assertTrue(rec_cat_panel.recommended_for_you_content.get_children()[0].title.get_property("visible"))
do_events()
# test clicking recommended_for_you More button
self.subcat_view.connect("category-selected", self._on_category_selected)
rec_cat_panel.more.clicked()
# this is delayed for some reason so we need to sleep here
do_events_with_sleep()
self.assertNotEqual(self._cat, None)
self.assertEqual(self._cat.name, "Recommended For You in Internet")
def test_recommends_category(self, AgentMockCls):
# ensure we use the same instance in test and code
agent_mock_instance = AgentMockCls.return_value
recommends_cat = RecommendedForYouCategory()
docids = recommends_cat.get_documents(self.db)
self.assertEqual(docids, [])
self.assertTrue(agent_mock_instance.query_recommend_me.called)
# ensure we get a query when the callback is called
recommends_cat._recommend_me_result(
None, make_recommender_agent_recommend_me_dict())
self.assertNotEqual(recommends_cat.get_documents(self.db), [])
def test_recommends_category(self, AgentMockCls):
# ensure we use the same instance in test and code
agent_mock_instance = AgentMockCls.return_value
recommends_cat = RecommendedForYouCategory()
docids = recommends_cat.get_documents(self.db)
self.assertEqual(docids, [])
self.assertTrue(agent_mock_instance.query_recommend_me.called)
# ensure we get a query when the callback is called
recommends_cat._recommend_me_result(
None,
make_recommender_agent_recommend_me_dict())
self.assertNotEqual(recommends_cat.get_documents(self.db), [])
def test_recommends_in_category_category(self, AgentMockCls):
# ensure we use the same instance in test and code
parser = CategoriesParser(self.db)
cats = parser.parse_applications_menu("./data")
# "2" is a multimedia query
# see ./test/data/desktop/software-center.menu
recommends_cat = RecommendedForYouCategory(cats[2])
# ensure we get a query when the callback is called
recommends_cat._recommend_me_result(
None, make_recommender_agent_recommend_me_dict())
recommendations_in_cat = recommends_cat.get_documents(self.db)
print recommendations_in_cat
self.assertNotEqual(recommendations_in_cat, [])
def test_subcatview_recommended_for_you_display_recommendations_opted_in(
self, mock_query):
# patch the recommender UUID value to insure that we are not opted-in for this test
get_recommender_opted_in_patcher = patch(
'softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
self.addCleanup(get_recommender_opted_in_patcher.stop)
mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start(
)
mock_get_recommender_opted_in.return_value = True
from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
# get the widgets we need
win = get_test_window_catview()
# we want to work in the "subcat" view
notebook = win.get_child()
notebook.next_page()
subcat_view = win.get_data("subcat")
rec_cat_panel = subcat_view.recommended_for_you_in_cat
self._p()
rec_cat_panel._update_recommended_for_you_content()
self._p()
# we fake the callback from the agent here
rec_cat_panel.recommended_for_you_cat._recommend_me_result(
None, make_recommender_agent_recommend_me_dict())
result_docs = rec_cat_panel.recommended_for_you_cat.get_documents(
self.db)
self.assertNotEqual(result_docs, [])
# check that we are getting the correct number of results, corresponding
# to the following Internet items:
# Mangler, Midori, Midori Private Browsing, Psi
self.assertTrue(len(result_docs) == 4)
from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
self.assertTrue(rec_cat_panel.spinner_notebook.get_current_page() ==
SpinnerNotebook.CONTENT_PAGE)
# check that the tiles themselves are visible
self._p()
self.assertTrue(
rec_cat_panel.recommended_for_you_content.get_property("visible"))
self.assertTrue(
rec_cat_panel.recommended_for_you_content.get_children()
[0].title.get_property("visible"))
self._p()
# test clicking recommended_for_you More button
subcat_view.connect("category-selected", self._on_category_selected)
rec_cat_panel.more.clicked()
self._p()
self.assertNotEqual(self._cat, None)
self.assertEqual(self._cat.name, "Recommended For You in Internet")
win.destroy()
def test_recommends_in_category_category(self, AgentMockCls):
# ensure we use the same instance in test and code
parser = CategoriesParser(self.db)
cats = parser.parse_applications_menu("./data")
# "2" is a multimedia query
# see ./test/data/desktop/software-center.menu
recommends_cat = RecommendedForYouCategory(cats[2])
# ensure we get a query when the callback is called
recommends_cat._recommend_me_result(
None,
make_recommender_agent_recommend_me_dict())
recommendations_in_cat = recommends_cat.get_documents(self.db)
print recommendations_in_cat
self.assertNotEqual(recommendations_in_cat, [])
def test_subcatview_recommended_for_you_display_recommendations_opted_in(self, mock_query):
# patch the recommender UUID value to insure that we are not opted-in for this test
get_recommender_opted_in_patcher = patch('softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
self.addCleanup(get_recommender_opted_in_patcher.stop)
mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start()
mock_get_recommender_opted_in.return_value = True
from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
# get the widgets we need
win = get_test_window_catview()
# we want to work in the "subcat" view
notebook = win.get_child()
notebook.next_page()
subcat_view = win.get_data("subcat")
rec_cat_panel = subcat_view.recommended_for_you_in_cat
self._p()
rec_cat_panel._update_recommended_for_you_content()
self._p()
# we fake the callback from the agent here
rec_cat_panel.recommended_for_you_cat._recommend_me_result(
None,
make_recommender_agent_recommend_me_dict())
result_docs = rec_cat_panel.recommended_for_you_cat.get_documents(self.db)
self.assertNotEqual(result_docs, [])
# check that we are getting the correct number of results, corresponding
# to the following Internet items:
# Mangler, Midori, Midori Private Browsing, Psi
self.assertTrue(len(result_docs) == 4)
from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
self.assertTrue(rec_cat_panel.spinner_notebook.get_current_page() == SpinnerNotebook.CONTENT_PAGE)
# check that the tiles themselves are visible
self._p()
self.assertTrue(rec_cat_panel.recommended_for_you_content.get_property("visible"))
self.assertTrue(rec_cat_panel.recommended_for_you_content.get_children()[0].title.get_property("visible"))
self._p()
# test clicking recommended_for_you More button
subcat_view.connect("category-selected", self._on_category_selected)
rec_cat_panel.more.clicked()
self._p()
self.assertNotEqual(self._cat, None)
self.assertEqual(self._cat.name, "Recommended For You in Internet")
win.destroy()
def test_recommended_for_you_display_recommendations_opted_in(
self, mock_query, mock_get_recommender_opted_in):
# patch the recommender UUID value to insure that we are not opted-in
# for this test
mock_get_recommender_opted_in.return_value = True
# we want to work in the "subcat" view
self.notebook.next_page()
rec_cat_panel = self.subcat_view.recommended_for_you_in_cat
rec_cat_panel._update_recommended_for_you_content()
do_events()
# we fake the callback from the agent here
rec_cat_panel.recommended_for_you_cat._recommend_me_result(
None, make_recommender_agent_recommend_me_dict())
result_docs = rec_cat_panel.recommended_for_you_cat.get_documents(
self.db)
self.assertNotEqual(result_docs, [])
# check that we are getting the correct number of results,
# corresponding to the following Internet items:
# Mangler, Midori, Midori Private Browsing, Psi
self.assertTrue(len(result_docs) == 4)
self.assertEqual(rec_cat_panel.spinner_notebook.get_current_page(),
SpinnerNotebook.CONTENT_PAGE)
# check that the tiles themselves are visible
do_events()
self.assertTrue(
rec_cat_panel.recommended_for_you_content.get_property("visible"))
self.assertTrue(
rec_cat_panel.recommended_for_you_content.get_children()
[0].title.get_property("visible"))
do_events()
# test clicking recommended_for_you More button
self.subcat_view.connect("category-selected",
self._on_category_selected)
rec_cat_panel.more.clicked()
# this is delayed for some reason so we need to sleep here
do_events_with_sleep()
self.assertNotEqual(self._cat, None)
self.assertEqual(self._cat.name, "Recommended For You in Internet")
def test_subcatview_recommended_for_you_display_recommendations(
self, mock_query):
# patch the recommender UUID value to insure that we are not opted-in for this test
get_recommender_opted_in_patcher = patch(
'softwarecenter.backend.recagent.RecommenderAgent.is_opted_in')
self.addCleanup(get_recommender_opted_in_patcher.stop)
mock_get_recommender_opted_in = get_recommender_opted_in_patcher.start(
)
mock_get_recommender_opted_in.return_value = False
from softwarecenter.ui.gtk3.views.catview_gtk import get_test_window_catview
# get the widgets we need
win = get_test_window_catview()
lobby = win.get_data("lobby")
rec_panel = lobby.recommended_for_you_panel
self._p()
# click the opt-in button to initiate the process, this will show the spinner
rec_panel.opt_in_button.emit('clicked')
self._p()
rec_panel._update_recommended_for_you_content()
self._p()
# we fake the callback from the agent here
lobby.recommended_for_you_panel.recommended_for_you_cat._recommend_me_result(
None, make_recommender_agent_recommend_me_dict())
self.assertNotEqual(
lobby.recommended_for_you_panel.recommended_for_you_cat.
get_documents(self.db), [])
from softwarecenter.ui.gtk3.widgets.spinner import SpinnerNotebook
self.assertTrue(rec_panel.spinner_notebook.get_current_page() ==
SpinnerNotebook.CONTENT_PAGE)
self._p()
# test clicking recommended_for_you More button
lobby.connect("category-selected", self._on_category_selected)
lobby.recommended_for_you_panel.more.clicked()
self._p()
self.assertNotEqual(self._cat, None)
self.assertEqual(self._cat.name, "Recommended For You")
win.destroy()
