# A regression test "framework" for Privoxy. For documentation see:
# perldoc privoxy-regression-test.pl
#
-# $Id: privoxy-regression-test.pl,v 1.74 2011/06/29 18:35:01 fabiankeil Exp $
-#
# Wish list:
#
# - Update documentation
# - Document magic Expect Header values
# - Internal fuzz support?
#
-# Copyright (c) 2007-2011 Fabian Keil <fk@fabiankeil.de>
+# Copyright (c) 2007-2021 Fabian Keil <fk@fabiankeil.de>
#
# Permission to use, copy, modify, and distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
use Getopt::Long;
use constant {
- PRT_VERSION => 'Privoxy-Regression-Test 0.4',
+ PRT_VERSION => 'Privoxy-Regression-Test 0.7.2',
CURL => 'curl',
CLI_LOOPS => 1,
CLI_MAX_TIME => 5,
CLI_MIN_LEVEL => 0,
- # XXX: why limit at all?
+ # The reason for a maximum test level is explained in the
+ # perldoc section TEST LEVELS near the end of this file.
CLI_MAX_LEVEL => 100,
CLI_FORKS => 0,
CLI_SLEEP_TIME => 0,
+ PRIVOXY_ADDRESS => 'http://127.0.0.1:8118/',
PRIVOXY_CGI_URL => 'http://p.p/',
FELLATIO_URL => 'http://127.0.0.1:8080/',
LEADING_LOG_DATE => 1,
DEBUG_LEVEL_VERBOSE_SUCCESS => 0,
DEBUG_LEVEL_STATUS => 1,
- VERBOSE_TEST_DESCRIPTION => 1,
-
# Internal use, don't modify
# Available debug bits:
LL_SOFT_ERROR => 1,
REDIRECT_TEST =>108,
};
-sub init_our_variables () {
+sub init_our_variables() {
our $leading_log_time = LEADING_LOG_TIME;
our $leading_log_date = LEADING_LOG_DATE;
our $privoxy_cgi_url = PRIVOXY_CGI_URL;
- our $verbose_test_description = VERBOSE_TEST_DESCRIPTION;
our $log_level = get_default_log_level();
+ our $proxy = defined $ENV{'http_proxy'} ? $ENV{'http_proxy'} : PRIVOXY_ADDRESS;
}
-sub get_default_log_level () {
+sub get_default_log_level() {
my $log_level = 0;
#
############################################################################
-sub parse_tag ($) {
+sub parse_tag($) {
my $tag = shift;
return $tag;
}
-sub check_for_forbidden_characters ($) {
+sub check_for_forbidden_characters($) {
my $string = shift;
- my $allowed = '[-=\dA-Za-z~{}:./();\t ,+@"_%?&*^]';
+ my $allowed = '[-=\dA-Za-z~{}\[\]:./();\t ,+@"_%?&*^|]';
unless ($string =~ m/^$allowed*$/o) {
my $forbidden = $string;
}
}
-sub load_regressions_tests () {
+sub load_regression_tests() {
+ if (cli_option_is_set('local-test-file')) {
+ load_regression_tests_from_file(get_cli_option('local-test-file'));
+ } else {
+ load_regression_tests_through_privoxy();
+ }
+}
+
+# XXX: Contains a lot of code duplicated from load_action_files()
+# that should be factored out.
+sub load_regression_tests_from_file($) {
+ my $action_file = shift;
+
+ # initialized here
+ our %actions;
+ our @regression_tests;
+
+ my $si = 0; # Section index
+ my $ri = -1; # Regression test index
+ my $count = 0;
+
+ my $ignored = 0;
+
+ my $sticky_actions = undef;
+
+ l(LL_STATUS, "Gathering regression tests from local file " . $action_file);
+
+ open(my $ACTION_FILE, "<", $action_file)
+ or log_and_die("Failed to open $action_file: $!");
+
+ while (<$ACTION_FILE>) {
+
+ my $no_checks = 0;
+ chomp;
+ my ($token, $value) = tokenize($_);
+
+ next unless defined $token;
+
+ # Load regression tests
+
+ if (token_starts_new_test($token)) {
+
+ # Beginning of new regression test.
+ $ri++;
+ $count++;
+ enlist_new_test(\@regression_tests, $token, $value, $si, $ri, $count);
+ $no_checks = 1; # Already validated by enlist_new_test().
+ }
+
+ if ($token =~ /level\s+(\d+)/i) {
+
+ my $level = $1;
+ register_dependency($level, $value);
+ }
+
+ if ($token eq 'sticky actions') {
+
+ # Will be used by each following Sticky URL.
+ $sticky_actions = $value;
+ if ($sticky_actions =~ /{[^}]*\s/) {
+ log_and_die("'Sticky Actions' with whitespace inside the " .
+ "action parameters are currently unsupported.");
+ }
+ }
+
+ if ($si == -1 || $ri == -1) {
+ # No beginning of a test detected yet,
+ # so we don't care about any other test
+ # attributes.
+ next;
+ }
+
+ if ($token eq 'expect header') {
+
+ l(LL_FILE_LOADING, "Detected expectation: " . $value);
+ $regression_tests[$si][$ri]{'expect-header'} = $value;
+
+ } elsif ($token eq 'tag') {
+
+ next if ($ri == -1);
+
+ my $tag = parse_tag($value);
+
+ # We already checked in parse_tag() after filtering
+ $no_checks = 1;
+
+ l(LL_FILE_LOADING, "Detected TAG: " . $tag);
+
+ # Save tag for all tests in this section
+ do {
+ $regression_tests[$si][$ri]{'tag'} = $tag;
+ } while ($ri-- > 0);
+
+ $si++;
+ $ri = -1;
+
+ } elsif ($token eq 'ignore' && $value =~ /Yes/i) {
+
+ l(LL_FILE_LOADING, "Ignoring section: " . test_content_as_string($regression_tests[$si][$ri]));
+ $regression_tests[$si][$ri]{'ignore'} = 1;
+ $ignored++;
+
+ } elsif ($token eq 'expect status code') {
+
+ l(LL_FILE_LOADING, "Expecting status code: " . $value);
+ $regression_tests[$si][$ri]{'expected-status-code'} = $value;
+
+ } elsif ($token eq 'level') { # XXX: stupid name
+
+ $value =~ s@(\d+).*@$1@;
+ l(LL_FILE_LOADING, "Level: " . $value);
+ $regression_tests[$si][$ri]{'level'} = $value;
+
+ } elsif ($token eq 'method') {
+
+ l(LL_FILE_LOADING, "Method: " . $value);
+ $regression_tests[$si][$ri]{'method'} = $value;
+
+ } elsif ($token eq 'redirect destination') {
+
+ l(LL_FILE_LOADING, "Redirect destination: " . $value);
+ $regression_tests[$si][$ri]{'redirect destination'} = $value;
+
+ } elsif ($token eq 'url') {
+
+ if (defined $sticky_actions) {
+ die "WTF? Attempted to overwrite Sticky Actions"
+ if defined ($regression_tests[$si][$ri]{'sticky-actions'});
+
+ l(LL_FILE_LOADING, "Sticky actions: " . $sticky_actions);
+ $regression_tests[$si][$ri]{'sticky-actions'} = $sticky_actions;
+ } else {
+ log_and_die("Sticky URL without Sticky Actions in $action_file: $value");
+ }
+
+ } else {
+
+ # We don't use it, so we don't need
+ $no_checks = 1;
+ l(LL_STATUS, "Enabling no_checks for $token") unless $no_checks;
+ }
+
+ # XXX: Necessary?
+ unless ($no_checks) {
+ check_for_forbidden_characters($value);
+ check_for_forbidden_characters($token);
+ }
+ }
+
+ l(LL_FILE_LOADING, "Done loading " . $count . " regression tests."
+ . " Of which " . $ignored. " will be ignored)\n");
+
+}
+
+
+sub load_regression_tests_through_privoxy() {
our $privoxy_cgi_url;
our @privoxy_config;
my $curl_url = '';
my $file_number = 0;
my $feature;
+ my $privoxy_version = '(Unknown version!)';
$curl_url .= $privoxy_cgi_url;
$curl_url .= 'show-status';
$privoxy_features{$feature} = $1 if defined $feature;
$feature = undef;
+
+ } elsif (m@This is <a href="https?://www.privoxy.org/">Privoxy</a> (\d+\.\d+\.\d+) on@) {
+ $privoxy_version = $1;
}
}
- l(LL_FILE_LOADING, "Recognized " . @actionfiles . " actions files");
+ l(LL_STATUS, "Gathering regression tests from " .
+ @actionfiles . " action file(s) delivered by Privoxy $privoxy_version.");
load_action_files(\@actionfiles);
}
-sub token_starts_new_test ($) {
+sub token_starts_new_test($) {
my $token = shift;
my @new_test_directives = ('set header', 'fetch test',
return 0;
}
-sub tokenize ($) {
+sub tokenize($) {
my ($token, $value) = (undef, undef);
- # Remove leading and trailing white space.
- s@^\s*@@;
+ # Remove leading and trailing white space and a
+ # a leading <pre> which is part of the first line.
+ s@^\s*(<pre>)?@@;
s@\s*$@@;
# Reverse HTML-encoding
return ($token, $value);
}
-sub enlist_new_test ($$$$$$) {
+sub enlist_new_test($$$$$$) {
my ($regression_tests, $token, $value, $si, $ri, $number) = @_;
my $type;
"Regression test " . $number . " (section:" . $si . "):");
}
-sub load_action_files ($) {
+sub mark_matching_tests_for_skipping($) {
+ my $overwrite_condition = shift;
+
+ our @regression_tests;
+
+ for (my $s = 0; $s < @regression_tests; $s++) {
+
+ my $r = 0;
+
+ while (defined $regression_tests[$s][$r]) {
+
+ if ($regression_tests[$s][$r]{'data'} eq $overwrite_condition) {
+ my $message = sprintf("Marking test %s for ignoring. Overwrite condition: %s.",
+ $regression_tests[$s][$r]{'number'}, $overwrite_condition);
+
+ l(LL_FILE_LOADING, $message);
+
+ # XXX: Should eventually get its own key so get_skip_reason()
+ # can tell about the overwrite condition.
+ $regression_tests[$s][$r]{'ignore'} = 1;
+ }
+ $r++;
+ }
+ }
+}
+
+
+# XXX: Shares a lot of code with load_regression_tests_from_file()
+# that should be factored out.
+sub load_action_files($) {
# initialized here
our %actions;
my $ignored = 0;
- l(LL_STATUS, "Gathering regression tests from " .
- @actionfiles . " action file(s) delivered by Privoxy.");
-
for my $file_number (0 .. @actionfiles - 1) {
my $curl_url = quote($actionfiles[$file_number]);
my $actionfile = undef;
my $sticky_actions = undef;
+ my $level_offset = 0;
foreach (@{get_cgi_page_or_else($curl_url)}) {
next unless defined $token;
# Load regression tests
+ if ($token eq 'default level offset') {
+
+ $level_offset = $value;
+ l(LL_FILE_LOADING, "Setting default level offset to " . $level_offset);
+ }
if (token_starts_new_test($token)) {
$count++;
enlist_new_test(\@regression_tests, $token, $value, $si, $ri, $count);
$no_checks = 1; # Already validated by enlist_new_test().
+ if ($level_offset != 0) {
+ $regression_tests[$si][$ri]{'level'} += $level_offset;
+ }
}
if ($token =~ /level\s+(\d+)/i) {
"action parameters are currently unsupported.");
}
}
-
+
+ if ($token eq 'overwrite condition') {
+
+ l(LL_FILE_LOADING, "Detected overwrite condition: " . $value);
+ # We can only skip matching tests that have already
+ # be loaded but that is exactly what we want anyway.
+ mark_matching_tests_for_skipping($value);
+ next;
+ }
+
if ($si == -1 || $ri == -1) {
# No beginning of a test detected yet,
# so we don't care about any other test
l(LL_FILE_LOADING, "Sticky actions: " . $sticky_actions);
$regression_tests[$si][$ri]{'sticky-actions'} = $sticky_actions;
} else {
- log_and_die("Sticky URL without Sticky Actions: $value");
+ log_and_die("Sticky URL without Sticky Actions in $actionfile: $value");
}
} else {
#
############################################################################
-sub execute_regression_tests () {
+# Fisher Yates shuffle from Perl's "How do I shuffle an array randomly?" FAQ
+sub fisher_yates_shuffle($) {
+ my $deck = shift;
+ my $i = @$deck;
+ while ($i--) {
+ my $j = int rand($i+1);
+ @$deck[$i,$j] = @$deck[$j,$i];
+ }
+}
+
+sub execute_regression_tests() {
our @regression_tests;
my $loops = get_cli_option('loops');
my $failures;
my $skipped = 0;
- for (my $s = 0; $s < @regression_tests; $s++) {
+ if (cli_option_is_set('shuffle-tests')) {
+
+ # Shuffle both the test sections and
+ # the tests they contain.
+ #
+ # XXX: With the current data layout, shuffling tests
+ # from different sections isn't possible.
+ # Is this worth changing the layout?
+ fisher_yates_shuffle(\@regression_tests);
+ for (my $s = 0; $s < @regression_tests; $s++) {
+ fisher_yates_shuffle($regression_tests[$s]);
+ }
+ }
+
+ for (my $s = 0; $s < @regression_tests; $s++) {
my $r = 0;
while (defined $regression_tests[$s][$r]) {
- die "Section id mismatch" if ($s != $regression_tests[$s][$r]{'section-id'});
- die "Regression test id mismatch" if ($r != $regression_tests[$s][$r]{'regression-test-id'});
+ unless (cli_option_is_set('shuffle-tests')) {
+ die "Section id mismatch" if ($s != $regression_tests[$s][$r]{'section-id'});
+ die "Regression test id mismatch" if ($r != $regression_tests[$s][$r]{'regression-test-id'});
+ }
die "Internal error. Test executor missing."
unless defined $regression_tests[$s][$r]{executor};
}
}
-sub get_skip_reason ($) {
+sub get_skip_reason($) {
my $test = shift;
my $skip_reason = undef;
return $skip_reason;
}
-sub level_is_unacceptable ($) {
+sub level_is_unacceptable($) {
my $level = shift;
my $min_level = get_cli_option('min-level');
my $max_level = get_cli_option('max-level');
return $reason;
}
-sub dependency_unsatisfied ($) {
+sub dependency_unsatisfied($) {
my $level = shift;
our %dependencies;
return $dependency_problem;
}
-sub register_dependency ($$) {
+sub register_dependency($$) {
my $level = shift;
my $dependency = shift;
}
}
-sub execute_method_test ($) {
+sub execute_method_test($) {
my $test = shift;
+ our $privoxy_cgi_url;
+
my $buffer_ref;
my $status_code;
my $method = $test->{'data'};
# Don't complain about the 'missing' body
$curl_parameters .= '--head ' if ($method =~ /^HEAD$/i);
- $curl_parameters .= PRIVOXY_CGI_URL;
+ $curl_parameters .= $privoxy_cgi_url;
$buffer_ref = get_page_with_curl($curl_parameters);
$status_code = get_status_code($buffer_ref);
return check_status_code_result($status_code, $expected_status_code);
}
-sub execute_redirect_test ($) {
+sub execute_redirect_test($) {
my $test = shift;
my $buffer_ref;
return $success;
}
-sub execute_dumb_fetch_test ($) {
+sub execute_dumb_fetch_test($) {
my $test = shift;
+ our $privoxy_cgi_url;
+
my $buffer_ref;
my $status_code;
my $expected_status_code = $test->{'expected-status-code'};
if (defined $test->{method}) {
- $curl_parameters .= quote('--request') . quote($test->{method}) . ' ';
+ $curl_parameters .= '--request ' . quote($test->{method}) . ' ';
}
if ($test->{type} == TRUSTED_CGI_REQUEST) {
- $curl_parameters .= quote('--referer ') . quote(PRIVOXY_CGI_URL) . ' ';
+ $curl_parameters .= '--referer ' . quote($privoxy_cgi_url) . ' ';
}
$curl_parameters .= quote($test->{'data'});
return check_status_code_result($status_code, $expected_status_code);
}
-sub execute_block_test ($) {
+sub execute_block_test($) {
my $test = shift;
my $url = $test->{'data'};
return defined $final_results->{'+block'};
}
-sub execute_sticky_actions_test ($) {
+sub execute_sticky_actions_test($) {
my $test = shift;
my $url = $test->{'data'};
return $verified_actions == @sticky_actions;
}
-sub get_final_results ($) {
+sub get_final_results($) {
my $url = shift;
+ our $privoxy_cgi_url;
+
my $curl_parameters = '';
my %final_results = ();
my $final_results_reached = 0;
$url =~ s@:@%3A@g;
$url =~ s@/@%2F@g;
- $curl_parameters .= quote(PRIVOXY_CGI_URL . 'show-url-info?url=' . $url);
+ $curl_parameters .= quote($privoxy_cgi_url . 'show-url-info?url=' . $url);
foreach (@{get_cgi_page_or_else($curl_parameters)}) {
return \%final_results;
}
-sub check_status_code_result ($$) {
+sub check_status_code_result($$) {
my $status_code = shift;
my $expected_status_code = shift;
return $result;
}
-sub execute_client_header_regression_test ($) {
+sub execute_client_header_regression_test($) {
my $test = shift;
my $buffer_ref;
return check_header_result($test, $header);
}
-sub execute_server_header_regression_test ($) {
+sub execute_server_header_regression_test($) {
my $test = shift;
my $buffer_ref;
return check_header_result($test, $header);
}
-sub interpret_result ($) {
+sub interpret_result($) {
my $success = shift;
return $success ? "Success" : "Failure";
}
-sub check_header_result ($$) {
+sub check_header_result($$) {
my $test = shift;
my $header = shift;
return $success;
}
-sub get_header_name ($) {
+sub get_header_name($) {
my $header = shift;
return $header;
}
-sub get_header ($$) {
+sub get_header($$) {
our $filtered_request = '';
return $header;
}
-sub get_server_header ($$) {
+sub get_server_header($$) {
my $buffer_ref = shift;
my $test = shift;
return $header;
}
-sub get_status_code ($) {
+sub get_status_code($) {
my $buffer_ref = shift;
+ our $privoxy_cgi_url;
+
+ my $skip_connection_established_response = $privoxy_cgi_url =~ m@^https://@;
my @buffer = @{$buffer_ref};
foreach (@buffer) {
+ if ($skip_connection_established_response) {
+
+ next if (m@^HTTP/1\.1 200 Connection established@);
+ next if (m@^\r\n$@);
+ $skip_connection_established_response = 0;
+ }
+
if (/^HTTP\/\d\.\d (\d{3})/) {
return $1;
}
}
-sub get_test_keys () {
+sub get_test_keys() {
return ('tag', 'data', 'expect-header', 'ignore');
}
# XXX: incomplete
-sub test_content_as_string ($) {
+sub test_content_as_string($) {
my $test = shift;
#
############################################################################
-sub get_cgi_page_or_else ($) {
+sub get_cgi_page_or_else($) {
my $cgi_url = shift;
my $content_ref = get_page_with_curl($cgi_url);
if (200 != $status_code) {
- my $log_message = "Failed to fetch Privoxy CGI Page. " .
+ my $log_message = "Failed to fetch Privoxy CGI page '$cgi_url'. " .
"Received status code ". $status_code .
" while only 200 is acceptable.";
}
# XXX: misleading name
-sub get_show_request_with_curl ($) {
+sub get_show_request_with_curl($) {
our $privoxy_cgi_url;
my $test = shift;
# Enable the action to test
$curl_parameters .= '-H \'X-Privoxy-Control: ' . $test->{'tag'} . '\' ';
- # The header to filter
- $curl_parameters .= '-H \'' . $header . '\' ';
+
+ # Add the header to filter
+ if ($privoxy_cgi_url =~ m@^https://@ and $header =~ m@^Host:@) {
+ $curl_parameters .= '--proxy-header \'' . $header . '\' ';
+ } else {
+ $curl_parameters .= '-H \'' . $header . '\' ';
+ }
$curl_parameters .= ' ';
$curl_parameters .= $privoxy_cgi_url;
return get_cgi_page_or_else($curl_parameters);
}
-sub get_head_with_curl ($) {
+sub get_head_with_curl($) {
our $fellatio_url = FELLATIO_URL;
my $test = shift;
return get_page_with_curl($curl_parameters);
}
-sub get_page_with_curl ($) {
+sub get_page_with_curl($) {
our $proxy;
my $retries_left = get_cli_option('retries') + 1;
my $failure_reason;
- $curl_line .= ' --proxy ' . $proxy if (defined $proxy);
-
+ if (defined $proxy) {
+ $curl_line .= ' --proxy ' . quote($proxy);
+ }
# We want to see the HTTP status code
$curl_line .= " --include ";
# Let Privoxy emit two log messages less.
$curl_line .= " --user-agent '" . PRT_VERSION . "' ";
# We aren't too patient
$curl_line .= " --max-time '" . get_cli_option('max-time') . "' ";
+ # We don't want curl to treat "[]", "{}" etc. special
+ $curl_line .= " --globoff ";
$curl_line .= $parameters;
# XXX: still necessary?
#
############################################################################
-sub array_as_string ($) {
+sub array_as_string($) {
my $array_ref = shift;
my $string = '';
return $string;
}
-sub show_test ($) {
+sub show_test($) {
my $test = shift;
log_message('Test is:' . test_content_as_string($test));
}
# Conditional log
-sub l ($$) {
+sub l($$) {
our $log_level;
my $this_level = shift;
my $message = shift;
log_message($message) if ($log_level & $this_level);
}
-sub log_and_die ($) {
+sub log_and_die($) {
my $message = shift;
log_message('Oh noes. ' . $message . ' Fatal error. Exiting.');
exit;
}
-sub log_message ($) {
+sub log_message($) {
my $message = shift;
$message = $time_stamp . ": " . $message;
}
- printf(STDERR "%s\n", $message);
+ printf("%s\n", $message);
}
-sub log_result ($$) {
+sub log_result($$) {
- our $verbose_test_description;
our $filtered_request;
my $test = shift;
my $result = shift;
my $number = shift;
- my $message = '';
+ my $message = sprintf("%s for test %d",
+ interpret_result($result),
+ $test->{'number'});
- $message .= interpret_result($result);
- $message .= " for test ";
- $message .= $number;
- $message .= '/';
- $message .= $test->{'number'};
- $message .= '/';
- $message .= $test->{'section-id'};
- $message .= '/';
- $message .= $test->{'regression-test-id'};
- $message .= '.';
+ if (cli_option_is_set('verbose')) {
+ $message .= sprintf(" (%d/%d/%d)", $number,
+ $test->{'section-id'},
+ $test->{'regression-test-id'});
+ }
- if ($verbose_test_description) {
+ $message .= '. ';
- if ($test->{'type'} == CLIENT_HEADER_TEST) {
+ if ($test->{'type'} == CLIENT_HEADER_TEST) {
- $message .= ' Header ';
- $message .= quote($test->{'data'});
- $message .= ' and tag ';
- $message .= quote($test->{'tag'});
+ $message .= 'Header ';
+ $message .= quote($test->{'data'});
+ $message .= ' and tag ';
+ $message .= quote($test->{'tag'});
- } elsif ($test->{'type'} == SERVER_HEADER_TEST) {
+ } elsif ($test->{'type'} == SERVER_HEADER_TEST) {
- $message .= ' Request Header ';
- $message .= quote($test->{'data'});
- $message .= ' and tag ';
- $message .= quote($test->{'tag'});
+ $message .= 'Request Header ';
+ $message .= quote($test->{'data'});
+ $message .= ' and tag ';
+ $message .= quote($test->{'tag'});
- } elsif ($test->{'type'} == DUMB_FETCH_TEST) {
+ } elsif ($test->{'type'} == DUMB_FETCH_TEST) {
- $message .= ' URL ';
- $message .= quote($test->{'data'});
- $message .= ' and expected status code ';
- $message .= quote($test->{'expected-status-code'});
+ $message .= 'URL ';
+ $message .= quote($test->{'data'});
+ $message .= ' and expected status code ';
+ $message .= quote($test->{'expected-status-code'});
- } elsif ($test->{'type'} == TRUSTED_CGI_REQUEST) {
+ } elsif ($test->{'type'} == TRUSTED_CGI_REQUEST) {
- $message .= ' CGI URL ';
- $message .= quote($test->{'data'});
- $message .= ' and expected status code ';
- $message .= quote($test->{'expected-status-code'});
+ $message .= 'CGI URL ';
+ $message .= quote($test->{'data'});
+ $message .= ' and expected status code ';
+ $message .= quote($test->{'expected-status-code'});
- } elsif ($test->{'type'} == METHOD_TEST) {
+ } elsif ($test->{'type'} == METHOD_TEST) {
- $message .= ' HTTP method ';
- $message .= quote($test->{'data'});
- $message .= ' and expected status code ';
- $message .= quote($test->{'expected-status-code'});
+ $message .= 'HTTP method ';
+ $message .= quote($test->{'data'});
+ $message .= ' and expected status code ';
+ $message .= quote($test->{'expected-status-code'});
- } elsif ($test->{'type'} == BLOCK_TEST) {
+ } elsif ($test->{'type'} == BLOCK_TEST) {
- $message .= ' Supposedly-blocked URL: ';
- $message .= quote($test->{'data'});
+ $message .= 'Supposedly-blocked URL: ';
+ $message .= quote($test->{'data'});
- } elsif ($test->{'type'} == STICKY_ACTIONS_TEST) {
+ } elsif ($test->{'type'} == STICKY_ACTIONS_TEST) {
- $message .= ' Sticky Actions: ';
- $message .= quote($test->{'sticky-actions'});
- $message .= ' and URL: ';
- $message .= quote($test->{'data'});
+ $message .= 'Sticky Actions: ';
+ $message .= quote($test->{'sticky-actions'});
+ $message .= ' and URL: ';
+ $message .= quote($test->{'data'});
- } elsif ($test->{'type'} == REDIRECT_TEST) {
+ } elsif ($test->{'type'} == REDIRECT_TEST) {
- $message .= ' Redirected URL: ';
- $message .= quote($test->{'data'});
- $message .= ' and redirect destination: ';
- $message .= quote($test->{'redirect destination'});
+ $message .= 'Redirected URL: ';
+ $message .= quote($test->{'data'});
+ $message .= ' and redirect destination: ';
+ $message .= quote($test->{'redirect destination'});
- } else {
+ } else {
- die "Incomplete support for test type " . $test->{'type'} . " detected.";
- }
+ die "Incomplete support for test type " . $test->{'type'} . " detected.";
}
log_message($message) if (!$result or cli_option_is_set('verbose'));
}
-sub quote ($) {
+sub quote($) {
my $s = shift;
return '\'' . $s . '\'';
}
-sub print_version () {
- printf PRT_VERSION . "\n" . 'Copyright (C) 2007-2011 Fabian Keil <fk@fabiankeil.de>' . "\n";
+sub print_version() {
+ printf PRT_VERSION . "\n";
}
-sub list_test_types () {
+sub list_test_types() {
my %test_types = (
'Client header test' => CLIENT_HEADER_TEST,
'Server header test' => 2,
}
}
-sub help () {
+sub help() {
our %cli_options;
+ our $privoxy_cgi_url;
print_version();
[--help]
[--header-fuzzing]
[--level]
+ [--local-test-file]
[--loops $cli_options{'loops'}]
[--max-level $cli_options{'max-level'}]
[--max-time $cli_options{'max-time'}]
[--min-level $cli_options{'min-level'}]
- [--privoxy-address]
+ [--privoxy-address $cli_options{'privoxy-address'}]
+ [--privoxy-cgi-prefix $privoxy_cgi_url]
[--retries $cli_options{'retries'}]
[--show-skipped-tests]
+ [--shuffle-tests]
[--sleep-time $cli_options{'sleep-time'}]
[--test-number]
[--verbose]
exit(0);
}
-sub init_cli_options () {
+sub init_cli_options() {
our %cli_options;
our $log_level;
+ our $proxy;
$cli_options{'debug'} = $log_level;
$cli_options{'forks'} = CLI_FORKS;
$cli_options{'min-level'} = CLI_MIN_LEVEL;
$cli_options{'sleep-time'}= CLI_SLEEP_TIME;
$cli_options{'retries'} = CLI_RETRIES;
+ $cli_options{'privoxy-address'} = $proxy;
}
-sub parse_cli_options () {
+sub parse_cli_options() {
our %cli_options;
our $log_level;
+ our $privoxy_cgi_url;
init_cli_options();
GetOptions (
+ 'check-bad-ssl' => \$cli_options{'check-bad-ssl'},
'debug=i' => \$cli_options{'debug'},
'forks=i' => \$cli_options{'forks'},
'fuzzer-address=s' => \$cli_options{'fuzzer-address'},
'header-fuzzing' => \$cli_options{'header-fuzzing'},
'help' => \&help,
'level=i' => \$cli_options{'level'},
+ 'local-test-file=s' => \$cli_options{'local-test-file'},
'loops=i' => \$cli_options{'loops'},
'max-level=i' => \$cli_options{'max-level'},
'max-time=i' => \$cli_options{'max-time'},
'min-level=i' => \$cli_options{'min-level'},
'privoxy-address=s' => \$cli_options{'privoxy-address'},
+ 'privoxy-cgi-prefix=s' => \$privoxy_cgi_url, # XXX: Should use cli_options()
'retries=i' => \$cli_options{'retries'},
+ 'shuffle-tests' => \$cli_options{'shuffle-tests'},
'show-skipped-tests' => \$cli_options{'show-skipped-tests'},
'sleep-time=i' => \$cli_options{'sleep-time'},
'test-number=i' => \$cli_options{'test-number'},
$log_level |= $cli_options{'debug'};
}
-sub cli_option_is_set ($) {
+sub cli_option_is_set($) {
our %cli_options;
my $cli_option = shift;
return defined $cli_options{$cli_option};
}
-sub get_cli_option ($) {
+sub get_cli_option($) {
our %cli_options;
my $cli_option = shift;
}
}
-sub main () {
+sub check_bad_ssl() {
+ my $failures = 0;
+ my @bad_ssl_urls_to_check = (
+ "https://expired.badssl.com/",
+ "https://wrong.host.badssl.com/",
+ "https://self-signed.badssl.com/",
+ "https://untrusted-root.badssl.com/",
+ "https://no-common-name.badssl.com/", # XXX: Certificate has expired ...
+ "https://no-subject.badssl.com/", # XXX: Certificate has expired ...
+ "https://incomplete-chain.badssl.com/",
+ );
+ # This is needed for get_status_code() to skip the
+ # status code from the "HTTP/1.1 200 Connection established"
+ # reply.
+ our $privoxy_cgi_url = "https://p.p/";
+
+ log_message("Requesting pages from badssl.com with various " .
+ "certificate problems. This will only work if Privoxy " .
+ "has been configured properly and can reach the Internet.");
+
+ foreach my $url_to_check (@bad_ssl_urls_to_check) {
+ my ($buffer_ref, $status_code);
+ log_message("Requesting $url_to_check");
+
+ $buffer_ref = get_page_with_curl($url_to_check);
+ $status_code = get_status_code($buffer_ref);
+
+ if (!check_status_code_result($status_code, "403")) {
+ $failures++;
+ }
+
+ }
+ if ($failures == 0) {
+ log_message("All requests resulted in status code 403 as expected.");
+ } else {
+ log_message("There were $failures requests that did not result in status code 403!");
+ }
+
+ return $failures;
+}
+
+sub main() {
init_our_variables();
parse_cli_options();
init_proxy_settings('vanilla-proxy');
- load_regressions_tests();
+ if (cli_option_is_set('check-bad-ssl')) {
+ exit check_bad_ssl();
+ }
+ load_regression_tests();
init_proxy_settings('fuzz-proxy');
start_forks(get_cli_option('forks')) if cli_option_is_set('forks');
execute_regression_tests();
=head1 SYNOPSIS
-B<privoxy-regression-test> [B<--debug bitmask>] [B<--forks> forks]
+B<privoxy-regression-test> [B<--check-bad-ssl>] [B<--debug bitmask>] [B<--forks> forks]
[B<--fuzzer-feeding>] [B<--fuzzer-feeding>] [B<--help>] [B<--level level>]
-[B<--loops count>] [B<--max-level max-level>] [B<--max-time max-time>]
-[B<--min-level min-level>] B<--privoxy-address proxy-address>
-[B<--retries retries>] [B<--test-number test-number>]
+[B<--local-test-file testfile>] [B<--loops count>] [B<--max-level max-level>]
+[B<--max-time max-time>] [B<--min-level min-level>] B<--privoxy-address proxy-address>
+B<--privoxy-cgi-prefix cgi-prefix> [B<--retries retries>] [B<--test-number test-number>]
[B<--show-skipped-tests>] [B<--sleep-time> seconds] [B<--verbose>]
[B<--version>]
# Redirected URL = http://www.example.com/redirect-me
# Redirect Destination = http://www.example.org/redirected
+To skip a test, add the following line:
+
+ # Ignore = Yes
+
+The difference between a skipped test and a removed one is that removing
+a test affects the numbers of the following tests, while a skipped test
+is still loaded and thus keeps the test numbers unchanged.
+
+Sometimes user modifications intentionally conflict with tests in the
+default configuration and thus cause test failures. Adding the Ignore
+directive to the failing tests works but is inconvenient as the directive
+is likely to get lost with the next update.
+
+Overwrite conditions are an alternative and can be added in any action
+file as long as the come after the test that is expected to fail.
+They cause all previous tests that match the condition to be skipped.
+
+It is recommended to put the overwrite condition below the custom Privoxy
+section that causes the expected test failure and before the custom test
+that verifies that tests the now expected behaviour. Example:
+
+ # The following section is expected to overwrite a section in
+ # default.action, whose effect is being tested. Thus also disable
+ # the test that is now expected to fail and add a new one.
+ #
+ {+block{Facebook makes Firefox even more unstable. Do not want.}}
+ # Overwrite condition = http://apps.facebook.com/onthefarm/track.php?creative=&cat=friendvisit&subcat=weeds&key=a789a971dc687bee4c20c044834fabdd&next=index.php%3Fref%3Dnotif%26visitId%3D898835505
+ # Blocked URL = http://apps.facebook.com/
+ .facebook./
+
=head1 TEST LEVELS
All tests have test levels to let the user
connections. Use the B<--max-level> option to run them
as well.
+The "Default level offset" directive can be used to change
+the default level by a given value. This directive affects
+all tests located after it until the end of the file or a another
+"Default level offset" directive is reached. The purpose of this
+directive is to make it more convenient to skip similar tests in
+a given file without having to remove or disable the tests completely.
+
=head1 OPTIONS
+B<--check-bad-ssl> Instead of running the regression tests
+as described above, request pages from badssl.com with bad
+certificates to verify that Privoxy is detecting the
+certificate issues. Only works if Privoxy has been compiled
+with FEATURE_HTTPS_INSPECTION, has been configured properly
+and can reach the Internet.
+
B<--debug bitmask> Add the bitmask provided as integer
to the debug settings.
B<--level level> Only execute tests with the specified B<level>.
+B<--local-test-file test-file> Do not get the tests
+through Privoxy's web interface, but use a single local
+file. Not recommended for testing Privoxy, but can be useful
+to "misappropriate" Privoxy-Regression-Test to test other
+stuff, like webserver configurations.
+
B<--loop count> Loop through the regression tests B<count> times.
Useful to feed a fuzzer, or when doing stress tests with
several Privoxy-Regression-Test instances running at the same
B<--privoxy-address proxy-address> Privoxy's listening address.
If it's not set, the value of the environment variable http_proxy
-will be used. B<proxy-address> has to be specified in http_proxy
-syntax.
+will be used unless the variable isn't set in which case
+http://127.0.0.1:8118/ will be used. B<proxy-address> has to
+be specified in http_proxy syntax.
+
+B<--privoxy-cgi-prefix privoxy-cgi-prefix> The prefix to use when
+building URLs that are supposed to reach Privoxy's CGI interface.
+If it's not set, B<http://p.p/> is used, which is supposed to work
+with the default Privoxy configuration.
+If Privoxy has been built with B<FEATURE_HTTPS_INSPECTION> enabled,
+and if https inspection is activated with the B<+https-inspection>
+action, this option can be used with
+B<https://p.p/> provided the system running Privoxy-Regression-Test
+has been configured to trust the certificate used by Privoxy.
+Note that there are currently two tests in the official
+B<regression-tests.action> file that are expected to fail when
+using a B<privoxy-cgi-prefix> with B<https://> and aren't automatically
+skipped.
B<--retries retries> Retry B<retries> times.
B<--show-skipped-tests> Log skipped tests even if verbose mode is off.
+B<--shuffle-tests> Shuffle test sections and their tests before
+executing them. When combined with B<--forks>, this can increase
+the chances of detecting race conditions. Of course some problems
+are easier to detect without this option.
+
B<--sleep-time seconds> Wait B<seconds> between tests. Useful when
debugging issues with systems that don't log with millisecond precision.
=head1 SEE ALSO
-privoxy(1) curl(1)
+privoxy(8) curl(1)
=head1 AUTHOR
projects / privoxy.git / blobdiff