Differential D993

try to be safer when typing in X: slower, more checks
ClosedPublic
Actions

Authored by adamwill on Sep 5 2016, 6:44 AM.

Details

Reviewers
garretraziel
jskladan
Commits
rOPENQATESTSe1ec1997af5a: try to be safer when typing in X: slower, more checks
Summary

the main thing this does is try and type slower in X - this
should cover nearly everywhere we type anything in X, and make
it type slower. We also add a bit more safety checking to some
old tests which didn't have it (mainly _do_install_and_reboot)

  • wait_still_screen after typing to make sure all the keypresses

were registered before continuing.

This is an attempt to mitigate the problems we've seen where
the wrong text gets typed into the wrong places and the tests
break.

This branch is live on staging atm. It still has *some* issues,
but I do think it's an improvement.

Test Plan

run the tests (probably several times), compare to
runs without the change, see if it's better or worse...

Diff Detail

Repository
rOPENQATESTS os-autoinst-distri-fedora
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.
adamwill retitled this revision from to try to be safer when typing in X: slower, more checks.Sep 5 2016, 6:44 AM
adamwill updated this object.
adamwill edited the test plan for this revision. (Show Details)
adamwill added reviewers: jskladan, garretraziel.
adamwill added a comment.EditedSep 5 2016, 6:55 AM

to elaborate a bit on the changes from multiple send_key calls to type_string with special characters: I think mutliple send_key calls in sequence with nothing between them are dangerous as they may lead to typing too fast, which can result in the keypresses getting lost or happening out of order. There is no kind of confirmation of send_key calls (or VNC events in general, really) - the function just fires off the appropriate command over the wire and returns immediately, it does not verify (and really cannot verify) that the keypress was actually received and applied before returning.

type_string also cannot actually *verify* that keypresses worked, but it does have some protection against typing too fast, and you can make it even slower with the argument, like we do all the time in this diff. So I think it's much safer to do type_string "\t\t\t", 20; than send_key "tab"; send_key "tab"; send_key "tab";, even if the latter is a bit more obvious to read.

in general this commit tries to avoid all cases where we stack up send_key events, or do type_string immediately after send_key with no kind of wait in the middle.

garretraziel added inline comments.Sep 5 2016, 1:11 PM
lib/freeipa.pm
23–24

type_string "\t\t\t\t", 20?

adamwill updated this revision to Diff 2533.Sep 7 2016, 5:37 AM

considerable rework with check_type_string

this is quite a lot further down the road from the previous
version, using a check_type_string function which checks for
screen changes while typing, and with nicer syntax and a few
other tweaks.

adamwill added a comment.Sep 7 2016, 5:44 AM

So a few more notes here. I have two main concerns about this:

  1. if we happen to hit a failure case where we're trying to type but we don't have the right interface element selected or whatever, so the keystrokes don't result in the screen changing at all, this will make the test take rather longer to fail (depending on the size value and the length of the string).
  1. all the wait_screen_change calls probably increase load on the worker box somewhat. I dunno what the cost of that call is exactly, but I don't think it's *outrageous* - I compared several test execution times between prod and staging and overall these changes don't really seem to make tests take longer.

It also does have some limitations. Most obviously if anything *else* that's going on causes the screen to change, it'll keep typing even if there are no screen changes actually caused by the typing. There's very little we can do about that, it's just kind of a fundamental limitation of this approach. There's one case where this problem renders the function totally useless - typing into cockpit when the constantly scrolling graph of system load is visible - so we don't use it there, we just type real slow. Note that the cockpit FreeIPA enrolment test, and the freeipa webUI test that runs after it, aren't actually working right now because for some reason the cockpit join domain screen doesn't work at all; I need to finally figure out what's going on there and fix it. If any of the blind changes to those tests don't quite work right, I'll fix it in the diff to fix the enrolment problem.

still, overall I think this is an improvement. We may run into little issues down the road and maybe have to tweak the implementations of the convenience functions and/or switch between safely and very_safely in a few places, or something, but I think this implementation gives us the tools to twiddle relatively easily. I've done quite a lot of runs with this code on staging and it seems pretty promising, it definitely reduces the number of typing fails.

adamwill added a comment.Sep 7 2016, 5:48 AM

oh, one more note - I've submitted check_type_string upstream: https://github.com/os-autoinst/os-autoinst/pull/584 . If that gets merged, we can simply drop it out of main_common.

I took the main_common name from SUSE, figured we may as well follow their conventions. It might better be called util (they have a util.pm too), I don't really know, doesn't seem like a big deal. Once this gets merged we can move several other things that aren't really class methods out of the classes and into this module (or make some other new ones, for specialized things).

adamwill updated this revision to Diff 2536.Sep 8 2016, 8:54 PM

rebase on current develop

adamwill updated this revision to Diff 2539.Sep 9 2016, 4:45 AM

rebase again

adamwill updated this revision to Diff 2541.Sep 9 2016, 8:24 PM

add handling of 'Finish configuration' state

with the slow typing, we're now more likely to hit a special case
in the install hub; if we don't finish User creation before anaconda
gets to post-install, it stops and waits, showing a 'Finish
configuration' button we have to click before the post-install steps
will run. So we just check for that button on return from the user
creation spoke, and click it if it's there. Include needles for all
languages, just on the offchance we somehow hit it with English or
French.

adamwill updated this revision to Diff 2542.Sep 9 2016, 9:53 PM

go back and type the user password again if we hit a warning bar

so even with all the slow typing and screen checking, a few times
I've seen a test somehow miss one character when typing the user
password for the second time. So let's call this the 'belt, braces,
superglue and constantly checking to see if your pants have fallen
down' approach: if there's a warning bar after we type the password
for the second time, go back and try typing it again.

I like this 'warning_bar' needle (rather than a specific 'passwords
don't match' warning needle) because it's not susceptible to font
changes or language differences, and we don't lose much by trying
to type the passwords again if the error happens to be something
other than 'passwords don't match'. And we can use the needle in
other cases in future if needed.

I can't recall if I've seen similar on the root password spoke,
but I'll probably add the same workaround there just in case.

garretraziel accepted this revision.Sep 12 2016, 4:47 PM
This revision is now accepted and ready to land.Sep 12 2016, 4:47 PM
Closed by commit rOPENQATESTSe1ec1997af5a: try to be safer when typing in X: slower, more checks (authored by adamwill). · Explain WhySep 12 2016, 5:24 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 2546

View Options

lib/anacondatest.pm

1package anacondatest; 1​package anacondatest;
2use base 'fedorabase'; 2​use base 'fedorabase';
3 3​
4# base class for all Anaconda (installation) tests 4​# base class for all Anaconda (installation) tests
5 5​
6# should be used in tests where Anaconda is running - when it makes sense 6​# should be used in tests where Anaconda is running - when it makes sense
7# to upload Anaconda logs when something fails 7​# to upload Anaconda logs when something fails
8 8​
9use testapi; 9​use testapi;
10​use main_common;
10 11​
11sub post_fail_hook { 12​sub post_fail_hook {
12 my $self = shift; 13​ my $self = shift;
13 14​
14 # if error dialog is shown, click "report" - it then creates directory structure for ABRT 15​ # if error dialog is shown, click "report" - it then creates directory structure for ABRT
15 my $has_traceback = 0; 16​ my $has_traceback = 0;
16 if (check_screen "anaconda_error", 10) { 17​ if (check_screen "anaconda_error", 10) {
17 assert_and_click "anaconda_error_report"; 18​ assert_and_click "anaconda_error_report";
▲ Show 20 Lines • Show All 90 Lines • ▼ Show 20 Line(s)78sub select_disks {
108 } 109​ }
109 110​
110 # Handle network disks. 111​ # Handle network disks.
111 if (%iscsi) { 112​ if (%iscsi) {
112 assert_and_click "anaconda_install_destination_add_network_disk"; 113​ assert_and_click "anaconda_install_destination_add_network_disk";
113 foreach my $target (keys %iscsi) { 114​ foreach my $target (keys %iscsi) {
114 my $ip = $iscsi{$target}; 115​ my $ip = $iscsi{$target};
115 assert_and_click "anaconda_install_destination_add_iscsi_target"; 116​ assert_and_click "anaconda_install_destination_add_iscsi_target";
116 type_string $ip; ​
117 wait_still_screen 2; 117​ wait_still_screen 2;
118 send_key "tab"; 118​ type_safely $ip;
119 type_string $target; 119​ wait_screen_change { send_key "tab"; };
120 wait_still_screen 2; 120​ type_safely $target;
121 # start discovery 121​ # start discovery - three tabs, enter
122 send_key "tab"; 122​ type_safely "\t\t\t\n";
123 send_key "tab"; ​
124 send_key "tab"; ​
125 send_key "ret"; ​
126 assert_and_click "anaconda_install_destination_target_login"; 123​ assert_and_click "anaconda_install_destination_target_login";
127 assert_and_click "anaconda_install_destination_select_target"; 124​ assert_and_click "anaconda_install_destination_select_target";
128 } 125​ }
129 assert_and_click "anaconda_spoke_done"; 126​ assert_and_click "anaconda_spoke_done";
130 } 127​ }
131 128​
132 # If this is a custom partitioning test, select custom partitioning. 129​ # If this is a custom partitioning test, select custom partitioning.
133 if (get_var('PARTITIONING') =~ /^custom_/) { 130​ if (get_var('PARTITIONING') =~ /^custom_/) {
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines
View Options

lib/fedoradistribution.pm

Show All 22 Lines21sub init() {
23 23​
24 $self->SUPER::init(); 24​ $self->SUPER::init();
25} 25​}
26 26​
27sub x11_start_program { 27​sub x11_start_program {
28 my ($self, $program, $timeout, $options) = @_; 28​ my ($self, $program, $timeout, $options) = @_;
29 send_key "alt-f2"; 29​ send_key "alt-f2";
30 assert_screen "desktop_runner"; 30​ assert_screen "desktop_runner";
31 type_string $program; 31​ type_string $program, 20;
32 wait_idle 5; # because of KDE dialog - SUSE guys are doing the same! 32​ wait_idle 5; # because of KDE dialog - SUSE guys are doing the same!
33 send_key "ret", 1; 33​ send_key "ret", 1;
34} 34​}
35 35​
36sub script_run { 36​sub script_run {
37 my ($self, $program, $timeout) = @_; 37​ my ($self, $program, $timeout) = @_;
38 38​
39 type_string $program; 39​ type_string $program;
40 send_key "ret", $timeout; 40​ send_key "ret", $timeout;
41} 41​}
42 42​
431; 43​1;
44# vim: set sw=4 et: 44​# vim: set sw=4 et:
View Options

lib/freeipa.pm

1package freeipa; 1​package freeipa;
2 2​
3use strict; 3​use strict;
4 4​
5use base 'Exporter'; 5​use base 'Exporter';
6use Exporter; 6​use Exporter;
7 7​
8use testapi; 8​use testapi;
9​use main_common;
9 10​
10our @EXPORT = qw/add_user start_webui/; 11​our @EXPORT = qw/add_user start_webui/;
11 12​
12# add a user with given username and surname, always uses the password 13​# add a user with given username and surname, always uses the password
13# "correcthorse". Assumes FreeIPA web UI is showing the Users screen. 14​# "correcthorse". Assumes FreeIPA web UI is showing the Users screen.
14sub add_user { 15​sub add_user {
15 my ($user, $surname) = @_; 16​ my ($user, $surname) = @_;
16 wait_still_screen 1; 17​ wait_still_screen 1;
17 assert_and_click "freeipa_webui_add_button"; 18​ assert_and_click "freeipa_webui_add_button";
18 assert_screen "freeipa_webui_add_user"; 19​ assert_screen "freeipa_webui_add_user";
19 wait_still_screen 1; 20​ wait_still_screen 1;
20 type_string $user; 21​ type_safely $user;
21 wait_still_screen 1; 22​ wait_screen_change { send_key "tab"; };
22 send_key "tab"; ​
23 # we don't need to be too careful here as the names don't matter 23​ # we don't need to be too careful here as the names don't matter
24 type_string "Test"; 24​ type_safely "Test";
garretrazielUnsubmitted
Not Done

type_string "\t\t\t\t", 20?

25 send_key "tab"; 25​ wait_screen_change { send_key "tab"; };
26 type_string $surname; 26​ type_safely $surname;
27 send_key "tab"; 27​ type_safely "\t\t\t\t";
28 send_key "tab"; 28​ type_safely "correcthorse";
29 send_key "tab"; 29​ wait_screen_change { send_key "tab"; };
30 send_key "tab"; 30​ type_safely "correcthorse\n";
31 type_string "correcthorse"; ​
32 wait_still_screen 1; ​
33 send_key "tab"; ​
34 wait_still_screen 1; ​
35 type_string "correcthorse\n"; ​
36} 31​}
37 32​
38# access the FreeIPA web UI and log in as a given user. Assumes 33​# access the FreeIPA web UI and log in as a given user. Assumes
39# Firefox is running. 34​# it's at a console ready to start Firefox.
40sub start_webui { 35​sub start_webui {
41 my ($user, $password) = @_; 36​ my ($user, $password) = @_;
42 # new tab 37​ type_string "startx /usr/bin/firefox -width 1024 -height 768 https://ipa001.domain.local\n";
43 send_key "ctrl-t"; 38​ wait_still_screen 5;
44 wait_still_screen 2; ​
45 type_string "https://ipa001.domain.local"; ​
46 # firefox's stupid 'smart' url bar is a pain. wait for things to settle. ​
47 wait_still_screen 3; ​
48 send_key "ret"; ​
49 assert_screen "freeipa_webui_login"; 39​ assert_screen "freeipa_webui_login";
50 type_string $user; 40​ type_safely $user;
51 wait_still_screen 1; 41​ wait_screen_change { send_key "tab"; };
52 send_key "tab"; 42​ type_safely $password;
53 wait_still_screen 1; ​
54 type_string $password; ​
55 wait_still_screen 1; ​
56 send_key "ret"; 43​ send_key "ret";
57 # if we logged in as 'admin' we should land on the admin 'Active 44​ # if we logged in as 'admin' we should land on the admin 'Active
58 # users' screen, otherwise we should land on the user's own page 45​ # users' screen, otherwise we should land on the user's own page
59 $user eq 'admin' ? assert_screen "freeipa_webui_users" : assert_screen "freeipa_webui_user"; 46​ $user eq 'admin' ? assert_screen "freeipa_webui_users" : assert_screen "freeipa_webui_user";
47​ wait_still_screen 3;
60} 48​}
View Options

lib/installedtest.pm

1package installedtest; 1​package installedtest;
2use base 'fedorabase'; 2​use base 'fedorabase';
3 3​
4# base class for tests that run on installed system 4​# base class for tests that run on installed system
5 5​
6# should be used when with tests, where system is already installed, e. g all parts 6​# should be used when with tests, where system is already installed, e. g all parts
7# of upgrade tests, postinstall phases... 7​# of upgrade tests, postinstall phases...
8 8​
9use testapi; 9​use testapi;
10​use main_common;
10 11​
11sub root_console { 12​sub root_console {
12 my $self = shift; 13​ my $self = shift;
13 my %args = ( 14​ my %args = (
14 tty => 1, # what TTY to login to 15​ tty => 1, # what TTY to login to
15 check => 1, # whether to fail when console wasn't reached 16​ check => 1, # whether to fail when console wasn't reached
16 @_); 17​ @_);
17 18​
Show All 35 Lines
53 54​
54sub menu_launch_type { 55​sub menu_launch_type {
55 my $self = shift; 56​ my $self = shift;
56 my $app = shift; 57​ my $app = shift;
57 # super does not work on KDE, because fml 58​ # super does not work on KDE, because fml
58 send_key 'alt-f1'; 59​ send_key 'alt-f1';
59 # srsly KDE y u so slo 60​ # srsly KDE y u so slo
60 wait_still_screen 3; 61​ wait_still_screen 3;
61 type_string "$app"; 62​ type_very_safely $app;
62 wait_still_screen 3; ​
63 send_key 'ret'; 63​ send_key 'ret';
64} 64​}
65 65​
66sub start_cockpit { 66​sub start_cockpit {
67 my $self = shift; 67​ my $self = shift;
68 my $login = shift || 0; 68​ my $login = shift || 0;
69 # run firefox directly in X as root. never do this, kids! 69​ # run firefox directly in X as root. never do this, kids!
70 type_string "startx /usr/bin/firefox -width 1024 -height 768\n"; 70​ type_string "startx /usr/bin/firefox -width 1024 -height 768 http://localhost:9090\n";
71 assert_screen "firefox"; ​
72 # open a new tab so we don't race with the default page load ​
73 # (also focuses the location bar for us) ​
74 send_key "ctrl-t"; ​
75 wait_still_screen 2; ​
76 type_string "http://localhost:9090"; ​
77 # firefox's stupid 'smart' url bar is a pain. wait for things to settle. ​
78 wait_still_screen 3; ​
79 send_key "ret"; ​
80 assert_screen "cockpit_login"; 71​ assert_screen "cockpit_login";
72​ wait_still_screen 5;
81 if ($login) { 73​ if ($login) {
82 # with cockpit 118, user name field is not highlighted by 74​ # with cockpit 118, user name field is not highlighted by
83 # default. for right now 118 is only in Rawhide, we'll have 75​ # default. for right now 118 is only in Rawhide, we'll have
84 # to adjust this conditional as necessary. 76​ # to adjust this conditional as necessary.
85 if (lc(get_var('VERSION')) eq "rawhide") { 77​ if (lc(get_var('VERSION')) eq "rawhide") {
86 wait_screen_change { send_key "tab"; }; 78​ wait_screen_change { send_key "tab"; };
87 } 79​ }
88 type_string "root"; 80​ type_safely "root";
89 send_key "tab"; 81​ wait_screen_change { send_key "tab"; };
90 type_string get_var("ROOT_PASSWORD", "weakpassword"); 82​ type_safely get_var("ROOT_PASSWORD", "weakpassword");
91 send_key "ret"; 83​ send_key "ret";
92 assert_screen "cockpit_main"; 84​ assert_screen "cockpit_main";
85​ # wait for any animation or other weirdness
86​ # can't use wait_still_screen because of that damn graph
87​ sleep 3;
93 } 88​ }
94} 89​}
95 90​
96sub repo_setup { 91​sub repo_setup {
97 # disable updates-testing and use the compose location rather than 92​ # disable updates-testing and use the compose location rather than
98 # mirrorlist, so we're testing the right packages 93​ # mirrorlist, so we're testing the right packages
99 my $location = get_var("LOCATION"); 94​ my $location = get_var("LOCATION");
100 assert_script_run 'dnf config-manager --set-disabled updates-testing'; 95​ assert_script_run 'dnf config-manager --set-disabled updates-testing';
Show All 11 Lines
View Options

lib/main_common.pm

1package main_common; 1​package main_common;
2 2​
3use strict; 3​use strict;
4 4​
5use base 'Exporter'; 5​use base 'Exporter';
6use Exporter; 6​use Exporter;
7 7​
8use testapi; 8​use testapi;
9 9​our @EXPORT = qw/run_with_error_check check_type_string type_safely type_very_safely/;
10our @EXPORT = qw/run_with_error_check/; ​
11 10​
12sub run_with_error_check { 11​sub run_with_error_check {
13 my ($func, $error_screen) = @_; 12​ my ($func, $error_screen) = @_;
14 die "Error screen appeared" if (check_screen $error_screen, 5); 13​ die "Error screen appeared" if (check_screen $error_screen, 5);
15 $func->(); 14​ $func->();
16 die "Error screen appeared" if (check_screen $error_screen, 5); 15​ die "Error screen appeared" if (check_screen $error_screen, 5);
17} 16​}
17​
18​# type the string in sets of characters at a time (default 3), waiting
19​# for a screen change after each set. Intended to be safer when the VM
20​# is busy and regular type_string may overload the input buffer. Args
21​# passed along to `type_string`. Accepts additional args:
22​# `size` - size of character groups (default 3) - set to 1 for extreme
23​# safety (but slower and more screenshotting)
24​sub check_type_string {
25​ my ($string, %args) = @_;
26​ $args{size} //= 3;
27​
28​ # split string into an array of pieces of specified size
29​ # https://stackoverflow.com/questions/372370
30​ my @pieces = unpack("(a$args{size})*", $string);
31​ for my $piece (@pieces) {
32​ wait_screen_change { type_string($piece, %args); };
33​ }
34​}
35​
36​# high-level 'type this string quite safely but reasonably fast'
37​# function whose specific implementation may vary
38​sub type_safely {
39​ my $string = shift;
40​ check_type_string($string, max_interval => 20);
41​ wait_still_screen 2;
42​}
43​
44​# high-level 'type this string extremely safely and rather slow'
45​# function whose specific implementation may vary
46​sub type_very_safely {
47​ my $string = shift;
48​ check_type_string($string, size => 1, still => 5, max_interval => 1);
49​ wait_still_screen 5;
50​}
View Options

needles/anaconda/install_process/french/install_finish_configuration_french.json

  • This file was added.
1​{
2​ "area": [
3​ {
4​ "height": 16,
5​ "type": "match",
6​ "width": 149,
7​ "xpos": 852,
8​ "ypos": 684
9​ }
10​ ],
11​ "properties": [],
12​ "tags": [
13​ "ENV-DISTRI-fedora",
14​ "LANGUAGE-french",
15​ "anaconda_install_finish_configuration"
16​ ]
17​}
View Options

needles/anaconda/install_process/french/install_finish_configuration_french.png

  • This binary file was added.
View Options

needles/anaconda/install_process/install_finish_configuration.json

  • This file was added.
1​{
2​ "area": [
3​ {
4​ "height": 17,
5​ "type": "match",
6​ "width": 115,
7​ "xpos": 886,
8​ "ypos": 684
9​ }
10​ ],
11​ "tags": [
12​ "anaconda_install_finish_configuration",
13​ "ENV-DISTRI-fedora",
14​ "LANGUAGE-english"
15​ ]
16​}
View Options

needles/anaconda/install_process/install_finish_configuration.png

  • This binary file was added.
View Options

needles/anaconda/install_process/russian/install_finish_configuration_russian.json

  • This file was added.
1​{
2​ "properties": [],
3​ "area": [
4​ {
5​ "xpos": 874,
6​ "ypos": 686,
7​ "width": 128,
8​ "height": 14,
9​ "type": "match"
10​ }
11​ ],
12​ "tags": [
13​ "ENV-DISTRI-fedora",
14​ "LANGUAGE-russian",
15​ "anaconda_install_finish_configuration"
16​ ]
17​}
18​No newline at end of file
View Options

needles/anaconda/install_process/russian/install_finish_configuration_russian.png

  • This binary file was added.
View Options

needles/anaconda/universal/warning_bar.json

  • This file was added.
1​{
2​ "area": [
3​ {
4​ "height": 20,
5​ "type": "match",
6​ "width": 414,
7​ "xpos": 283,
8​ "ypos": 741
9​ }
10​ ],
11​ "properties": [],
12​ "tags": [
13​ "ENV-DISTRI-fedora",
14​ "LANGUAGE-english",
15​ "anaconda_warning_bar"
16​ ]
17​}
18​No newline at end of file
View Options

needles/anaconda/universal/warning_bar.png

  • This binary file was added.
View Options

tests/_boot_to_anaconda.pm

1use base "anacondatest"; 1​use base "anacondatest";
2use strict; 2​use strict;
3use testapi; 3​use testapi;
4​use main_common;
4 5​
5sub run { 6​sub run {
6 my $self = shift; 7​ my $self = shift;
7 # construct the kernel params. the trick here is to wind up with 8​ # construct the kernel params. the trick here is to wind up with
8 # spaced params if GRUB or GRUBADD is set, and just spaces if not, 9​ # spaced params if GRUB or GRUBADD is set, and just spaces if not,
9 # then check if we got all spaces. We wind up with a harmless 10​ # then check if we got all spaces. We wind up with a harmless
10 # extra space if GRUBADD is set but GRUB is not. 11​ # extra space if GRUBADD is set but GRUB is not.
11 my $params = ""; 12​ my $params = "";
Show All 16 Lines
28 29​
29 # proceed to installer 30​ # proceed to installer
30 unless (get_var("KICKSTART")) 31​ unless (get_var("KICKSTART"))
31 { 32​ {
32 if (get_var("ANACONDA_TEXT")) { 33​ if (get_var("ANACONDA_TEXT")) {
33 # select that we don't want to start VNC; we want to run in text mode 34​ # select that we don't want to start VNC; we want to run in text mode
34 assert_screen "anaconda_use_text_mode", 300; 35​ assert_screen "anaconda_use_text_mode", 300;
35 type_string "2\n"; 36​ type_string "2\n";
36 ​
37 # wait for text version of Anaconda main hub 37​ # wait for text version of Anaconda main hub
38 assert_screen "anaconda_main_hub_text", 300; 38​ assert_screen "anaconda_main_hub_text", 300;
39 } else { 39​ } else {
40 # on lives, we have to explicitly launch anaconda 40​ # on lives, we have to explicitly launch anaconda
41 if (get_var('LIVE')) { 41​ if (get_var('LIVE')) {
42 assert_and_click "live_start_anaconda_icon", '', 300; 42​ assert_and_click "live_start_anaconda_icon", '', 300;
43 } 43​ }
44 my $language = get_var('LANGUAGE') || 'english'; 44​ my $language = get_var('LANGUAGE') || 'english';
45 # wait for anaconda to appear 45​ # wait for anaconda to appear
46 assert_screen "anaconda_select_install_lang", 300; 46​ assert_screen "anaconda_select_install_lang", 300;
47 # Select install language 47​ # Select install language
48 assert_and_click "anaconda_select_install_lang_input"; 48​ wait_screen_change { assert_and_click "anaconda_select_install_lang_input"; };
49 type_string "${language}"; 49​ type_safely $language;
50 # Needle filtering in main.pm ensures we will only look for the 50​ # Needle filtering in main.pm ensures we will only look for the
51 # appropriate language, here 51​ # appropriate language, here
52 assert_and_click "anaconda_select_install_lang_filtered"; 52​ assert_and_click "anaconda_select_install_lang_filtered";
53 assert_screen "anaconda_select_install_lang_selected", 3; 53​ assert_screen "anaconda_select_install_lang_selected", 3;
54 assert_and_click "anaconda_select_install_lang_continue"; 54​ assert_and_click "anaconda_select_install_lang_continue";
55 55​
56 if ( check_screen "anaconda_rawhide_accept_fate" ) { 56​ if ( check_screen "anaconda_rawhide_accept_fate" ) {
57 assert_and_click "anaconda_rawhide_accept_fate"; 57​ assert_and_click "anaconda_rawhide_accept_fate";
Show All 20 Lines
View Options

tests/_do_install_and_reboot.pm

1use base "anacondatest"; 1​use base "anacondatest";
2use strict; 2​use strict;
3use testapi; 3​use testapi;
4​use main_common;
5​
6​sub type_user_password {
7​ my $self = shift;
8​ my $user_password = get_var("USER_PASSWORD") || "weakpassword";
9​ if (get_var("SWITCHED_LAYOUT")) {
10​ # we double the password, the second time using the native
11​ # layout, so the password has both US and native characters
12​ $self->switch_layout("us");
13​ type_very_safely $user_password;
14​ $self->switch_layout("native");
15​ type_very_safely $user_password;
16​ }
17​ else {
18​ type_very_safely $user_password;
19​ }
20​}
4 21​
5sub run { 22​sub run {
6 my $self = shift; 23​ my $self = shift;
7 # Anaconda hub 24​ # Anaconda hub
8 assert_screen "anaconda_main_hub", 300; # 25​ assert_screen "anaconda_main_hub", 300; #
9 26​
10 # Begin installation 27​ # Begin installation
11 # Sometimes, the 'slide in from the top' animation messes with 28​ # Sometimes, the 'slide in from the top' animation messes with
12 # this - by the time we click the button isn't where it was any 29​ # this - by the time we click the button isn't where it was any
13 # more. So wait a sec just in case. 30​ # more. So wait a sec just in case.
14 sleep 1; 31​ sleep 1;
15 assert_and_click "anaconda_main_hub_begin_installation"; 32​ assert_and_click "anaconda_main_hub_begin_installation";
16 33​
17 # Set root password 34​ # Set root password
18 my $root_password = get_var("ROOT_PASSWORD") || "weakpassword"; 35​ my $root_password = get_var("ROOT_PASSWORD") || "weakpassword";
19 assert_and_click "anaconda_install_root_password"; 36​ assert_and_click "anaconda_install_root_password";
20 assert_screen "anaconda_install_root_password_screen"; 37​ assert_screen "anaconda_install_root_password_screen";
38​ # wait out animation
39​ wait_still_screen 2;
21 $self->switch_layout("us") if (get_var("SWITCHED_LAYOUT")); 40​ $self->switch_layout("us") if (get_var("SWITCHED_LAYOUT"));
22 type_string $root_password; 41​ # these screens seems insanely subject to typing errors, so let's
23 send_key "tab"; 42​ # type super safely. Note this doesn't really slow the test down
24 type_string $root_password; 43​ # as we still get done before the install process is complete.
44​ type_very_safely $root_password;
45​ wait_screen_change { send_key "tab"; };
46​ type_very_safely $root_password;
25 assert_and_click "anaconda_spoke_done"; 47​ assert_and_click "anaconda_spoke_done";
26 48​
27 # Set user details 49​ # Set user details
28 sleep 1; 50​ # wait out animation
51​ sleep 3;
29 my $user_login = get_var("USER_LOGIN") || "test"; 52​ my $user_login = get_var("USER_LOGIN") || "test";
30 my $user_password = get_var("USER_PASSWORD") || "weakpassword"; ​
31 assert_and_click "anaconda_install_user_creation"; 53​ assert_and_click "anaconda_install_user_creation";
32 assert_screen "anaconda_install_user_creation_screen"; 54​ assert_screen "anaconda_install_user_creation_screen";
33 type_string $user_login; 55​ # wait out animation
34 assert_and_click "anaconda_user_creation_password_input"; 56​ wait_still_screen 2;
35 if (get_var("SWITCHED_LAYOUT")) { 57​ type_very_safely $user_login;
36 # we double the password, the second time using the native 58​ type_very_safely "\t\t\t\t";
37 # layout, so the password has both US and native characters 59​ $self->type_user_password();
38 $self->switch_layout("us"); 60​ wait_screen_change { send_key "tab"; };
39 type_string $user_password; 61​ wait_still_screen 2;
40 $self->switch_layout("native"); 62​ $self->type_user_password();
41 type_string $user_password; 63​ # even with all our slow typing this still *sometimes* seems to
42 } 64​ # miss a character, so let's try again if we have a warning bar
43 else { 65​ if (check_screen "anaconda_warning_bar", 3) {
44 type_string $user_password; 66​ wait_screen_change { send_key "shift-tab"; };
45 } 67​ wait_still_screen 2;
46 send_key "tab"; 68​ $self->type_user_password();
47 if (get_var("SWITCHED_LAYOUT")) { 69​ wait_screen_change { send_key "tab"; };
48 $self->switch_layout("us"); 70​ wait_still_screen 2;
49 type_string $user_password; 71​ $self->type_user_password();
50 $self->switch_layout("native"); ​
51 type_string $user_password; ​
52 } ​
53 else { ​
54 type_string $user_password; ​
55 } 72​ }
56 assert_and_click "anaconda_install_user_creation_make_admin"; 73​ assert_and_click "anaconda_install_user_creation_make_admin";
57 assert_and_click "anaconda_spoke_done"; 74​ assert_and_click "anaconda_spoke_done";
58 75​
59 # Check username (and hence keyboard layout) if non-English 76​ # Check username (and hence keyboard layout) if non-English
60 if (get_var('LANGUAGE')) { 77​ if (get_var('LANGUAGE')) {
61 assert_screen "anaconda_install_user_created"; 78​ assert_screen "anaconda_install_user_created";
62 } 79​ }
63 80​
81​ # With the slow typing - especially with SWITCHED_LAYOUT - we
82​ # may not complete user creation until anaconda reaches post-install,
83​ # which causes a 'Finish configuration' button
84​ if (check_screen "anaconda_install_finish_configuration", 5) {
85​ assert_and_click "anaconda_install_finish_configuration";
86​ }
87​
64 # Wait for install to end. Give Rawhide a bit longer, in case 88​ # Wait for install to end. Give Rawhide a bit longer, in case
65 # we're on a debug kernel, debug kernel installs are really slow. 89​ # we're on a debug kernel, debug kernel installs are really slow.
66 my $timeout = 1800; 90​ my $timeout = 1800;
67 if (lc(get_var('VERSION')) eq "rawhide") { 91​ if (lc(get_var('VERSION')) eq "rawhide") {
68 $timeout = 2400; 92​ $timeout = 2400;
69 } 93​ }
70 assert_screen "anaconda_install_done", $timeout; 94​ assert_screen "anaconda_install_done", $timeout;
71 # wait for transition to complete so we don't click in the sidebar 95​ # wait for transition to complete so we don't click in the sidebar
72 wait_still_screen 3; 96​ wait_still_screen 3;
73 assert_and_click "anaconda_install_done"; 97​ assert_and_click "anaconda_install_done";
74 if (get_var('LIVE')) { 98​ if (get_var('LIVE')) {
75 x11_start_program("sudo reboot"); 99​ # reboot from a console, it's more reliable than the desktop
100​ # runners
101​ $self->root_console;
102​ type_string "reboot\n";
76 } 103​ }
77} 104​}
78 105​
79sub test_flags { 106​sub test_flags {
80 # without anything - rollback to 'lastgood' snapshot if failed 107​ # without anything - rollback to 'lastgood' snapshot if failed
81 # 'fatal' - whole test suite is in danger if this fails 108​ # 'fatal' - whole test suite is in danger if this fails
82 # 'milestone' - after this test succeeds, update 'lastgood' 109​ # 'milestone' - after this test succeeds, update 'lastgood'
83 # 'important' - if this fails, set the overall state to 'fail' 110​ # 'important' - if this fails, set the overall state to 'fail'
84 return { fatal => 1 }; 111​ return { fatal => 1 };
85} 112​}
86 113​
871; 114​1;
88 115​
89# vim: set sw=4 et: 116​# vim: set sw=4 et:
View Options

tests/_graphical_wait_login.pm

1use base "installedtest"; 1​use base "installedtest";
2use strict; 2​use strict;
3use testapi; 3​use testapi;
4​use main_common;
4 5​
5sub run { 6​sub run {
7​ my $self = shift;
6 # If KICKSTART is set, then the wait_time needs to consider the 8​ # If KICKSTART is set, then the wait_time needs to consider the
7 # install time. if UPGRADE, we have to wait for the entire upgrade 9​ # install time. if UPGRADE, we have to wait for the entire upgrade
8 # unless ENCRYPT_PASSWORD is set (in which case the postinstall 10​ # unless ENCRYPT_PASSWORD is set (in which case the postinstall
9 # test does the waiting) 11​ # test does the waiting)
10 my $wait_time = 300; 12​ my $wait_time = 300;
11 $wait_time = 1800 if (get_var("KICKSTART")); 13​ $wait_time = 1800 if (get_var("KICKSTART"));
12 $wait_time = 6000 if (get_var("UPGRADE") && !get_var("ENCRYPT_PASSWORD")); 14​ $wait_time = 6000 if (get_var("UPGRADE") && !get_var("ENCRYPT_PASSWORD"));
13 15​
14 # Wait for the login screen 16​ # Wait for the login screen
15 assert_screen "graphical_login", $wait_time; 17​ assert_screen "graphical_login", $wait_time;
16 # handle the qemu display buffer sometimes showing the DM from the 18​ # handle the qemu display buffer sometimes showing the DM from the
17 # *previous* boot - https://openqa.stg.fedoraproject.org/tests/17116 19​ # *previous* boot - https://openqa.stg.fedoraproject.org/tests/17116
18 wait_still_screen; 20​ wait_still_screen;
19 assert_screen "graphical_login"; 21​ assert_screen "graphical_login";
20 # do user login unless USER_LOGIN is set to string 'false' 22​ # do user login unless USER_LOGIN is set to string 'false'
21 unless (get_var("USER_LOGIN") eq "false") { 23​ unless (get_var("USER_LOGIN") eq "false") {
22 if (get_var("DESKTOP") eq 'gnome') { 24​ if (get_var("DESKTOP") eq 'gnome') {
23 # we have to hit enter to get the password dialog 25​ # we have to hit enter to get the password dialog
24 send_key "ret"; 26​ send_key "ret";
25 } 27​ }
26 assert_screen "graphical_login_input"; 28​ assert_screen "graphical_login_input";
27 type_string get_var("USER_PASSWORD", "weakpassword"); 29​ type_very_safely get_var("USER_PASSWORD", "weakpassword");
28 send_key "ret"; 30​ send_key "ret";
29 31​
30 # Handle initial-setup, for GNOME, unless START_AFTER_TEST 32​ # Handle initial-setup, for GNOME, unless START_AFTER_TEST
31 # is set in which case it will have been done already 33​ # is set in which case it will have been done already
32 if (get_var("DESKTOP") eq 'gnome' && !get_var("START_AFTER_TEST")) { 34​ if (get_var("DESKTOP") eq 'gnome' && !get_var("START_AFTER_TEST")) {
33 assert_screen "next_button", 60; 35​ assert_screen "next_button", 120;
34 # wait a bit in case of animation 36​ # wait a bit in case of animation
35 wait_still_screen 3; 37​ wait_still_screen 3;
36 for my $n (1..3) { 38​ for my $n (1..3) {
37 # click 'Next' three times, moving the mouse to avoid 39​ # click 'Next' three times, moving the mouse to avoid
38 # highlight problems, sleeping to give it time to get 40​ # highlight problems, sleeping to give it time to get
39 # to the next screen between clicks 41​ # to the next screen between clicks
40 mouse_set(100, 100); 42​ mouse_set(100, 100);
41 wait_screen_change { assert_and_click "next_button"; }; 43​ wait_screen_change { assert_and_click "next_button"; };
Show All 29 Lines
View Options

tests/_network_static.pm

1use base "anacondatest"; 1​use base "anacondatest";
2use strict; 2​use strict;
3use testapi; 3​use testapi;
4​use main_common;
4 5​
5sub run { 6​sub run {
6 my $self = shift; 7​ my $self = shift;
7 assert_and_click "anaconda_main_hub_network_host_name"; 8​ assert_and_click "anaconda_main_hub_network_host_name";
8 assert_and_click "anaconda_network_configure"; 9​ assert_and_click "anaconda_network_configure";
9 assert_and_click "anaconda_network_ipv4"; 10​ assert_and_click "anaconda_network_ipv4";
10 assert_and_click "anaconda_network_method"; 11​ assert_and_click "anaconda_network_method";
11 assert_and_click "anaconda_network_method_manual"; 12​ assert_and_click "anaconda_network_method_manual";
12 assert_and_click "anaconda_network_address_add"; 13​ assert_and_click "anaconda_network_address_add";
13 type_string get_var('ANACONDA_STATIC'); 14​ type_safely get_var('ANACONDA_STATIC');
14 wait_still_screen 2; ​
15 send_key "tab"; ​
16 # netmask is automatically set 15​ # netmask is automatically set
17 send_key "tab"; 16​ type_safely "\t\t";
18 # assume gateway 17​ # assume gateway
19 wait_still_screen 2; 18​ type_safely "10.0.2.2";
20 type_string "10.0.2.2"; ​
21 wait_still_screen 2; ​
22 send_key "ret"; ​
23 # move to DNS servers 19​ # move to DNS servers
24 send_key "tab"; 20​ type_safely "\n\t\t\t";
25 send_key "tab"; ​
26 send_key "tab"; ​
27 wait_still_screen 2; ​
28 # set DNS from host 21​ # set DNS from host
29 type_string join(',', $self->get_host_dns()); 22​ type_safely join(',', $self->get_host_dns());
30 send_key "tab"; 23​ type_safely "\t\t\t\t\t\n";
31 send_key "tab"; ​
32 send_key "tab"; ​
33 send_key "tab"; ​
34 send_key "tab"; ​
35 send_key "ret"; ​
36 # can take a bit of time as it seems to wait for all the pending 24​ # can take a bit of time as it seems to wait for all the pending
37 # DHCP requests to time out before applying the static config 25​ # DHCP requests to time out before applying the static config
38 assert_screen "anaconda_network_connected", 90; 26​ assert_screen "anaconda_network_connected", 90;
39 assert_and_click "anaconda_spoke_done"; 27​ assert_and_click "anaconda_spoke_done";
40} 28​}
41 29​
42sub test_flags { 30​sub test_flags {
43 # without anything - rollback to 'lastgood' snapshot if failed 31​ # without anything - rollback to 'lastgood' snapshot if failed
Show All 9 Lines
View Options

tests/_software_selection.pm

Show All 10 Lines5sub run {
11 if ($packageset eq 'default') { 11​ if ($packageset eq 'default') {
12 return 12​ return
13 } 13​ }
14 14​
15 assert_and_click "anaconda_main_hub_select_packages"; 15​ assert_and_click "anaconda_main_hub_select_packages";
16 16​
17 # Focus on "base environment" list 17​ # Focus on "base environment" list
18 send_key "tab"; 18​ send_key "tab";
19 sleep 1; 19​ wait_still_screen 1;
20 send_key "tab"; 20​ send_key "tab";
21​ wait_still_screen 1;
21 22​
22 # select desired environment 23​ # select desired environment
23 # go through the list 20 times at max (to prevent infinite loop when it's missing) 24​ # go through the list 20 times at max (to prevent infinite loop when it's missing)
24 for (my $i = 0; !check_screen("anaconda_".$packageset."_highlighted", 1) && $i < 20; $i++) { 25​ for (my $i = 0; !check_screen("anaconda_".$packageset."_highlighted", 1) && $i < 20; $i++) {
25 send_key "down"; 26​ send_key "down";
26 } 27​ }
27 28​
28 send_key "spc"; 29​ send_key "spc";
Show All 22 Lines
View Options

tests/desktop_browser_postinstall.pm

1use base "installedtest"; 1​use base "installedtest";
2use strict; 2​use strict;
3use testapi; 3​use testapi;
4​use main_common;
5​
6​# we are very paranoid with waits and typing speed in this test
7​# because the system can be very busy; it's effectively first boot of
8​# a freshly installed system and we're running Firefox for the first
9​# time, which causes an awful lot of system load, and there's lots of
10​# screen change potentially going on. This makes the test quite slow,
11​# but it's best to be safe. If you're working on the test you might
12​# want to tweak the waits down a bit and use type_safely instead of
13​# type_very_safely for your test runs, just to save your time.
4 14​
5sub run { 15​sub run {
6 my $self = shift; 16​ my $self = shift;
7 assert_screen 'graphical_desktop_clean'; 17​ assert_screen 'graphical_desktop_clean';
8 send_key 'alt-f1'; 18​ send_key 'alt-f1';
9 # wait out animations 19​ # wait out animations
10 wait_still_screen 2; 20​ wait_still_screen 2;
11 assert_and_click 'browser_launcher'; 21​ assert_and_click 'browser_launcher';
12 assert_screen 'browser'; 22​ assert_screen 'browser';
23​ wait_idle 5;
13 # open a new tab so we don't race with the default page load 24​ # open a new tab so we don't race with the default page load
14 # (also focuses the location bar for us) 25​ # (also focuses the location bar for us)
15 send_key 'ctrl-t'; 26​ send_key 'ctrl-t';
16 wait_still_screen 2; 27​ wait_still_screen 2;
17 # check FAS 28​ wait_idle 3;
18 type_string "https://admin.fedoraproject.org/accounts/\n"; 29​ # check FAS, typing slowly to avoid errors
30​ type_very_safely "https://admin.fedoraproject.org/accounts/\n";
19 assert_screen "browser_fas_home"; 31​ assert_screen "browser_fas_home";
20 send_key 'ctrl-t'; 32​ send_key 'ctrl-t';
21 wait_still_screen 2; 33​ wait_still_screen 2;
22 type_string "https://kernel.org\n"; 34​ wait_idle 2;
35​ type_very_safely "https://kernel.org\n";
23 assert_and_click "browser_kernelorg_patch"; 36​ assert_and_click "browser_kernelorg_patch";
24 assert_and_click "browser_download_save"; 37​ assert_and_click "browser_download_save";
25 send_key 'ret'; 38​ send_key 'ret';
26 # browsers do...something...when the download completes, and we 39​ # browsers do...something...when the download completes, and we
27 # expect there's a single click to make it go away and return 40​ # expect there's a single click to make it go away and return
28 # browser to a state where ctrl-t will work 41​ # browser to a state where ctrl-t will work
29 assert_and_click "browser_download_complete"; 42​ assert_and_click "browser_download_complete";
30 # we'll check it actually downloaded later 43​ # we'll check it actually downloaded later
31 # add-on test: at present all desktops we test (KDE, GNOME) are 44​ # add-on test: at present all desktops we test (KDE, GNOME) are
32 # using Firefox by default so we do this unconditionally, but we 45​ # using Firefox by default so we do this unconditionally, but we
33 # may need to conditionalize it if we ever test desktops whose 46​ # may need to conditionalize it if we ever test desktops whose
34 # default browser doesn't support add-ons or uses different ones 47​ # default browser doesn't support add-ons or uses different ones
35 send_key 'ctrl-t'; 48​ send_key 'ctrl-t';
36 wait_still_screen 2; 49​ wait_still_screen 2;
37 type_string "https://addons.mozilla.org/en-US/firefox/addon/ublock-origin/\n"; 50​ wait_idle 2;
51​ type_very_safely "https://addons.mozilla.org/en-US/firefox/addon/ublock-origin/\n";
38 assert_and_click "firefox_addon_add"; 52​ assert_and_click "firefox_addon_add";
39 assert_and_click "firefox_addon_install"; 53​ assert_and_click "firefox_addon_install";
40 assert_and_click "firefox_addon_success"; 54​ assert_and_click "firefox_addon_success";
41 # go to a console and check download worked 55​ # go to a console and check download worked
42 $self->root_console(tty=>3); 56​ $self->root_console(tty=>3);
43 my $user = get_var("USER_LOGIN", "test"); 57​ my $user = get_var("USER_LOGIN", "test");
44 assert_script_run "test -e /home/$user/Downloads/patch-*.xz"; 58​ assert_script_run "test -e /home/$user/Downloads/patch-*.xz";
45} 59​}
Show All 12 Lines
View Options

tests/desktop_terminal_postinstall.pm

1use base "installedtest"; 1​use base "installedtest";
2use strict; 2​use strict;
3use testapi; 3​use testapi;
4​use main_common;
4 5​
5sub run { 6​sub run {
6 my $self=shift; 7​ my $self=shift;
7 assert_screen 'graphical_desktop_clean'; 8​ assert_screen 'graphical_desktop_clean';
8 $self->menu_launch_type('terminal'); 9​ $self->menu_launch_type('terminal');
9 wait_still_screen 5; 10​ wait_still_screen 5;
10 # need to be root 11​ # need to be root
11 my $rootpass = get_var("ROOT_PASSWORD", "weakpassword"); 12​ my $rootpass = get_var("ROOT_PASSWORD", "weakpassword");
12 type_string "su\n"; 13​ type_string "su\n", 20;
13 wait_still_screen 3; 14​ wait_still_screen 3;
14 type_string "$rootpass\n"; 15​ # can't use type_safely for now as current implementation relies
16​ # on screen change checks, and there is no screen change here
17​ type_string "$rootpass\n", 1;
15 wait_still_screen 3; 18​ wait_still_screen 3;
16 # if we can do an assert_script_run, we're at a console 19​ # if we can run something successfully, we're at a console;
17 assert_script_run 'ls'; 20​ # we're reinventing assert_script_run instead of using it so
21​ # we can type safely
22​ type_very_safely "ls && echo 'ls OK' > /dev/ttyS0\n";
23​ wait_serial "ls OK" || die "terminal command failed";
18} 24​}
19 25​
20sub test_flags { 26​sub test_flags {
21 # without anything - rollback to 'lastgood' snapshot if failed 27​ # without anything - rollback to 'lastgood' snapshot if failed
22 # 'fatal' - whole test suite is in danger if this fails 28​ # 'fatal' - whole test suite is in danger if this fails
23 # 'milestone' - after this test succeeds, update 'lastgood' 29​ # 'milestone' - after this test succeeds, update 'lastgood'
24 # 'important' - if this fails, set the overall state to 'fail' 30​ # 'important' - if this fails, set the overall state to 'fail'
25 return { fatal => 1 }; 31​ return { fatal => 1 };
26} 32​}
27 33​
281; 34​1;
29 35​
30# vim: set sw=4 et: 36​# vim: set sw=4 et:
View Options

tests/disk_guided_encrypted.pm

1use base "anacondatest"; 1​use base "anacondatest";
2use strict; 2​use strict;
3use testapi; 3​use testapi;
4​use main_common;
4 5​
5sub run { 6​sub run {
6 my $self = shift; 7​ my $self = shift;
7 # Anaconda hub 8​ # Anaconda hub
8 # Go to INSTALLATION DESTINATION and ensure one disk is selected. 9​ # Go to INSTALLATION DESTINATION and ensure one disk is selected.
9 $self->select_disks(); 10​ $self->select_disks();
10 11​
11 # check "encrypt data" checkbox 12​ # check "encrypt data" checkbox
12 assert_and_click "anaconda_install_destination_encrypt_data"; 13​ assert_and_click "anaconda_install_destination_encrypt_data";
13 assert_and_click "anaconda_spoke_done"; 14​ assert_and_click "anaconda_spoke_done";
14 15​
15 # type password for disk encryption 16​ # type password for disk encryption
16 wait_idle 5; 17​ wait_idle 5;
17 if (get_var("SWITCHED_LAYOUT")) { 18​ if (get_var("SWITCHED_LAYOUT")) {
18 $self->switch_layout("us"); 19​ $self->switch_layout("us");
19 } 20​ }
20 type_string get_var("ENCRYPT_PASSWORD"); 21​ type_safely get_var("ENCRYPT_PASSWORD");
21 send_key "tab"; 22​ wait_screen_change { send_key "tab"; };
22 type_string get_var("ENCRYPT_PASSWORD"); 23​ type_safely get_var("ENCRYPT_PASSWORD");
23 if (get_var("SWITCHED_LAYOUT")) { 24​ if (get_var("SWITCHED_LAYOUT")) {
24 # work around RHBZ #1333984 25​ # work around RHBZ #1333984
25 $self->switch_layout("native"); 26​ $self->switch_layout("native");
26 } 27​ }
27 28​
28 assert_and_click "anaconda_install_destination_save_passphrase"; 29​ assert_and_click "anaconda_install_destination_save_passphrase";
29 30​
30 # Anaconda hub 31​ # Anaconda hub
Show All 15 Lines
View Options

tests/freeipa_password_change_postinstall.pm

1use base "installedtest"; 1​use base "installedtest";
2use strict; 2​use strict;
3use testapi; 3​use testapi;
4​use main_common;
4use freeipa; 5​use freeipa;
5 6​
6sub run { 7​sub run {
7 my $self = shift; 8​ my $self = shift;
8 $self->console_login(user=>'root'); 9​ $self->console_login(user=>'root');
9 # clear browser data so we don't go back to the 'admin' login 10​ # clear browser data so we don't go back to the 'admin' login
10 assert_script_run 'rm -rf /root/.mozilla'; 11​ assert_script_run 'rm -rf /root/.mozilla';
11 # clear kerberos ticket so we don't auto-auth as 'test4' 12​ # clear kerberos ticket so we don't auto-auth as 'test4'
12 assert_script_run 'kdestroy -A'; 13​ assert_script_run 'kdestroy -A';
13 type_string "startx /usr/bin/firefox -width 1024 -height 768\n"; ​
14 assert_screen "firefox"; ​
15 start_webui("test1", "batterystaple"); 14​ start_webui("test1", "batterystaple");
16 assert_and_click "freeipa_webui_actions"; 15​ assert_and_click "freeipa_webui_actions";
17 assert_and_click "freeipa_webui_reset_password_link"; 16​ assert_and_click "freeipa_webui_reset_password_link";
18 wait_still_screen 3; 17​ wait_still_screen 3;
19 type_string "batterystaple"; 18​ type_safely "batterystaple";
20 wait_still_screen 1; 19​ type_safely "\t\t";
21 send_key "tab"; 20​ type_safely "loremipsum";
22 send_key "tab"; 21​ wait_screen_change { send_key "tab"; };
23 wait_still_screen 1; 22​ type_safely "loremipsum";
24 type_string "loremipsum"; ​
25 wait_still_screen 1; ​
26 send_key "tab"; ​
27 wait_still_screen 1; ​
28 type_string "loremipsum"; ​
29 wait_still_screen 1; ​
30 assert_and_click "freeipa_webui_reset_password_button"; 23​ assert_and_click "freeipa_webui_reset_password_button";
31 wait_still_screen 2; 24​ wait_still_screen 2;
32 # log out 25​ # log out
33 assert_and_click "freeipa_webui_user_menu"; 26​ assert_and_click "freeipa_webui_user_menu";
27​ wait_still_screen 2;
34 assert_and_click "freeipa_webui_logout"; 28​ assert_and_click "freeipa_webui_logout";
35 wait_still_screen 3; 29​ wait_still_screen 3;
36 # close browser, back to console 30​ # close browser, back to console
37 send_key "ctrl-q"; 31​ send_key "ctrl-q";
38 # we don't get back to a prompt instantly and keystrokes while X 32​ # we don't get back to a prompt instantly and keystrokes while X
39 # is still shutting down are swallowed, so wait_still_screen before 33​ # is still shutting down are swallowed, so wait_still_screen before
40 # finishing (and handing off to freeipa_client_postinstall) 34​ # finishing (and handing off to freeipa_client_postinstall)
41 wait_still_screen 5; 35​ wait_still_screen 5;
Show All 20 Lines
View Options

tests/freeipa_webui_postinstall.pm

1use base "installedtest"; 1​use base "installedtest";
2use strict; 2​use strict;
3use testapi; 3​use testapi;
4​use main_common;
4use freeipa; 5​use freeipa;
5 6​
6sub run { 7​sub run {
7 my $self = shift; 8​ my $self = shift;
8 # we're restarting firefox (instead of using the same one from 9​ # we're restarting firefox (instead of using the same one from
9 # freeipa_client_postinstall) so Firefox's trusted CA store 10​ # realmd_join_cockpit) so Firefox's trusted CA store refreshes and
10 # refreshes and it trusts the web server cert 11​ # it trusts the web server cert
11 type_string "startx /usr/bin/firefox -width 1024 -height 768\n"; ​
12 assert_screen "firefox"; ​
13 start_webui("admin", "monkeys123"); 12​ start_webui("admin", "monkeys123");
14 add_user("test3", "Three"); 13​ add_user("test3", "Three");
15 add_user("test4", "Four"); 14​ add_user("test4", "Four");
16 assert_screen "freeipa_webui_users_added"; 15​ assert_screen "freeipa_webui_users_added";
17 assert_and_click "freeipa_webui_policy"; 16​ assert_and_click "freeipa_webui_policy";
17​ wait_still_screen 2;
18 assert_screen "freeipa_webui_hbac"; 18​ assert_screen "freeipa_webui_hbac";
19 assert_and_click "freeipa_webui_add_button"; 19​ assert_and_click "freeipa_webui_add_button";
20​ wait_still_screen 2;
20 assert_screen "freeipa_webui_add_policy"; 21​ assert_screen "freeipa_webui_add_policy";
21 type_string "allow-test3"; 22​ type_safely "allow-test3";
22 wait_still_screen 1; 23​ type_safely "\t\t\t";
23 send_key "tab"; ​
24 send_key "tab"; ​
25 send_key "tab"; ​
26 wait_still_screen 1; ​
27 send_key "ret"; 24​ send_key "ret";
28 assert_and_click "freeipa_webui_policy_add_user"; 25​ assert_and_click "freeipa_webui_policy_add_user";
26​ wait_still_screen 2;
29 # filter users 27​ # filter users
30 type_string "test3\n"; 28​ type_safely "test3\n";
31 # go to the correct checkbox (assert_and_click is tricky as 29​ # go to the correct checkbox (assert_and_click is tricky as
32 # we can't make sure we click the right checkbox) 30​ # we can't make sure we click the right checkbox), check it,
33 send_key "tab"; 31​ # select right arrow, click it - tab tab tab, space, tab, enter
34 send_key "tab"; 32​ type_safely "\t\t\t \t\n";
35 send_key "tab"; ​
36 # check it ​
37 send_key "spc"; ​
38 # select the right arrow ​
39 send_key "tab"; ​
40 # click it ​
41 send_key "ret"; ​
42 assert_and_click "freeipa_webui_add_button"; 33​ assert_and_click "freeipa_webui_add_button";
43 wait_still_screen 2; 34​ wait_still_screen 2;
44 send_key "pgdn"; 35​ send_key "pgdn";
45 wait_still_screen 1; 36​ wait_still_screen 1;
46 assert_and_click "freeipa_webui_policy_any_host"; 37​ assert_and_click "freeipa_webui_policy_any_host";
47 assert_and_click "freeipa_webui_policy_any_service"; 38​ assert_and_click "freeipa_webui_policy_any_service";
48 wait_still_screen 1; 39​ wait_still_screen 1;
49 send_key "pgup"; 40​ send_key "pgup";
Show All 38 Lines
View Options

tests/install_source_graphical.pm

1use base "anacondatest"; 1​use base "anacondatest";
2use strict; 2​use strict;
3use testapi; 3​use testapi;
4​use main_common;
5​use Time::HiRes qw( usleep );
4 6​
5sub run { 7​sub run {
6 my $self = shift; 8​ my $self = shift;
7 # Anaconda hub 9​ # Anaconda hub
8 assert_screen "anaconda_main_hub", 300; # 10​ assert_screen "anaconda_main_hub", 300; #
9 11​
10 # Go into the Install Source spoke 12​ # Go into the Install Source spoke
11 assert_and_click "anaconda_main_hub_installation_source"; 13​ assert_and_click "anaconda_main_hub_installation_source";
12 14​
13 # select appropriate protocol on the network 15​ # select appropriate protocol on the network
14 assert_and_click "anaconda_install_source_on_the_network"; 16​ assert_and_click "anaconda_install_source_on_the_network";
15 send_key "tab"; 17​ send_key "tab";
18​ wait_still_screen 2;
16 # select appropriate repo type for the URL by pressing 'up' a given 19​ # select appropriate repo type for the URL by pressing 'up' a given
17 # number of times. default - 3 - is https 20​ # number of times. default - 3 - is https
18 my $num = 3; 21​ my $num = 3;
19 if (get_var("REPOSITORY_GRAPHICAL") =~ m/^nfs:/) { 22​ if (get_var("REPOSITORY_GRAPHICAL") =~ m/^nfs:/) {
20 $num = 1; 23​ $num = 1;
21 } 24​ }
22 if (get_var("REPOSITORY_GRAPHICAL") =~ m/^http:/) { 25​ if (get_var("REPOSITORY_GRAPHICAL") =~ m/^http:/) {
23 $num = 4; 26​ $num = 4;
24 } 27​ }
25 for (my $i=0; $i<$num; $i++) { 28​ for (my $i=0; $i<$num; $i++) {
26 send_key "up"; 29​ send_key "up";
30​ usleep 100;
27 } 31​ }
28 # we accept any of the protocol needles here, if we happened to 32​ # we accept any of the protocol needles here, if we happened to
29 # choose wrong the test will fail soon anyhow 33​ # choose wrong the test will fail soon anyhow
30 assert_screen "anaconda_install_source_selected"; 34​ assert_screen "anaconda_install_source_selected";
31 35​
32 # insert the url 36​ # insert the url
33 send_key "tab"; 37​ wait_screen_change { send_key "tab"; };
34 my $repourl = ""; 38​ my $repourl = "";
35 39​
36 # if either MIRRORLIST_GRAPHICAL or REPOSITORY_GRAPHICAL is set, type this into 40​ # if either MIRRORLIST_GRAPHICAL or REPOSITORY_GRAPHICAL is set, type this into
37 # the repository url input 41​ # the repository url input
38 if (get_var("MIRRORLIST_GRAPHICAL")) { 42​ if (get_var("MIRRORLIST_GRAPHICAL")) {
39 $repourl = $self->get_mirrorlist_url(); 43​ $repourl = $self->get_mirrorlist_url();
40 type_string $repourl; 44​ type_safely $repourl;
41 45​
42 # select as mirror list 46​ # select as mirror list
43 assert_and_click "anaconda_install_source_repo_select_mirrorlist"; 47​ assert_and_click "anaconda_install_source_repo_select_mirrorlist";
44 } 48​ }
45 elsif (get_var("REPOSITORY_GRAPHICAL")) { 49​ elsif (get_var("REPOSITORY_GRAPHICAL")) {
46 $repourl = $self->get_full_repo(get_var("REPOSITORY_GRAPHICAL")); 50​ $repourl = $self->get_full_repo(get_var("REPOSITORY_GRAPHICAL"));
47 # strip the 'nfs:' for typing here 51​ # strip the 'nfs:' for typing here
48 $repourl =~ s/^nfs://; 52​ $repourl =~ s/^nfs://;
49 type_string $repourl; 53​ type_safely $repourl;
50 } 54​ }
51 55​
52 assert_and_click "anaconda_spoke_done"; 56​ assert_and_click "anaconda_spoke_done";
53 57​
54 # Anaconda hub 58​ # Anaconda hub
55 assert_screen "anaconda_main_hub", 300; 59​ assert_screen "anaconda_main_hub", 300;
56} 60​}
57 61​
Show All 11 Lines
View Options

tests/realmd_join_cockpit_postinstall.pm

Loading...