← Back to branch summary

~osomon/webbrowser-app/hangouts-ua-overrides

« back to all changes in this revision

Viewing changes to tests/autopilot/webbrowser_app/tests/test_settings.py

  • Committer: CI Train Bot
  • Author(s): Olivier Tilloy
  • Date: 2016-03-03 19:01:25 UTC
  • mfrom: (1360.1.15 visual-tweaks)
  • Revision ID: ci-train-bot@canonical.com-20160303190125-knclvoooqdw1lquw
Visual tweaks per designers’ review.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/autopilot/webbrowser_app/tests/test_settings.py
1
1
# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
2
2
#
3
 
# Copyright 2015 Canonical
 
3
# Copyright 2015-2016 Canonical
4
4
#
5
5
# This program is free software: you can redistribute it and/or modify it
6
6
# under the terms of the GNU General Public License version 3, as published
20
20
 
21
21
from testtools.matchers import Equals, GreaterThan, NotEquals
22
22
from autopilot.matchers import Eventually
23
 
from autopilot.platform import model
24
23
 
25
24
import ubuntuuitoolkit as uitk
26
25
 
45
44
    def test_open_close_searchengine_page(self):
46
45
        settings = self.open_settings()
47
46
        searchengine = settings.get_searchengine_entry()
48
 
        old_engine = searchengine.subText
 
47
        old_engine = searchengine.currentSearchEngineDisplayName
49
48
        self.assertThat(old_engine, NotEquals(""))
50
49
        self.pointing_device.click_object(searchengine)
51
50
        searchengine_page = settings.get_searchengine_page()
53
52
            browser.BrowserPageHeader)
54
53
        searchengine_header.click_back_button()
55
54
        searchengine_page.wait_until_destroyed()
56
 
        self.assertThat(searchengine.subText, Equals(old_engine))
 
55
        self.assertThat(searchengine.currentSearchEngineDisplayName,
 
56
                        Equals(old_engine))
57
57
 
58
58
    def test_change_searchengine(self):
59
59
        settings = self.open_settings()
60
60
        searchengine = settings.get_searchengine_entry()
61
 
        old_engine = searchengine.subText
 
61
        old_engine = searchengine.currentSearchEngineDisplayName
62
62
        self.assertThat(old_engine, NotEquals(""))
63
63
        self.pointing_device.click_object(searchengine)
64
64
        searchengine_page = settings.get_searchengine_page()
65
 
        self.assertThat(lambda: len(searchengine_page.select_many("Standard")),
66
 
                        Eventually(GreaterThan(1)))
67
 
        delegates = searchengine_page.select_many("Standard")
 
65
        self.assertThat(lambda: len(searchengine_page.select_many(
 
66
            objectName="searchEngineDelegate")),
 
67
            Eventually(GreaterThan(1)))
 
68
        delegates = searchengine_page.select_many(
 
69
            objectName="searchEngineDelegate")
68
70
        delegates.sort(key=lambda delegate: delegate.objectName)
69
71
        new_index = -1
70
72
        for (i, delegate) in enumerate(delegates):
72
74
            if (new_index == -1) and not checkbox.checked:
73
75
                new_index = i
74
76
            self.assertThat(checkbox.checked,
75
 
                            Equals(delegate.text == old_engine))
76
 
        new_engine = delegates[new_index].text
 
77
                            Equals(delegate.displayName == old_engine))
 
78
        new_engine = delegates[new_index].displayName
77
79
        self.assertThat(new_engine, NotEquals(old_engine))
78
80
        self.pointing_device.click_object(
79
81
            delegates[new_index].select_single(uitk.CheckBox))
80
82
        searchengine_page.wait_until_destroyed()
81
 
        self.assertThat(searchengine.subText, Eventually(Equals(new_engine)))
 
83
        self.assertThat(searchengine.currentSearchEngineDisplayName,
 
84
                        Eventually(Equals(new_engine)))
82
85
 
83
86
    def test_change_homepage(self):
84
87
        settings = self.open_settings()
85
88
        homepage = settings.get_homepage_entry()
86
 
        old = homepage.subText
 
89
        old = homepage.currentHomepage
87
90
        self.assertThat(old, NotEquals(""))
88
91
 
89
92
        # First test cancelling the edition
97
100
            objectName="homepageDialog.cancelButton")
98
101
        self.pointing_device.click_object(cancel_button)
99
102
        dialog.wait_until_destroyed()
100
 
        self.assertThat(homepage.subText, Equals(old))
 
103
        self.assertThat(homepage.currentHomepage, Equals(old))
101
104
 
102
105
        # Then test actually changing the homepage
103
106
        self.pointing_device.click_object(homepage)
113
116
            objectName="homepageDialog.saveButton")
114
117
        self.pointing_device.click_object(save_button)
115
118
        dialog.wait_until_destroyed()
116
 
        self.assertThat(homepage.subText, Eventually(Equals(new)))
 
119
        self.assertThat(homepage.currentHomepage, Eventually(Equals(new)))
117
120
 
118
121
    def test_open_close_privacy_settings(self):
119
122
        settings = self.open_settings()
130
133
        self.pointing_device.click_object(privacy)
131
134
        privacy_page = settings.get_privacy_page()
132
135
        clear_history = privacy_page.select_single(
133
 
            "Standard",
134
136
            objectName="privacy.clearHistory")
135
137
        self.assertThat(clear_history.enabled, Equals(True))
136
138
 
158
160
        self.pointing_device.click_object(privacy)
159
161
        privacy_page = settings.get_privacy_page()
160
162
        clear_cache = privacy_page.select_single(
161
 
            "Standard",
162
163
            objectName="privacy.clearCache")
163
164
        self.assertThat(clear_cache.enabled, Equals(True))
164
165
 
186
187
        self.pointing_device.click_object(reset)
187
188
 
188
189
        searchengine = settings.get_searchengine_entry()
189
 
        self.assertThat(searchengine.subText,
 
190
        self.assertThat(searchengine.currentSearchEngineDisplayName,
190
191
                        Eventually(Equals("Google")))
191
192
 
192
193
        homepage = settings.get_homepage_entry()
193
 
        self.assertThat(homepage.subText,
 
194
        self.assertThat(homepage.currentHomepage,
194
195
                        Eventually(Equals("http://start.ubuntu.com")))
195
196
 
196
197
        restore_session = settings.get_restore_session_entry()
197
198
        checkbox = restore_session.select_single(uitk.CheckBox)
198
199
        self.assertThat(checkbox.checked, Eventually(Equals(True)))
199
 
 
200
 
        background_tabs = settings.get_background_tabs_entry()
201
 
        checkbox = background_tabs.select_single(uitk.CheckBox)
202
 
        self.assertThat(checkbox.checked,
203
 
                        Eventually(Equals(model() == 'Desktop')))