← Back to branch summary

~carla-sella/ubuntu-rssreader-app/edit-topic-test

« back to all changes in this revision

Viewing changes to tests/autopilot/ubuntu_rssreader_app/tests/test_rssreader.py

  • Committer: Tarmac
  • Author(s): Carla Sella
  • Date: 2013-10-06 14:05:33 UTC
  • mfrom: (94.1.1 ubuntu-rssreader-app)
  • Revision ID: tarmac-20131006140533-6qlrpuvh8c8k7udt
Autopilot tests for ubuntu-rssreader-app.

Approved by Ubuntu Phone Apps Jenkins Bot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/autopilot/ubuntu_rssreader_app/tests/test_rssreader.py
101
101
        logger.debug("input topic")
102
102
        self._input_new_topic(topicName)
103
103
 
104
 
        #A new topic is now automatically selected as the topic
105
 
        #select new topic
106
 
        #logger.debug("assert new topic")
107
 
        #newNumTopics = len(self.main_view.get_choose_topics_items)
108
 
        #self.assertThat(newNumTopics, Eventually(Equals(numTopics + 1)))
109
 
        #logger.debug("grab new topic")
110
 
        #topics = self.main_view.get_choose_topics_items()
111
 
        #numTopics = len(topics)
112
 
        #logger.debug("found " + str(numTopics) + " topics")
113
 
        #for topic in topics:
114
 
        #    logger.debug("Topic: ") + str(topic.text)
115
 
        #newTopic = self.main_view.get_choose_topics_items()[-1]
116
 
        #newTopic = topics[-1]
117
 
        #logger.debug("click new topic, ") + str(newTopic.text)
118
 
        #self.pointing_device.click_object(newTopic)
119
 
        #logger.debug("topic clicked")
120
 
 
121
 
        #wait for any updates to finish before beginning tests
122
 
        #this transition currently locks the device https://bugs.launchpad.net/ubuntu-rssreader-app/+bug/1221893
123
 
        #logger.debug("check for network updates")
124
 
        #self.assertThat(self.main_view.get_network_activity, Eventually(Not(Is(None))))
125
 
        #logger.debug("assert no network updates")
126
 
        #self.assertThat(self.main_view.get_network_activity, Eventually(Is(None)))
127
 
        #logger.debug("assert we're back on main view")
128
 
        #self.assertThat(self.main_view.visible, Eventually(Equals(True)))
129
 
        #logger.debug("finished with add_feed_topic")
130
 
 
131
104
    def _remove_feed(self, feedName, topicName):
132
105
        logger.debug("removing feed")
133
106
        #open toolbar
140
113
 
141
114
        #verify we are on the Management page
142
115
        logger.debug("assert feedlist page")
143
 
        feedlistpage = lambda: self.main_view.get_feed_management_page().visible
144
 
        self.assertThat(feedlistpage, Eventually(Equals(True)))
 
116
        feedlistpage = self.main_view.get_feed_management_page()
 
117
        self.assertThat(feedlistpage.visible, Eventually(Equals(True)))
145
118
 
146
119
        #select topic
147
120
        logger.debug("grabbing topic")
148
121
        self._get_topic(topicName)
149
122
 
150
 
        #select feed
 
123
        ##select feed
151
124
        logger.debug("assert feed")
152
125
        self.assertThat(lambda: self.main_view.get_feedlist_feed(feedName), Eventually(Not(Is(None))))
153
126
        logger.debug("grabbing feed")
154
127
        feed = self.main_view.get_feedlist_feed(feedName)
155
 
        logger.debug("clicking feed")
156
 
        self.pointing_device.click_object(feed)
157
 
 
158
 
        #verify we are on the Edit Feed page
159
 
        logger.debug("assert editfeedpage")
160
 
        editFeedPage = self.main_view.get_edit_feed_page()
161
 
        self.assertThat(editFeedPage.visible, Eventually(Equals(True)))
162
 
 
163
 
        #press delete button
164
 
        logger.debug("assert delete button")
165
 
        self.assertThat(self.main_view.get_delete_button, Eventually(Not(Is(None))))
166
 
        logger.debug("grab delete button")
167
 
        deleteButton = self.main_view.get_delete_button()
168
 
        logger.debug("click delete button")
169
 
        self.pointing_device.click_object(deleteButton)
 
128
 
 
129
 
 
130
 
 
131
 
 
132
        self.assertThat(
 
133
            self.main_view.get_feed_management_page,
 
134
                Eventually(NotEquals(None)))
 
135
 
 
136
        #swipe to delete canonical topic
 
137
        startX = int(feedlistpage.x + feedlistpage.width * 0.30)
 
138
        stopX = int(feedlistpage.x + feedlistpage.width)
 
139
        lineY = feed.globalRect[1]
 
140
 
 
141
        #swipe to remove the topic
 
142
        self.pointing_device.move(startX, lineY)
 
143
        #self.pointing_device.click()
 
144
        self.pointing_device.drag(startX, lineY, stopX, lineY)
 
145
 
 
146
 
 
147
 
 
148
 
 
149
 
 
150
 
 
151
 
 
152
 
 
153
 
 
154
        #logger.debug("clicking feed")
 
155
        #self.pointing_device.click_object(feed)
 
156
 
 
157
        ##verify we are on the Edit Feed page
 
158
        #logger.debug("assert editfeedpage")
 
159
        #editFeedPage = self.main_view.get_edit_feed_page()
 
160
        #self.assertThat(editFeedPage.visible, Eventually(Equals(True)))
 
161
 
 
162
        ##press delete button
 
163
        #logger.debug("assert delete button")
 
164
        #self.assertThat(self.main_view.get_delete_button, Eventually(Not(Is(None))))
 
165
        #logger.debug("grab delete button")
 
166
        #deleteButton = self.main_view.get_delete_button()
 
167
        #logger.debug("click delete button")
 
168
        #self.pointing_device.click_object(deleteButton)
170
169
 
171
170
        #verify we are on the Management page
172
171
        logger.debug("assert feedlistpage")
210
209
        #select topic
211
210
        topic = self._get_topic(topicName)
212
211
 
213
 
        #topicsPage = self.main_view.get_manage_topics_page()
214
 
        #self.assertThat(self.main_view.get_manage_topics_page, Eventually(NotEquals(None)))
215
212
        topicmanagementpage = self.main_view.get_feed_management_page()
216
213
        self.assertThat(self.main_view.get_feed_management_page, Eventually(NotEquals(None)))
217
214
 
225
222
        self.pointing_device.click()
226
223
        self.pointing_device.drag(startX, lineY, stopX, lineY)
227
224
 
228
 
        #verify we are on the Management page  *** for timing issues ***
229
 
        feedmanagementpage = self.main_view.get_feed_management_page()
230
 
        self.assertThat(feedmanagementpage, NotEquals(None))
 
225
        #verify we are on the Topic Management page **for timing issue
 
226
        topicmanagementpage = self.main_view.get_feed_management_page()
 
227
        self.assertThat(self.main_view.get_feed_management_page, Eventually(NotEquals(None)))
 
228
        self.assertThat(self.main_view.get_feed_management_page().visible, Eventually(Equals(True)))
 
229
        self.assertThat(self.main_view.get_feed_management_page().objectName, Eventually(Equals("topicmanagement")))
231
230
 
232
231
        #check that it is gone
233
232
        topic = self.main_view.get_feedlist_topic(topicName)
288
287
        #remove added topic
289
288
        self._remove_topic(topicName)
290
289
 
291
 
 
292
 
    @unittest.skip("Topic page broken, see https://bugs.launchpad.net/ubuntu-rssreader-app/+bug/1206248")
293
290
    def test_view_feeds(self):
294
291
        """test view feeds"""
295
292
 
296
 
        self.assertThat(self.main_view.get_topics_page(), NotEquals(None))
297
 
 
298
 
        #-----> view all news:
 
293
        feed = "http://www.canonical.com/rss.xml"
 
294
        feedName = "Canonical"
 
295
        topicName = "CanonicalTopic"
 
296
 
 
297
        #add topic and feed
 
298
        self._add_feed_and_topic(feed, topicName)
 
299
 
 
300
        #verify we are on the CanonicalTopic Tab
 
301
        canonicalTab = self.main_view.get_canonical_tab()
 
302
        self.assertThat(lambda: canonicalTab.visible, Eventually(Equals(True)))
 
303
 
299
304
        #open toolbar
300
305
        toolbar = self.main_view.open_toolbar()
301
306
 
302
 
        #click on add reads toolbar button
303
 
        toolbar.click_button("List view")
304
 
 
305
 
        #verify we are on the Feeds page
306
 
        feedlistpage = self.main_view.get_feedlist_page()
307
 
        self.assertThat(feedlistpage.visible, Eventually(Equals(True)))
308
 
 
309
 
        #select All articles
310
 
        allFeeds = self.main_view.get_all_feeds()
311
 
        self.assertThat(allFeeds, NotEquals("None"))
312
 
        self.pointing_device.click_object(allFeeds )
313
 
 
314
 
        #verify we are on the All articles page
315
 
        articlelistpage = self.main_view.get_articlelist_page()
316
 
        self.assertThat(articlelistpage.visible, Eventually(Equals(True)))
317
 
 
318
 
        toolbar = self.main_view.open_toolbar()
319
 
 
320
 
        #click on back toolbar button
321
 
        toolbar.click_button("Back")
322
 
 
323
 
        #verify we are on the Feeds page
324
 
        feedlistpage = lambda: self.main_view.get_feedlist_page().visible
325
 
        self.assertThat(feedlistpage, Eventually(Equals(True)))
326
 
 
327
 
        #-----> view individual feed:
328
 
        #add topic and feed
329
 
        self._add_feed_and_topic()
 
307
        #click on list view toolbar button
 
308
        toolbar.click_button("rsspagerefreshbutton")
 
309
 
 
310
        #wait for any updates to finish before continuing tests
 
311
        try:
 
312
            self.main_view.get_activityIndicator().running.wait_for(False)
 
313
        except:
 
314
            self.assertThat(
 
315
                lambda:self.main_view.get_canonical_tab,
 
316
                Eventually(NotEquals(None)))
330
317
 
331
318
        #select Canonical feed
332
 
        canonicalFeed = lambda: self.main_view.get_canonical_feed_labelvisual()
333
 
        self.assertThat(canonicalFeed, Eventually(Not(Is(None))))
 
319
        canonicalFeed = self.main_view.get_canonical_feed_in_feedlist()
 
320
        self.assertThat(canonicalFeed, NotEquals(None))
334
321
        self.pointing_device.click_object(canonicalFeed)
335
322
 
336
 
        #verify we are on the Canonical page
337
 
        header = lambda: self.main_view.get_header()[0].title
338
 
        self.assertThat(header, Eventually(Equals("Canonical")))
 
323
        #verify we are on RSS feed page
 
324
        rssfeedpage = self.main_view.get_rss_feed_page()
 
325
        self.assertThat(rssfeedpage.visible, Eventually(Equals(True)))
339
326
 
340
 
        #toggle toolbar
 
327
        #open toolbar
341
328
        toolbar = self.main_view.open_toolbar()
342
329
 
343
330
        #click on back toolbar button
344
 
        toolbar.click_button("Back")
345
 
 
346
 
        #verify we are on the Feeds page
347
 
        feedlistpage = lambda: self.main_view.get_feedlist_page().visible
348
 
        self.assertThat(feedlistpage, Eventually(Equals(True)))
349
 
 
350
 
        #toggle toolbar
351
 
        toolbar = self.main_view.open_toolbar()
352
 
 
353
 
        #click on shorts toolbar button
354
 
        toolbar.click_button("shorts")
355
 
 
356
 
        #verify we are on the Shorts page
357
 
        shortsPage = lambda: self.main_view.switch_to_tab_by_index(0).visible
358
 
        self.assertThat(shortsPage, Eventually(Equals(True)))
 
331
        rssfeedpageBackBtn = self.main_view.get_page_back_btn()
 
332
        self.pointing_device.click_object(rssfeedpageBackBtn)
 
333
 
 
334
        #verify we are on the CanonicalTopic Tab
 
335
        canonicalTab = self.main_view.get_canonical_tab()
 
336
        self.assertThat(lambda: canonicalTab.visible, Eventually(Equals(True)))
 
337
 
 
338
        #remove added Canonical feed
 
339
        self._remove_feed(feedName, topicName)
359
340
 
360
341
        #remove added Canonical topic
361
 
        self._remove_topic()
362
 
 
363
 
        #remove added Canonical feed
364
 
        self._remove_feed()
 
342
        self._remove_topic(topicName)