~nataliabidart/ubuntu-sso-client/lint-fix-stable-3-0 : revision 790

32

from twisted.trial.unittest import TestCase

33

from ubuntuone.devtools.handlers import MementoHandler

34

35

from ubuntu_sso.utils.ui import UNKNOWN_ERROR

35

36

from ubuntu_sso.gtk import gui

36

37

from ubuntu_sso.tests import (APP_NAME, TC_URL, HELP_TEXT, CAPTCHA_ID,

37

38

CAPTCHA_SOLUTION, EMAIL, EMAIL_TOKEN, NAME, PASSWORD, RESET_PASSWORD_TOKEN)

390

391

'tc_browser', 'login', 'request_password_token',

391

392

'set_new_password')

392

393

self.ui = self.gui_class(**self.kwargs)

393

self.error = {'message': self.ui.UNKNOWN_ERROR}

394

self.error = {'message': UNKNOWN_ERROR}

394

395

396

def tearDown(self):

396

397

"""Clean up."""

572

573

msg = 'Text for "%s" must be "%s" (got "%s" instead).'

573

574

for name in self.ui.entries:

574

575

entry = getattr(self.ui, name)

575

expected = getattr(self.ui, name.upper())

576

expected = getattr(gui.utils.ui, name.upper())

576

577

actual = entry.label

577

578

# text content is correct

578

579

self.assertEqual(expected, actual, msg % (name, expected, actual))

649

650

"""When calling 'finish_success' the success page is shown."""

650

651

self.ui.finish_success()

651

652

self.assert_pages_visibility(finish=True)

652

self.assertEqual(self.ui.SUCCESS, self.ui.finish_vbox.label.get_text())

653

self.assertEqual(gui.SUCCESS, self.ui.finish_vbox.label.get_text())

653

654

655

def test_finish_error_shows_error_page(self):

655

656

"""When calling 'finish_error' the error page is shown."""

656

657

self.ui.finish_error()

657

658

self.assert_pages_visibility(finish=True)

658

self.assertEqual(self.ui.ERROR, self.ui.finish_vbox.label.get_text())

659

self.assertEqual(gui.ERROR, self.ui.finish_vbox.label.get_text())

659

660

661

662

class EnterDetailsTestCase(UbuntuSSOClientTestCase):

664

665

def test_initial_text_for_header_label(self):

665

666

"""The header must have the correct text at startup."""

666

667

msg = 'Text for the header must be "%s" (got "%s" instead).'

667

expected = self.ui.JOIN_HEADER_LABEL % {'app_name': APP_NAME}

668

expected = gui.JOIN_HEADER_LABEL % {'app_name': APP_NAME}

668

669

actual = self.ui.header_label.get_text()

669

670

# text content is correct

670

671

self.assertEqual(expected, actual, msg % (expected, actual))

685

686

def test_initial_texts_for_checkbuttons(self):

686

687

"""Check buttons have the correct text at startup."""

687

688

msg = 'Text for "%s" must be "%s" (got "%s" instead).'

688

expected = self.ui.YES_TO_UPDATES % {'app_name': APP_NAME}

689

expected = gui.YES_TO_UPDATES % {'app_name': APP_NAME}

689

690

actual = self.ui.yes_to_updates_checkbutton.get_label()

690

691

self.assertEqual(expected, actual, msg % ('yes_to_updates_checkbutton',

691

692

expected, actual))

692

expected = self.ui.YES_TO_TC % {'app_name': APP_NAME}

693

expected = gui.YES_TO_TC % {'app_name': APP_NAME}

693

694

actual = self.ui.yes_to_tc_checkbutton.get_label()

694

695

self.assertEqual(expected, actual,

695

696

msg % ('yes_to_tc_checkbutton', expected, actual))

744

745

'the processing spinner should be active.')

745

746

self.assertTrue(label.get_property('visible'),

746

747

'the processing label should be visible.')

747

self.assertEqual(label.get_text(), self.ui.ONE_MOMENT_PLEASE,

748

self.assertEqual(label.get_text(), gui.ONE_MOMENT_PLEASE,

748

749

'the processing label text must be correct.')

749

750

751

def test_captcha_image_is_not_visible_at_startup(self):

785

786

'the captcha_loading spinner should be active.')

786

787

self.assertTrue(label.get_property('visible'),

787

788

'the captcha_loading label should be visible.')

788

self.assertEqual(label.get_text(), self.ui.LOADING,

789

self.assertEqual(label.get_text(), gui.LOADING,

789

790

'the captcha_loading label text must be correct.')

790

791

792

def test_join_ok_button_is_disabled_until_captcha_is_available(self):

847

848

def test_captcha_reload_button_has_tooltip(self):

848

849

"""The captcha reload button has a tooltip."""

849

850

self.assertEqual(self.ui.captcha_reload_button.get_tooltip_text(),

850

self.ui.CAPTCHA_RELOAD_TOOLTIP)

851

gui.CAPTCHA_RELOAD_TOOLTIP)

851

852

853

def test_login_button_has_correct_wording(self):

853

854

"""The sign in button has the proper wording."""

854

855

actual = self.ui.login_button.get_label()

855

self.assertEqual(self.ui.LOGIN_BUTTON_LABEL, actual)

856

self.assertEqual(gui.LOGIN_BUTTON_LABEL, actual)

856

857

858

def test_join_ok_button_does_nothing_if_clicked_but_disabled(self):

858

859

"""The join form can only be submitted if the button is sensitive."""

877

878

self.patch(self.ui, '_generate_captcha', self._set_called)

878

879

self.ui.on_captcha_generation_error(APP_NAME, error=self.error)

879

880

self.assert_correct_label_warning(self.ui.warning_label,

880

self.ui.CAPTCHA_LOAD_ERROR)

881

gui.CAPTCHA_LOAD_ERROR)

881

882

self.assertEqual(self._called, ((), {}))

882

883

884

def test_captcha_success_after_error(self):

968

969

970

def test_tc_button_has_the_proper_wording(self):

970

971

"""Terms & Conditions has the proper wording."""

971

self.assertEqual(self.ui.tc_button.get_label(), self.ui.TC_BUTTON)

972

self.assertEqual(self.ui.tc_button.get_label(), gui.TC_BUTTON)

972

973

974

def test_tc_has_no_help_text(self):

974

975

"""The help text is removed."""

1086

1087

"""On UserRegistrationError the warning label is shown."""

1087

1088

self.ui.on_user_registration_error(app_name=APP_NAME, error=self.error)

1088

1089

self.assert_correct_label_warning(self.ui.warning_label,

1089

self.ui.UNKNOWN_ERROR)

1090

UNKNOWN_ERROR)

1090

1091

1092

def test_specific_errors_from_backend_are_shown(self):

1092

1093

"""Specific errors from backend are used."""

1128

1129

"""The help_label display VERIFY_EMAIL_LABEL."""

1129

1130

msg = 'help_label must read "%s" (got "%s" instead).'

1130

1131

actual = self.ui.help_label.get_label()

1131

expected = self.ui.VERIFY_EMAIL_LABEL % {'app_name': APP_NAME,

1132

'email': EMAIL}

1132

expected = gui.VERIFY_EMAIL_LABEL % {'app_name': APP_NAME,

1133

'email': EMAIL}

1133

1134

self.assertEqual(expected, actual, msg % (expected, actual))

1134

1135

1136

def test_on_verify_token_button_clicked_calls_validate_email(self):

1180

1181

self.ui.on_email_validation_error(app_name=APP_NAME, error=self.error)

1181

1182

self.assert_pages_visibility(verify_email=True)

1182

1183

self.assert_correct_label_warning(self.ui.warning_label,

1183

self.ui.UNKNOWN_ERROR)

1184

UNKNOWN_ERROR)

1184

1185

1186

def test_specific_errors_from_backend_are_shown(self):

1186

1187

"""Specific errors from backend are used."""

1198

1199

1200

def test_success_label_is_correct(self):

1200

1201

"""The success message is correct."""

1201

self.assertEqual(self.ui.SUCCESS,

1202

self.assertEqual(gui.SUCCESS,

1202

1203

self.ui.success_vbox.label.get_text())

1203

1204

markup = self.ui.success_vbox.label.get_label()

1204

1205

self.assertTrue('<span size="x-large">' in markup)

1205

1206

1207

def test_error_label_is_correct(self):

1207

1208

"""The error message is correct."""

1208

self.assertEqual(self.ui.ERROR,

1209

self.assertEqual(gui.ERROR,

1209

1210

self.ui.error_vbox.label.get_text())

1210

1211

markup = self.ui.error_vbox.label.get_label()

1211

1212

self.assertTrue('<span size="x-large">' in markup)

1269

1270

self.ui.verify_token_button.clicked()

1270

1271

1272

self.assert_correct_entry_warning(self.ui.email_token_entry,

1272

self.ui.FIELD_REQUIRED)

1273

gui.FIELD_REQUIRED)

1273

1274

self.assertNotIn('validate_email', self.ui.backend._called)

1274

1275

1276

def test_no_warning_messages_if_valid_data(self):

1319

1320

self.ui.join_ok_button.clicked()

1320

1321

1322

self.assert_correct_entry_warning(self.ui.name_entry,

1322

self.ui.FIELD_REQUIRED)

1323

gui.FIELD_REQUIRED)

1323

1324

self.assertNotIn('register_user', self.ui.backend._called)

1324

1325

1326

def test_warning_is_shown_if_empty_email(self):

1330

1331

self.ui.join_ok_button.clicked()

1331

1332

1333

self.assert_correct_entry_warning(self.ui.email1_entry,

1333

self.ui.FIELD_REQUIRED)

1334

gui.FIELD_REQUIRED)

1334

1335

self.assert_correct_entry_warning(self.ui.email2_entry,

1335

self.ui.FIELD_REQUIRED)

1336

gui.FIELD_REQUIRED)

1336

1337

self.assertNotIn('register_user', self.ui.backend._called)

1337

1338

1339

def test_warning_is_shown_if_email_mismatch(self):

1343

1344

self.ui.join_ok_button.clicked()

1344

1345

1346

self.assert_correct_entry_warning(self.ui.email1_entry,

1346

self.ui.EMAIL_MISMATCH)

1347

gui.EMAIL_MISMATCH)

1347

1348

self.assert_correct_entry_warning(self.ui.email2_entry,

1348

self.ui.EMAIL_MISMATCH)

1349

gui.EMAIL_MISMATCH)

1349

1350

self.assertNotIn('register_user', self.ui.backend._called)

1350

1351

1352

def test_warning_is_shown_if_invalid_email(self):

1356

1357

self.ui.join_ok_button.clicked()

1357

1358

1359

self.assert_correct_entry_warning(self.ui.email1_entry,

1359

self.ui.EMAIL_INVALID)

1360

gui.EMAIL_INVALID)

1360

1361

self.assert_correct_entry_warning(self.ui.email2_entry,

1361

self.ui.EMAIL_INVALID)

1362

gui.EMAIL_INVALID)

1362

1363

self.assertNotIn('register_user', self.ui.backend._called)

1363

1364

1365

def test_password_help_is_always_shown(self):

1366

1367

self.assertTrue(self.ui.password_help_label.get_property('visible'),

1367

1368

'password help text is visible.')

1368

1369

self.assertEqual(self.ui.password_help_label.get_text(),

1369

self.ui.PASSWORD_HELP)

1370

gui.PASSWORD_HELP)

1370

1371

self.assertNotIn('register_user', self.ui.backend._called)

1371

1372

1373

def test_warning_is_shown_if_password_mismatch(self):

1377

1378

self.ui.join_ok_button.clicked()

1378

1379

1380

self.assert_correct_entry_warning(self.ui.password1_entry,

1380

self.ui.PASSWORD_MISMATCH)

1381

gui.PASSWORD_MISMATCH)

1381

1382

self.assert_correct_entry_warning(self.ui.password2_entry,

1382

self.ui.PASSWORD_MISMATCH)

1383

gui.PASSWORD_MISMATCH)

1383

1384

self.assertNotIn('register_user', self.ui.backend._called)

1384

1385

1386

def test_warning_is_shown_if_password_too_weak(self):

1392

1393

self.ui.join_ok_button.clicked()

1393

1394

1395

self.assert_correct_entry_warning(self.ui.password1_entry,

1395

self.ui.PASSWORD_TOO_WEAK)

1396

gui.PASSWORD_TOO_WEAK)

1396

1397

self.assert_correct_entry_warning(self.ui.password2_entry,

1397

self.ui.PASSWORD_TOO_WEAK)

1398

gui.PASSWORD_TOO_WEAK)

1398

1399

self.assertNotIn('register_user', self.ui.backend._called)

1399

1400

1401

def test_warning_is_shown_if_tc_not_accepted(self):

1405

1406

self.ui.join_ok_button.clicked()

1406

1407

1408

self.assert_correct_label_warning(self.ui.tc_warning_label,

1408

self.ui.TC_NOT_ACCEPTED)

1409

gui.TC_NOT_ACCEPTED)

1409

1410

self.assertNotIn('register_user', self.ui.backend._called)

1410

1411

1412

def test_warning_is_shown_if_not_captcha_solution(self):

1416

1417

self.ui.join_ok_button.clicked()

1417

1418

1419

self.assert_correct_entry_warning(self.ui.captcha_solution_entry,

1419

self.ui.FIELD_REQUIRED)

1420

gui.FIELD_REQUIRED)

1420

1421

self.assertNotIn('register_user', self.ui.backend._called)

1421

1422

1423

def test_no_warning_messages_if_valid_data(self):

1452

1453

def test_initial_text_for_header_label(self):

1453

1454

"""The header must have the correct text when logging in."""

1454

1455

msg = 'Text for the header must be "%s" (got "%s" instead).'

1455

expected = self.ui.LOGIN_HEADER_LABEL % {'app_name': APP_NAME}

1456

expected = gui.LOGIN_HEADER_LABEL % {'app_name': APP_NAME}

1456

1457

actual = self.ui.header_label.get_text()

1457

1458

self.assertEqual(expected, actual, msg % (expected, actual))

1458

1459

1460

def test_initial_text_for_help_label(self):

1460

1461

"""The help must have the correct text at startup."""

1461

1462

msg = 'Text for the help must be "%s" (got "%s" instead).'

1462

expected = self.ui.CONNECT_HELP_LABEL % {'app_name': APP_NAME}

1463

expected = gui.CONNECT_HELP_LABEL % {'app_name': APP_NAME}

1463

1464

actual = self.ui.help_label.get_text()

1464

1465

self.assertEqual(expected, actual, msg % (expected, actual))

1465

1466

1524

1525

self.click_connect_with_valid_data()

1525

1526

self.ui.on_login_error(app_name=APP_NAME, error=self.error)

1526

1527

self.assert_correct_label_warning(self.ui.warning_label,

1527

self.ui.UNKNOWN_ERROR)

1528

UNKNOWN_ERROR)

1528

1529

1530

def test_specific_errors_from_backend_are_shown(self):

1530

1531

"""Specific errors from backend are used."""

1604

1605

self.ui.login_ok_button.clicked()

1605

1606

1607

self.assert_correct_entry_warning(self.ui.login_email_entry,

1607

self.ui.FIELD_REQUIRED)

1608

gui.FIELD_REQUIRED)

1608

1609

self.assertNotIn('login', self.ui.backend._called)

1609

1610

1611

def test_warning_is_shown_if_invalid_email(self):

1614

1615

self.ui.login_ok_button.clicked()

1615

1616

1617

self.assert_correct_entry_warning(self.ui.login_email_entry,

1617

self.ui.EMAIL_INVALID)

1618

gui.EMAIL_INVALID)

1618

1619

self.assertNotIn('login', self.ui.backend._called)

1619

1620

1621

def test_warning_is_shown_if_empty_password(self):

1624

1625

self.ui.login_ok_button.clicked()

1625

1626

1627

self.assert_correct_entry_warning(self.ui.login_password_entry,

1627

self.ui.FIELD_REQUIRED)

1628

gui.FIELD_REQUIRED)

1628

1629

self.assertNotIn('login', self.ui.backend._called)

1629

1630

1631

def test_no_warning_messages_if_valid_data(self):

1657

1658

def test_forgotten_password_button_has_the_proper_wording(self):

1658

1659

"""The forgotten_password_button has the proper wording."""

1659

1660

self.assertEqual(self.ui.forgotten_password_button.get_label(),

1660

self.ui.FORGOTTEN_PASSWORD_BUTTON)

1661

gui.FORGOTTEN_PASSWORD_BUTTON)

1661

1662

1663

def test_on_forgotten_password_button_clicked_help_text(self):

1663

1664

"""Clicking forgotten_password_button the help is properly changed."""

1664

wanted = self.ui.REQUEST_PASSWORD_TOKEN_LABEL % {'app_name': APP_NAME}

1665

wanted = gui.REQUEST_PASSWORD_TOKEN_LABEL % {'app_name': APP_NAME}

1665

1666

self.assertEqual(self.ui.help_label.get_text(), wanted)

1666

1667

1668

def test_on_forgotten_password_button_clicked_header_label(self):

1668

1669

"""Clicking forgotten_password_button the title is properly changed."""

1669

1670

self.assertEqual(self.ui.header_label.get_text(),

1670

self.ui.RESET_PASSWORD)

1671

gui.RESET_PASSWORD)

1671

1672

1673

def test_on_forgotten_password_button_clicked_ok_button(self):

1673

1674

"""Clicking forgotten_password_button the ok button reads 'Next'."""

1674

1675

self.assertEqual(self.ui.request_password_token_ok_button.get_label(),

1675

self.ui.NEXT)

1676

gui.NEXT)

1676

1677

1678

def test_on_forgotten_password_button_clicked_morphs_window(self):

1678

1679

"""Clicking forgotten_password_button the proper page is shown."""

1724

1725

self.ui.on_password_reset_token_sent(app_name=APP_NAME, email=EMAIL)

1725

1726

1727

self.assertEqual(self.ui.help_label.get_text(),

1727

self.ui.SET_NEW_PASSWORD_LABEL % {'email': EMAIL})

1728

gui.SET_NEW_PASSWORD_LABEL % {'email': EMAIL})

1728

1729

1730

def test_on_password_reset_token_sent_ok_button(self):

1730

1731

"""After request_password_token_ok_button the ok button is updated."""

1732

1733

self.ui.on_password_reset_token_sent(app_name=APP_NAME, email=EMAIL)

1733

1734

1735

self.assertEqual(self.ui.set_new_password_ok_button.get_label(),

1735

self.ui.RESET_PASSWORD)

1736

gui.RESET_PASSWORD)

1736

1737

1738

def test_on_password_reset_error_shows_login_page(self):

1738

1739

"""When reset token wasn't successfuly sent the login page is shown."""

1739

1740

self.ui.on_password_reset_error(app_name=APP_NAME, error=self.error)

1740

1741

self.assert_correct_label_warning(self.ui.warning_label,

1741

self.ui.UNKNOWN_ERROR)

1742

UNKNOWN_ERROR)

1742

1743

self.assert_pages_visibility(login=True)

1743

1744

1745

def test_specific_errors_from_backend_are_shown(self):

1776

1777

self.ui.request_password_token_ok_button.clicked()

1777

1778

1779

self.assert_correct_entry_warning(self.ui.reset_email_entry,

1779

self.ui.FIELD_REQUIRED)

1780

gui.FIELD_REQUIRED)

1780

1781

self.assertNotIn('request_password_reset_token',

1781

1782

self.ui.backend._called)

1782

1783

1787

1788

self.ui.request_password_token_ok_button.clicked()

1788

1789

1790

self.assert_correct_entry_warning(self.ui.reset_email_entry,

1790

self.ui.EMAIL_INVALID)

1791

gui.EMAIL_INVALID)

1791

1792

self.assertNotIn('request_password_reset_token',

1792

1793

self.ui.backend._called)

1793

1794

1855

1856

"""When password was successfuly changed the login page is shown."""

1856

1857

self.ui.on_password_changed(app_name=APP_NAME, email=EMAIL)

1857

1858

self.assert_correct_label_warning(self.ui.warning_label,

1858

self.ui.PASSWORD_CHANGED)

1859

gui.PASSWORD_CHANGED)

1859

1860

self.assert_pages_visibility(login=True)

1860

1861

1862

def test_on_password_change_error_shows_login_page(self):

1862

1863

"""When password wasn't changed the reset password page is shown."""

1863

1864

self.ui.on_password_change_error(app_name=APP_NAME, error=self.error)

1864

1865

self.assert_correct_label_warning(self.ui.warning_label,

1865

self.ui.UNKNOWN_ERROR)

1866

UNKNOWN_ERROR)

1866

1867

self.assert_pages_visibility(request_password_token=True)

1867

1868

1869

def test_specific_errors_from_backend_are_shown(self):

1900

1901

self.ui.set_new_password_ok_button.clicked()

1901

1902

1903

self.assert_correct_entry_warning(self.ui.reset_code_entry,

1903

self.ui.FIELD_REQUIRED)

1904

gui.FIELD_REQUIRED)

1904

1905

self.assertNotIn('set_new_password', self.ui.backend._called)

1905

1906

1907

def test_password_help_is_always_shown(self):

1908

1909

visible = self.ui.reset_password_help_label.get_property('visible')

1909

1910

self.assertTrue(visible, 'password help text is visible.')

1910

1911

self.assertEqual(self.ui.reset_password_help_label.get_text(),

1911

self.ui.PASSWORD_HELP)

1912

gui.PASSWORD_HELP)

1912

1913

self.assertNotIn('set_new_password', self.ui.backend._called)

1913

1914

1915

def test_warning_is_shown_if_password_mismatch(self):

1920

1921

self.ui.set_new_password_ok_button.clicked()

1921

1922

1923

self.assert_correct_entry_warning(self.ui.reset_password1_entry,

1923

self.ui.PASSWORD_MISMATCH)

1924

gui.PASSWORD_MISMATCH)

1924

1925

self.assert_correct_entry_warning(self.ui.reset_password2_entry,

1925

self.ui.PASSWORD_MISMATCH)

1926

gui.PASSWORD_MISMATCH)

1926

1927

self.assertNotIn('set_new_password', self.ui.backend._called)

1927

1928

1929

def test_warning_is_shown_if_password_too_weak(self):

1936

1937

self.ui.set_new_password_ok_button.clicked()

1937

1938

1939

self.assert_correct_entry_warning(self.ui.reset_password1_entry,

1939

self.ui.PASSWORD_TOO_WEAK)

1940

gui.PASSWORD_TOO_WEAK)

1940

1941

self.assert_correct_entry_warning(self.ui.reset_password2_entry,

1941

self.ui.PASSWORD_TOO_WEAK)

1942

gui.PASSWORD_TOO_WEAK)

1942

1943

self.assertNotIn('set_new_password', self.ui.backend._called)

1943

1944

1945

def test_no_warning_messages_if_valid_data(self):