238 lines
7.3 KiB
Perl
238 lines
7.3 KiB
Perl
# This Source Code Form is subject to the terms of the Mozilla Public
|
|
# License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
#
|
|
# This Source Code Form is "Incompatible With Secondary Licenses", as
|
|
# defined by the Mozilla Public License, v. 2.0.
|
|
|
|
|
|
|
|
##################
|
|
#Bugzilla Test 12#
|
|
######Errors######
|
|
|
|
use 5.10.1;
|
|
use strict;
|
|
use warnings;
|
|
|
|
use lib qw(. lib t);
|
|
|
|
use Bugzilla::Constants;
|
|
use Bugzilla::WebService::Constants;
|
|
|
|
use File::Spec;
|
|
use Support::Files;
|
|
use Support::Templates;
|
|
use Test::More;
|
|
|
|
my %Errors = ();
|
|
|
|
# Just a workaround for template errors handling. Define it as used.
|
|
push @{$Errors{code}{template_error}{used_in}{'Bugzilla/Error.pm'}}, 0;
|
|
|
|
# Define files to test. Each file would have a list of error messages, if any.
|
|
my %test_templates = ();
|
|
my %test_modules = ();
|
|
|
|
# Find all modules
|
|
foreach my $module (@Support::Files::testitems) {
|
|
$test_modules{$module} = ();
|
|
}
|
|
|
|
# Find all error templates
|
|
# Process all files since otherwise handling template hooks would became too
|
|
# hairy. But let us do it only once.
|
|
|
|
foreach my $include_path (@include_paths) {
|
|
foreach my $path (@{$actual_files{$include_path}}) {
|
|
my $file = File::Spec->catfile($include_path, $path);
|
|
$file =~ s/\s.*$//; # nuke everything after the first space
|
|
$file =~ s|\\|/|g if ON_WINDOWS; # convert \ to / in path if on windows
|
|
$test_templates{$file} = ()
|
|
if $file =~ m#global/(code|user)-error\.html\.tmpl#;
|
|
|
|
# Make sure the extension is not disabled
|
|
if ($file =~ m#^(extensions/[^/]+/)#) {
|
|
$test_templates{$file} = ()
|
|
if ! -e "${1}disabled"
|
|
&& $file =~ m#global/(code|user)-error-errors\.html\.tmpl#;
|
|
}
|
|
}
|
|
}
|
|
|
|
# Count the tests. The +1 is for checking the WS_ERROR_CODE errors.
|
|
my $tests = (scalar keys %test_modules) + (scalar keys %test_templates) + 1;
|
|
exit 0 if !$tests;
|
|
|
|
# Set requested tests counter.
|
|
plan tests => $tests;
|
|
|
|
# Collect all errors defined in templates
|
|
foreach my $file (keys %test_templates) {
|
|
$file =~ m|template/([^/]+).*/global/([^/]+)-error(?:-errors)?\.html\.tmpl|;
|
|
my $lang = $1;
|
|
my $errtype = $2;
|
|
|
|
if (! open (TMPL, $file)) {
|
|
Register(\%test_templates, $file, "could not open file --WARNING");
|
|
next;
|
|
}
|
|
|
|
my $lineno=0;
|
|
while (my $line = <TMPL>) {
|
|
$lineno++;
|
|
if ($line =~ /\[%\s[A-Z]+\s*error\s*==\s*"(.+)"\s*%\]/) {
|
|
my $errtag = $1;
|
|
if ($errtag =~ /\s/) {
|
|
Register(\%test_templates, $file,
|
|
"has an error definition \"$errtag\" at line $lineno with "
|
|
. "space(s) embedded --ERROR");
|
|
}
|
|
else {
|
|
push @{$Errors{$errtype}{$errtag}{defined_in}{$lang}{$file}}, $lineno;
|
|
}
|
|
}
|
|
}
|
|
close(TMPL);
|
|
}
|
|
|
|
# Collect all used errors from cgi/pm files
|
|
foreach my $file (keys %test_modules) {
|
|
$file =~ s/\s.*$//; # nuke everything after the first space (#comment)
|
|
next if (!$file); # skip null entries
|
|
if (! open (TMPL, $file)) {
|
|
Register(\%test_modules, $file, "could not open file --WARNING");
|
|
next;
|
|
}
|
|
|
|
my $lineno = 0;
|
|
while (my $line = <TMPL>) {
|
|
last if $line =~ /^__END__/; # skip the POD (at least in
|
|
# Bugzilla/Error.pm)
|
|
$lineno++;
|
|
if ($line =~
|
|
/^[^#]*\b(Throw(Code|User)Error|(user_)?error\s+=>)\s*\(?\s*["'](.*?)['"]/) {
|
|
my $errtype;
|
|
# If it's a normal ThrowCode/UserError
|
|
if ($2) {
|
|
$errtype = lc($2);
|
|
}
|
|
# If it's an AUTH_ERROR tag
|
|
else {
|
|
$errtype = $3 ? 'user' : 'code';
|
|
}
|
|
my $errtag = $4;
|
|
push @{$Errors{$errtype}{$errtag}{used_in}{$file}}, $lineno;
|
|
}
|
|
}
|
|
|
|
close(TMPL);
|
|
}
|
|
|
|
# Now let us start the checks
|
|
|
|
foreach my $errtype (keys %Errors) {
|
|
foreach my $errtag (keys %{$Errors{$errtype}}) {
|
|
# Check for undefined tags
|
|
if (!defined $Errors{$errtype}{$errtag}{defined_in}) {
|
|
UsedIn($errtype, $errtag, "any");
|
|
}
|
|
else {
|
|
# Check for all languages!!!
|
|
my @langs = ();
|
|
foreach my $lang (@languages) {
|
|
if (!defined $Errors{$errtype}{$errtag}{defined_in}{$lang}) {
|
|
push @langs, $lang;
|
|
}
|
|
}
|
|
if (scalar @langs) {
|
|
UsedIn($errtype, $errtag, join(', ',@langs));
|
|
}
|
|
|
|
# Now check for tag usage in all DEFINED languages
|
|
foreach my $lang (keys %{$Errors{$errtype}{$errtag}{defined_in}}) {
|
|
if (!defined $Errors{$errtype}{$errtag}{used_in}) {
|
|
DefinedIn($errtype, $errtag, $lang);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
# And make sure that everything defined in WS_ERROR_CODE
|
|
# is actually a valid error.
|
|
foreach my $err_name (keys %{WS_ERROR_CODE()}) {
|
|
if (!defined $Errors{'code'}{$err_name}
|
|
&& !defined $Errors{'user'}{$err_name})
|
|
{
|
|
Register(\%test_modules, 'WS_ERROR_CODE',
|
|
"Error tag '$err_name' is used in WS_ERROR_CODE in"
|
|
. " Bugzilla/WebService/Constants.pm"
|
|
. " but not defined in any template, and not used in any code.");
|
|
}
|
|
}
|
|
|
|
# Now report modules results
|
|
foreach my $file (sort keys %test_modules) {
|
|
Report($file, @{$test_modules{$file}});
|
|
}
|
|
|
|
# And report WS_ERROR_CODE results
|
|
Report('WS_ERROR_CODE', @{$test_modules{'WS_ERROR_CODE'}});
|
|
|
|
# Now report templates results
|
|
foreach my $file (sort keys %test_templates) {
|
|
Report($file, @{$test_templates{$file}});
|
|
}
|
|
|
|
sub Register {
|
|
my ($hash, $file, $message, $warning) = @_;
|
|
# If set to 1, $warning will avoid the test to fail.
|
|
$warning ||= 0;
|
|
push(@{$hash->{$file}}, {'message' => $message, 'warning' => $warning});
|
|
}
|
|
|
|
sub Report {
|
|
my ($file, @errors) = @_;
|
|
if (scalar @errors) {
|
|
# Do we only have warnings to report or also real errors?
|
|
my @real_errors = grep {$_->{'warning'} == 0} @errors;
|
|
# Extract error messages.
|
|
@errors = map {$_->{'message'}} @errors;
|
|
if (scalar(@real_errors)) {
|
|
ok(0, "$file has ". scalar(@errors) ." error(s):\n" . join("\n", @errors));
|
|
}
|
|
else {
|
|
ok(1, "--WARNING $file has " . scalar(@errors) .
|
|
" unused error tag(s):\n" . join("\n", @errors));
|
|
}
|
|
}
|
|
else {
|
|
# This is used for both code and template files, so let's use
|
|
# file-independent phrase
|
|
ok(1, "$file uses error tags correctly");
|
|
}
|
|
}
|
|
|
|
sub UsedIn {
|
|
my ($errtype, $errtag, $lang) = @_;
|
|
$lang = $lang || "any";
|
|
foreach my $file (keys %{$Errors{$errtype}{$errtag}{used_in}}) {
|
|
Register(\%test_modules, $file,
|
|
"$errtype error tag '$errtag' is used at line(s) ("
|
|
. join (',', @{$Errors{$errtype}{$errtag}{used_in}{$file}})
|
|
. ") but not defined for language(s): $lang");
|
|
}
|
|
}
|
|
sub DefinedIn {
|
|
my ($errtype, $errtag, $lang) = @_;
|
|
foreach my $file (keys %{$Errors{$errtype}{$errtag}{defined_in}{$lang}}) {
|
|
Register(\%test_templates, $file,
|
|
"$errtype error tag '$errtag' is defined at line(s) ("
|
|
. join (',', @{$Errors{$errtype}{$errtag}{defined_in}{$lang}{$file}})
|
|
. ") but is not used anywhere", 1);
|
|
}
|
|
}
|
|
|
|
exit 0;
|