Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-04-02 20:42:49 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

b=323768

Browse Source 
- change tests references to testcases
- fix changed field abbreviations
- disabled testgroup/subgroup editing -> interim step before test runs
- display lists of all testgroups/subgroups to which a testcase belongs when viewing a testcase
- updated database schema
- updated database population script.
- NOTE: due to changes in the underlying db structure, it will be necessary for users to establish new linkages between products, platforms, testgroup, subgroups, and testcases (documented in populatedb.sql)
- when running tests, ony display testgroups that match the chosen branch

b=322585
- fix defaulttestgroup display when continuing to test

b=334871
- allow fulltext searching of testcases by summary, steps, and expected results
This commit is contained in:
ccooper%deadsquid.com 2006-06-05 04:07:29 +00:00
parent 681b024298
commit 7d6c5dc95e
11 changed files with 424 additions and 263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
webtools/litmus/advanced_search.cgi
View File

@ -203,7 +203,7 @@ if ($c->param) {
my $products = Litmus::FormWidget->getProducts;
my $platforms = Litmus::FormWidget->getUniquePlatforms;
my $test_groups = Litmus::FormWidget->getTestGroups;
my $test_ids = Litmus::FormWidget->getTestIDs;
my $testcases = Litmus::FormWidget->getTestcaseIDs;
my $result_statuses = Litmus::FormWidget->getResultStatuses;
my $branches = Litmus::FormWidget->getBranches;
my $locales = Litmus::FormWidget->getLocales;
@ -221,7 +221,7 @@ my $vars = {
products => $products,
platforms => $platforms,
test_groups => $test_groups,
test_ids => $test_ids,
testcases => $testcases,
result_statuses => $result_statuses,
branches => $branches,
locales => $locales,

79
webtools/litmus/populatedb.pl
View File

@ -127,9 +127,11 @@ if ($reset_db) {
}
# UPGRADE THE SCHEMA
# Now we need to deal with upgrading old installations by adding new fields and
# indicies to the schema. To do this, we use the helpful Litmus::DBTools module
# Note that anything changed here should also be added to schema.pl for new
# Now we need to deal with upgrading old installations by adding new fields
# and indicies to the schema. To do this, we use the helpful Litmus::DBTools
# module.
#
# NOTE: anything changed here should also be added to schema.pl for new
# installations
use Litmus::DBTools;
my $dbtool = Litmus::DBTools->new($dbh);
@ -141,6 +143,8 @@ $dbtool->AddField("users", "password", "varchar(255)");
$dbtool->AddField("users", "realname", "varchar(255)");
$dbtool->AddField("users", "is_admin", "tinyint(1) default '0'");
$dbtool->AddField("users", "irc_nickname", "varchar(32)");
$dbtool->DropIndex("users", "email");
$dbtool->DropIndex("users", "irc_nickname");
$dbtool->AddUniqueKey("users","email","(email)");
$dbtool->AddUniqueKey("users","irc_nickname","(irc_nickname)");
$dbtool->AddKey("users","bugzilla_uid","(bugzilla_uid)");
@ -171,22 +175,71 @@ $dbtool->DropField("test_results", "vetting_status_id");
$dbtool->DropTable("validity_lookup");
$dbtool->DropTable("vetting_status_lookup");
$dbtool->AddField("test_groups", "enabled", "tinyint(1) default '1'");
$dbtool->AddKey("test_groups","enabled","(enabled)");
$dbtool->AddField("subgroups", "enabled", "tinyint(1) default '1'");
$dbtool->AddKey("subgroups","enabled","(enabled)");
$dbtool->DropField("test_groups", "obsolete");
$dbtool->RenameTable("test_groups","testgroups");
$dbtool->AddField("testgroups", "enabled", "tinyint(1) NO NULL default '1'");
$dbtool->AddKey("testgroups","enabled","(enabled)");
$dbtool->DropField("testgroups", "obsolete");
$dbtool->DropField("testgroups", "expiration_days");
$dbtool->AddField("users", "enabled", "tinyint(1) default '1'");
$dbtool->AddField("subgroups", "enabled", "tinyint(1) NOT NULL default '1'");
$dbtool->AddKey("subgroups","enabled","(enabled)");
$dbtool->AddField("subgroups", "product_id", "tinyint(4) NOT NULL");
$dbtool->AddKey("subgroups","product_id","(product_id)");
$dbtool->DropField("subgroups", "testgroup_id");
$dbtool->AddField("users", "enabled", "tinyint(1) NOT NULL default '1'");
$dbtool->AddKey("users","enabled","(enabled)");
$dbtool->DropField("users", "disabled");
# Remove reference to test_status_lookup
$dbtool->AddField("tests", "enabled", "tinyint(1) NOT NULL default '1'");
$dbtool->AddKey("tests","enabled","(enabled)");
$dbtool->DropField("tests", "status_id");
$dbtool->DropTable("test_status_lookup");
# Remove reference to test_status_lookup
$dbtool->RenameTable("tests","testcases");
$dbtool->AddField("testcases", "enabled", "tinyint(1) NOT NULL default '1'");
$dbtool->AddKey("testcases","enabled","(enabled)");
$dbtool->DropIndex("testcases", "test_id");
$dbtool->RenameField("testcases", "test_id", "testcase_id");
$dbtool->AddKey("testcases","testcase_id","(testcase_id)");
$dbtool->AddKey("testcases","summary_2","(summary, steps, expected_results)");
$dbtool->ChangeFieldType("testcases", "community_enabled", 'tinyint(1) default "1"');
$dbtool->AddField("testcases", "product_id", "tinyint(4) NOT NULL");
$dbtool->AddKey("testcases","product_id","(product_id)");
$dbtool->DropField("testcases", "subgroup_id");
$dbtool->DropIndex("test_results", "test_id");
$dbtool->RenameField("test_results", "test_id", "testcase_id");
$dbtool->AddKey("test_results","testcase_id","(testcase_id)");
$dbtool->RenameField("test_results", "buildid", "build_id");
$dbtool->ChangeFieldType("test_results", "build_id", 'int(10) unsigned');
$dbtool->AddKey("test_results","build_id","(build_id)");
$dbtool->DropIndex("test_results", "result_id");
$dbtool->RenameField("test_results", "result_id", "result_status_id");
$dbtool->AddKey("test_results","result_status_id","(result_status_id)");
$dbtool->DropField("test_results", "platform_id");
$dbtool->AddField("branches", "enabled", "tinyint(1) NOT NULL default '1'");
$dbtool->AddKey("branches","enabled","(enabled)");
$dbtool->DropField("platforms", "product_id");
print "Schema update complete.\n\n";
print <<EOS;
Due to the schema changes introduced, and depending on the when you last
updated your schema, you may now need to update/normalize your data as
well. This will include, but may not be limited to:
* populating the platform_products table;
* updating/normalizing platforms;
* updating/normalizing platform_ids in test_results;
* updating/normalizing opsyses;
* updating/normalizing opsys_ids in test_results;
* populating the subgroup_testgroups table;
* populating the testcase_subgroups table;
* filling in product_ids for each testcase/subgroup;
* populating the testgroup_branches table
EOS
# javascript cache
print "Rebuilding JS cache...";
require Litmus::Cache;

17
webtools/litmus/process_test.cgi
View File

@ -82,7 +82,7 @@ foreach my $curtestid (@tests) {
next;
}
my $curtest = Litmus::DB::Test->retrieve($curtestid);
my $curtest = Litmus::DB::Testcase->retrieve($curtestid);
unless ($curtest) {
# oddly enough, the test doesn't exist
next;
@ -101,7 +101,7 @@ foreach my $curtestid (@tests) {
$ua->platform($curtest->product()),
"NULL", # no way to autodetect the opsys
$ua->branch($curtest->product()),
$ua->buildid(),
$ua->build_id(),
);
}
@ -122,8 +122,8 @@ foreach my $curtestid (@tests) {
exit;
}
my $result = Litmus::DB::Result->retrieve($c->param("testresult_".$curtestid));
$resultcounts{$result->name()}++;
my $result_status = Litmus::DB::ResultStatus->retrieve($c->param("testresult_".$curtestid));
$resultcounts{$result_status->name()}++;
my $note = $c->param("comment_".$curtestid);
my $bugs = $c->param("bugs_".$curtestid);
@ -136,20 +136,19 @@ foreach my $curtestid (@tests) {
if ($c->param("isSimpleTest")) {
$user = $user || Litmus::DB::User->search(email => 'web-tester@mozilla.org')->next();
} else {
$user = $user || Litmus::Auth::getCookie()->userid();
$user = $user || Litmus::Auth::getCookie()->user_id();
}
my $tr = Litmus::DB::Testresult->create({
user => $user,
testid => $curtest,
testcase => $curtest,
timestamp => $time,
last_updated => $time,
useragent => $ua,
result => $result,
platform => $sysconfig->platform(),
result_status => $result_status,
opsys => $sysconfig->opsys(),
branch => $sysconfig->branch(),
buildid => $sysconfig->buildid(),
build_id => $sysconfig->build_id(),
locale_abbrev => $sysconfig->locale(),
});

84
webtools/litmus/run_tests.cgi
View File

@ -29,6 +29,9 @@
use strict;
use Time::HiRes qw( gettimeofday tv_interval );
my $t0 = [gettimeofday];
use Litmus;
use Litmus::Error;
use Litmus::DB::Product;
@ -73,41 +76,45 @@ sub page_sysSetup {
# an area to test:
sub page_pickGroupSubgroup {
my $sysconfig;
my $product = Litmus::DB::Product->retrieve($c->param("product"));
if (! $product) {
print $c->header();
invalidInputError("Invalid product ".$c->param("product"));
print $c->header();
invalidInputError("Invalid product ".$c->param("product"));
}
Litmus::Auth::requireLogin("run_tests.cgi");
my $branch;
if ($c->param("continuetesting")) {
# they have already gotten setup and just want to
# pick a new group or subgroup:
$sysconfig = Litmus::SysConfig->getCookie($product);
if (!$sysconfig) {page_pickProduct()};
if (!$sysconfig) {
page_pickProduct()
};
print $c->header();
$branch = $sysconfig->branch();
} else {
$branch = Litmus::DB::Branch->retrieve($c->param("branch"));
if (! $branch) {
print $c->header();
invalidInputError("Invalid branch ".$c->param("branch"));
}
$sysconfig = Litmus::SysConfig->processForm($c);
# get the user id and set a sysconfig cookie
$c->storeCookie($sysconfig->setCookie());
print $c->header();
}
# get all groups for the product:
my @groups = Litmus::DB::Testgroup->search(product => $sysconfig->product(),
enabled => 1,
{ order_by => 'name ASC' });
Litmus::Auth::requireLogin("run_tests.cgi");
# Get all groups for the current branch.
my @groups = Litmus::DB::Testgroup->search_EnabledByBranch($branch->branch_id());
# all possible subgroups per group:
my %subgroups;
foreach my $curgroup (@groups) {
my @subgroups = Litmus::DB::Subgroup->search(testgroup => $curgroup,
enabled => 1,
{ order_by => 'sort_order ASC' });
$subgroups{$curgroup->testgroupid()} = \@subgroups;
my @subgroups = Litmus::DB::Subgroup->search_EnabledByTestgroup($curgroup->testgroup_id());
$subgroups{$curgroup->testgroup_id()} = \@subgroups;
}
my $defaultgroup = "";
@ -115,7 +122,7 @@ sub page_pickGroupSubgroup {
$defaultgroup = Litmus::DB::Testgroup->
retrieve($c->param("defaulttestgroup"));
}
my $vars = {
title => $title,
user => Litmus::Auth::getCurrentUser(),
@ -133,6 +140,11 @@ sub page_pickGroupSubgroup {
Litmus->template()->process("runtests/selectgroupsubgroup.html.tmpl",
$vars) ||
internalError(Litmus->template()->error());
if ($Litmus::Config::DEBUG) {
my $elapsed = tv_interval ( $t0 );
printf "<div id='pageload'>Page took %f seconds to load.</div>", $elapsed;
}
}
# display a page of testcases:
@ -140,36 +152,42 @@ sub page_test {
# the form has a subgroup radio button set for each possible group, named
# subgroup_n where n is the group id number. We get the correct
# subgroup based on whatever group the user selected:
my $subgroupid = $c->param("subgroup_".$c->param("group"));
my $testgroup_id = $c->param("group");
my $subgroup_id = $c->param("subgroup_".$testgroup_id);
print $c->header();
# get the tests to display:
my @tests = Litmus::DB::Test->search(
subgroup => $subgroupid,
enabled => 1,
{ order_by => 'sort_order ASC' }
);
my @tests = Litmus::DB::Testcase->search_CommunityEnabledBySubgroup($subgroup_id);
# get all possible test results:
my @results = Litmus::DB::Result->retrieve_all();
# my @results = Litmus::DB::Result->retrieve_all();
my $sysconfig = Litmus::SysConfig->getCookie($tests[0]->product());
my $cookie = Litmus::Auth::getCookie();
my $vars = {
title => $title,
sysconfig => Litmus::SysConfig->getCookie($tests[0]->product()),
group => Litmus::DB::Subgroup->retrieve($subgroupid)->testgroup(),
subgroup => Litmus::DB::Subgroup->retrieve($subgroupid),
tests => \@tests,
results => \@results,
istrusted => Litmus::Auth::istrusted(Litmus::Auth::getCookie()),
title => $title,
sysconfig => Litmus::SysConfig->getCookie($tests[0]->product()),
group => Litmus::DB::Testgroup->retrieve($testgroup_id),
subgroup => Litmus::DB::Subgroup->retrieve($subgroup_id),
tests => \@tests,
# results => \@results,
defaultemail => $cookie,
show_admin => Litmus::Auth::istrusted($cookie),
istrusted => Litmus::Auth::istrusted($cookie),
};
my $cookie = Litmus::Auth::getCookie();
$vars->{"defaultemail"} = $cookie;
$vars->{"show_admin"} = Litmus::Auth::istrusted($cookie);
$vars->{"istrusted"} = Litmus::Auth::istrusted($cookie);
Litmus->template()->process("runtests/testdisplay.html.tmpl", $vars) ||
internalError(Litmus->template()->error());
if ($Litmus::Config::DEBUG) {
my $elapsed = tv_interval ( $t0 );
printf "<div id='pageload'>Page took %f seconds to load.</div>", $elapsed;
}
}

252
webtools/litmus/schema.pl
View File

@ -28,22 +28,26 @@
our $table;
$table{branches} =
'branch_id smallint not null primary key auto_increment,
product_id tinyint not null,
'branch_id smallint(6) not null primary key auto_increment,
product_id tinyint(4) not null,
name varchar(64) not null,
detect_regexp varchar(255),
enabled tinyint(1) default 1,
index(product_id),
index(name)';
index(name),
index(detect_regexp),
index(enabled)
';
$table{build_type_lookup} =
'build_type_id tinyint not null primary key auto_increment,
'build_type_id tinyint(4) not null primary key auto_increment,
name varchar(64) not null,
index(name)';
$table{exit_status_lookup} =
'exit_status_id tinyint not null primary key auto_increment,
'exit_status_id tinyint(4) not null primary key auto_increment,
name varchar(64) not null,
index(name)';
@ -55,29 +59,36 @@ $table{locale_lookup} =
index(name)';
$table{log_type_lookup} =
'log_type_id tinyint not null primary key auto_increment,
'log_type_id tinyint(4) not null primary key auto_increment,
name varchar(64) not null,
index(name)';
$table{opsyses} =
'opsys_id smallint not null primary key auto_increment,
platform_id smallint not null,
'opsys_id smallint(6) not null primary key auto_increment,
platform_id smallint(6) not null,
name varchar(64) not null,
detect_regexp varchar(255),
index(platform_id),
index(name)';
index(name),
index(detect_regexp)';
$table{platform_products} =
'platform_id smallint(6) not null,
product_id tinyint(4) not null,
primary key (platform_id, product_id)';
$table{platforms} =
'platform_id smallint not null primary key auto_increment,
product_id tinyint not null,
name varchar(64) not null,
detect_regexp varchar(255),
iconpath varchar(255),
index(product_id),
index(name)';
index(name),
index(detect_regexp),
index(iconpath)';
$table{products} =
'product_id tinyint not null primary key auto_increment,
@ -85,49 +96,52 @@ $table{products} =
iconpath varchar(255),
enabled tinyint default \'1\',
index(name),
unique key(name),
index(iconpath),
index(enabled)';
$table{subgroups} =
'subgroup_id smallint not null primary key auto_increment,
testgroup_id smallint not null,
name varchar(64) not null,
sort_order smallint(6),
testrunner_group_id int,
enabled tiniyint(1) default "1",
$table{sessions} =
'session_id int(11) not null primary key auto_increment,
user_id int(11) not null,
sessioncookie varchar(255) not null,
expires datetime not null,
index(user_id),
index(sessioncookie),
index(expires)';
$table{subgroup_testgroups} =
'subgroup_id smallint(6) not null,
testgroup_id smallint(6) not null,
primary key(subgroup_id, testgroup_id';
$table{subgroups} =
'subgroup_id smallint(6) not null primary key auto_increment,
name varchar(64) not null,
sort_order smallint(6) not null default "1",
testrunner_group_id int(11),
enabled tiniyint(1) default "1",
product_id tinyint(4) not null,
index(testgroup_id),
index(name),
index(sort_order),
index(testrunner_group_id),
index(enabled)';
index(enabled),
index(product_id)';
$table{test_format_lookup} =
'format_id tinyint not null primary key auto_increment,
'format_id tinyint(4) not null primary key auto_increment,
name varchar(255) not null,
index(name)';
$table{test_groups} =
'testgroup_id smallint not null primary key auto_increment,
product_id tinyint not null,
name varchar(64) not null,
expiration_days smallint not null,
enabled tinyint(1) default "1",
testrunner_plan_id int,
index(product_id),
index(name),
index(expiration_days),
index(enabled),
index(testrunner_plan_id)';
$table{test_result_bugs} =
'test_result_id int not null primary key auto_increment,
'test_result_id int(11) not null primary key auto_increment,
last_updated datetime not null,
submission_time datetime not null,
user_id int,
bug_id int not null,
user_id int(11),
bug_id int(11) not null,
index(test_result_id),
index(last_updated),
@ -135,11 +149,11 @@ $table{test_result_bugs} =
index(user_id)';
$table{test_result_comments} =
'comment_id int not null primary key auto_increment,
test_result_id int not null,
'comment_id int(11) not null primary key auto_increment,
test_result_id int(11) not null,
last_updated datetime not null,
submission_time datetime not null,
user_id int,
user_id int(11),
comment text,
index(test_result_id),
@ -148,12 +162,12 @@ $table{test_result_comments} =
index(user_id)';
$table{test_result_logs} =
'log_id int not null primary key auto_increment,
test_result_id int not null,
'log_id int(11) not null primary key auto_increment,
test_result_id int(11) not null,
last_updated datetime not null,
submission_time datetime not null,
log_text longtext,
log_type_id tinyint not null default \'1\',
log_type_id tinyint(4) not null default \'1\',
index(test_result_id),
index(last_updated),
@ -163,7 +177,7 @@ $table{test_result_logs} =
$table{test_result_status_lookup} =
'result_status_id smallint not null primary key auto_increment,
'result_status_id smallint(6) not null primary key auto_increment,
name varchar(64) not null,
style varchar(255) not null,
class_name varchar(16),
@ -173,22 +187,21 @@ $table{test_result_status_lookup} =
index(class_name)';
$table{test_results} =
'testresult_id int not null primary key auto_increment,
test_id int not null,
'testresult_id int(11) not null primary key auto_increment,
testcase_id int(11) not null,
last_updated datetime,
submission_time datetime,
user_id int,
platform_id smallint,
opsys_id smallint,
branch_id smallint,
buildid varchar(45),
user_id int(11),
opsys_id smallint(6),
branch_id smallint(6),
build_id int(10),
user_agent varchar(255),
result_id smallint,
build_type_id tinyint not null default \'1\',
result_status_id smallint(6),
build_type_id tinyint(4) not null default \'1\',
machine_name varchar(64),
exit_status_id tinyint not null default \'1\',
duration_ms int unsigned,
talkback_id int unsigned,
exit_status_id tinyint(4) not null default \'1\',
duration_ms int(11) unsigned,
talkback_id int(11) unsigned,
locale_abbrev varchar(16) not null default \'en-US\',
valid tinyint(1) not null default \'1\',
vetted tinyint(1) not null default \'0\',
@ -197,15 +210,15 @@ $table{test_results} =
validated_timestamp datetime,
vetted_timestamp datetime,
index(test_id),
index(testcase_id),
index(last_updated),
index(submission_time),
index(user_id),
index(platform_id),
index(opsys_id),
index(branch_id),
index(build_id),
index(user_agent),
index(result_id),
index(result_status_id),
index(build_type_id),
index(machine_name),
index(exit_status_id),
@ -218,42 +231,110 @@ $table{test_results} =
index(vetted_by_user_id),
index(validated_timestamp),
index(vetted_timestamp)';
$table{tests} =
'test_id int not null primary key auto_increment,
subgroup_id smallint not null,
$table{test_run_branches} =
'test_run_id int(11) not null,
branch_id smallint(6) not null,
primary key(test_run_id, branch_id)';
$table{test_run_build_ids} =
'test_run_id int(11) not null,
build_id int(10) not null,
primary key(test_run_id, build_id)';
$table{test_run_opsyses} =
'test_run_id int(11) not null,
opsys_id smallint(6) not null,
primary key(test_run_id, opsys_id)';
$table{test_run_platforms} =
'test_run_id int(11) not null,
platform_id smallint(6) not null,
primary key(test_run_id, platform_id)';
$table{test_runs} =
'test_run_id int(11) not null primary key auto increment,
testgroup_id smallint(6) not null,
name varchar(64) not null,
description varchar(255),
start_timestamp datetime not null,
finish_timestamp datetime not null,
enabled tinyint(1) not null default "1",
index(testgroup_id),
index(name),
index(description),
index(start_timestamp),
index(finish_timestamp),
index(enabled)';
$table{testcase_subgroups} =
'testcase_id int(11) not null,
subgroup_id smallint(6) not null,
primary key(testcase_id, subgroup_id)';
$table{testcases} =
'testcase_id int(11) not null primary key auto_increment,
summary varchar(255) not null,
details text,
enabled tinyint(1) not null default \'1\',
community_enabled tinyint(1),
format_id tinyint not null default \'1\',
regression_bug_id int,
community_enabled tinyint(1) not null default \'1\',
format_id tinyint(4) not null default \'1\',
regression_bug_id int(11),
steps longtext,
expected_results longtext,
sort_order smallint not null default \'1\',
author_id int not null,
sort_order smallint(6) not null default \'1\',
author_id int(11) not null,
creation_date datetime not null,
last_updated datetime not null,
version smallint not null default \'1\',
testrunner_case_id int,
testrunner_case_version int,
version smallint(6) not null default \'1\',
testrunner_case_id int(11),
testrunner_case_version int(11),
product_id tinyint(4) not null,
index(subgroup_id),
index(summary),
index(status_id),
index(enabled),
index(community_enabled),
index(format_id),
index(regression_bug_id),
index(steps(255)),
index(expected_results(255)),
index(author_id),
index(creation_date),
index(last_updated),
index(testrunner_case_id)';
index(testrunner_case_id),
index(testrunner_case_version),
index(product_id),
fulltext key(summary,steps,expected_results)';
$table{testgroup_branches} =
'testgroup_id smallint(6) not null,
branch_id smallint(6) not null,
primary key(testgroup_id, branch_id)';
$table{testgroups} =
'testgroup_id smallint(6) not null primary key auto_increment,
product_id tinyint(4) not null,
name varchar(64) not null,
enabled tinyint(1) default "1",
testrunner_plan_id int(11),
index(product_id),
index(name),
index(enabled),
index(testrunner_plan_id)';
$table{users} =
'user_id int not null primary key auto_increment,
'user_id int(11) not null primary key auto_increment,
bugzilla_uid int,
email varchar(255),
email varchar(255) not null,
password varchar(255),
realname varchar(255),
irc_nickname varchar(32),
@ -262,17 +343,8 @@ $table{users} =
index(bugzilla_uid),
unique index(email),
index(realname),
unique index(irc_nickname),
index(password),
index(realname),
index(disabled),
index(is_admin)';
$table{sessions} =
'session_id int not null primary key auto_increment,
user_id int not null,
sessioncookie varchar(255) not null,
expires datetime not null,
index(user_id),
index(sessioncookie),
index(expires)';

2
webtools/litmus/search_results.cgi
View File

@ -89,7 +89,7 @@ if ($c->param) {
push @where, {field => $param,
value => $value};
$where_criteria .= "Test group is \'".$c->param($param)."\'<br/>";
} elsif ($param eq 'test_id') {
} elsif ($param eq 'testcase_id') {
my $value = quotemeta($c->param($param));
push @where, {field => $param,
value => $value};

198
webtools/litmus/show_test.cgi
View File

@ -41,107 +41,135 @@ my $c = Litmus->cgi();
print $c->header();
my $testid = $c->param("id");
my $vars;
my $cookie = Litmus::Auth::getCookie();
$vars->{"defaultemail"} = $cookie;
$vars->{"show_admin"} = Litmus::Auth::istrusted($cookie);
$vars->{"show_admin"} = Litmus::Auth::istrusted($cookie);
if (! $testid) {
Litmus->template()->process("show/enter_id.html.tmpl", $vars) ||
$vars->{'default_match_limit'} = Litmus::DB::Testcase->getDefaultMatchLimit();
$vars->{'default_relevance_threshold'} = Litmus::DB::Testcase->getDefaultRelevanceThreshold();
if (! $c->param) {
Litmus->template()->process("show/search_for_testcases.tmpl", $vars) ||
internalError(Litmus->template()->error());
exit;
}
# Process changes to testcases:
# Only users with canedit can edit testcases.
my @changed;
my $update_status = 0;
if ($c->param("editingTestcases") &&
Litmus::Auth::canEdit(Litmus::Auth::getCookie())) {
if ($c->param("id")) {
my $testcase_id = $c->param("id");
# the editingTestcases param contains a comma-separated list of
# testids that the user has made changes to (well, has clicked
# the edit button for).
@changed = split(',' => $c->param("editingTestcases"));
foreach my $editid (@changed) {
my $edittest = Litmus::DB::Test->retrieve($editid);
if (! $edittest) {invalidInputError("Test $editid does not exist")}
# Process changes to testcases:
# Only users with canedit can edit testcases.
my @changed;
my $update_status = 0;
if ($c->param("editingTestcases") &&
Litmus::Auth::canEdit(Litmus::Auth::getCookie())) {
$edittest->summary($c->param("summary_edit_$editid"));
my $product = Litmus::DB::Product->retrieve($c->param("product_$editid"));
my $group = Litmus::DB::Testgroup->retrieve($c->param("testgroup_$editid"));
my $subgroup = Litmus::DB::Subgroup->retrieve($c->param("subgroup_$editid"));
requireField("product", $product);
requireField("group", $group);
requireField("subgroup", $subgroup);
$edittest->product($product);
$edittest->testgroup($group);
$edittest->subgroup($subgroup);
$edittest->steps($c->param("steps_edit_$editid"));
$edittest->expected_results($c->param("results_edit_$editid"));
if ($c->param("enabled_$editid")) {
$edittest->enabled(1);
if ($c->param("communityenabled_$editid")) {
$edittest->communityenabled(1);
# the editingTestcases param contains a comma-separated list of
# testcase IDs that the user has made changes to (well, has clicked
# the edit button for).
@changed = split(',' => $c->param("editingTestcases"));
foreach my $editid (@changed) {
my $edittest = Litmus::DB::Testcase->retrieve($editid);
if (! $edittest) {invalidInputError("Testcase $editid does not exist")}
$edittest->summary($c->param("summary_edit_$editid"));
my $product = Litmus::DB::Product->retrieve($c->param("product_$editid"));
# my $group = Litmus::DB::Testgroup->retrieve($c->param("testgroup_$editid"));
# my $subgroup = Litmus::DB::Subgroup->retrieve($c->param("subgroup_$editid"));
requireField("product", $product);
# requireField("group", $group);
# requireField("subgroup", $subgroup);
$edittest->product($product);
# $edittest->testgroup($group);
# $edittest->subgroup($subgroup);
$edittest->steps($c->param("steps_edit_$editid"));
$edittest->expected_results($c->param("results_edit_$editid"));
if ($c->param("enabled_$editid")) {
$edittest->enabled(1);
if ($c->param("communityenabled_$editid")) {
$edittest->communityenabled(1);
} else {
$edittest->communityenabled(0);
}
} else {
$edittest->enabled(0);
$edittest->communityenabled(0);
}
} else {
$edittest->enabled(0);
$edittest->communityenabled(0);
my $r_bug_id = $c->param("regression_bug_id_$editid");
if ($r_bug_id eq '' or $r_bug_id eq '0') {
undef $r_bug_id;
}
$edittest->regression_bug_id($r_bug_id);
$edittest->sort_order($c->param("sort_order_$editid"));
$edittest->author_id(Litmus::Auth::getCurrentUser());
$edittest->last_updated(&Date::Manip::UnixDate("now","%q"));
$edittest->version($edittest->version()+1);
my $update_status = $edittest->update();
my $status = "";
my $message = "";
if ($update_status) {
$status = "success";
$message = "Testcase ID# $editid updated successfully.";
} else {
$status = "failure";
$message = "Unable to update testcase ID# $editid.";
}
$vars->{'onload'} = "toggleMessage('$status','$message');";
}
my $r_bug_id = $c->param("regression_bug_id_$editid");
if ($r_bug_id eq '' or $r_bug_id eq '0') {
undef $r_bug_id;
}
$edittest->regression_bug_id($r_bug_id);
$edittest->sort_order($c->param("sort_order_$editid"));
$edittest->author_id(Litmus::Auth::getCurrentUser());
$edittest->last_updated(&Date::Manip::UnixDate("now","%q"));
$edittest->version($edittest->version()+1);
my $update_status = $edittest->update();
my $status = "";
my $message = "";
if ($update_status) {
$status = "success";
$message = "Testcase ID# $editid updated successfully.";
} else {
$status = "failure";
$message = "Unable to update testcase ID# $editid.";
}
$vars->{'onload'} = "toggleMessage('$status','$message');";
} elsif ($c->param("editingTestcases") &&
! Litmus::Auth::canEdit(Litmus::Auth::getCookie())) {
invalidInputError("You do not have permissions to edit testcases. ");
}
} elsif ($c->param("editingTestcases") &&
! Litmus::Auth::canEdit(Litmus::Auth::getCookie())) {
invalidInputError("You do not have permissions to edit testcases. ");
my $testcase = Litmus::DB::Testcase->retrieve($testcase_id);
if (! $testcase) {
invalidInputError("\"$testcase_id\" is not a valid testcase ID.");
}
my @testgroups = Litmus::DB::Testgroup->search_EnabledByTestcase($testcase_id);
my @subgroups = Litmus::DB::Subgroup->search_EnabledByTestcase($testcase_id);
my @result_statuses = Litmus::DB::ResultStatus->retrieve_all();
my $showallresults = $c->param("showallresults") || "";
my @where;
push @where, { field => 'testcase_id', value => $testcase_id };
my @order_by;
push @order_by, { field => 'created', direction => 'DESC' };
my $test_results = Litmus::DB::Testresult->getTestResults(\@where,\@order_by);
$vars->{'testcase'} = $testcase;
$vars->{'sysconfig'} = Litmus::SysConfig->getCookie($testcase->product());
$vars->{'testgroups'} = \@testgroups;
$vars->{'subgroups'} = \@subgroups;
$vars->{'result_statuses'} = \@result_statuses;
$vars->{'showallresults'} = $showallresults;
$vars->{'test_results'} = $test_results;
Litmus->template()->process("show/show.html.tmpl", $vars) ||
internalError(Litmus->template()->error());
exit;
}
my $test = Litmus::DB::Test->retrieve($testid);
if ($c->param("text_snippet")) {
my $text_snippet = $c->param("text_snippet");
my $match_limit = $c->param("match_limit");
my $relevance_threshold = $c->param("relevance_threshold");
my @testcases = Litmus::DB::Testcase->getFullTextMatches($text_snippet,
$match_limit,
$relevance_threshold);
$vars->{'testcases'} = \@testcases;
$vars->{'search_string_for_display'} = "Full-Text Search: \"$text_snippet\"";
}
if (! $test) {
invalidInputError("Test $testid is not a valid test id");
}
Litmus->template()->process("show/search_for_testcases.tmpl", $vars) ||
internalError(Litmus->template()->error());
my @results = Litmus::DB::Result->retrieve_all();
my $showallresults = $c->param("showallresults") || "";
my @where;
push @where, { field => 'test_id', value => $testid };
my @order_by;
push @order_by, { field => 'created', direction => 'DESC' };
my $test_results = Litmus::DB::Testresult->getTestResults(\@where,\@order_by);
$vars->{'test'} = $test;
$vars->{'results'} = \@results;
$vars->{'showallresults'} = $showallresults;
$vars->{'test_results'} = $test_results;
Litmus->template()->process("show/show.html.tmpl", $vars) ||
internalError(Litmus->template()->error());

4
webtools/litmus/simpletest.cgi
View File

@ -86,11 +86,11 @@ sub showTest {
my $test = Litmus::DB::Test->search_random_test($pid)->next();
my @results = Litmus::DB::Result->retrieve_all();
my @result_statuses = Litmus::DB::ResultStatus->retrieve_all();
my $vars = {
test => $test,
results => \@results,
result_statuses => \@result_statuses,
};
$vars->{"defaultemail"} = Litmus::Auth::getCookie();

8
webtools/litmus/single_result.cgi
View File

@ -56,7 +56,7 @@ if ($c->param && $c->param('id')) {
my $cookie = Litmus::Auth::getCookie();
my $user;
if ($cookie) {
$user = $cookie->userid();
$user = $cookie->user_id();
if ($user and
$c->param('new_bugs') and
@ -70,7 +70,7 @@ if ($c->param && $c->param('id')) {
if (!Litmus::DB::Resultbug->search(test_result_id =>$c->param('id'),
bug_id => $new_bug)) {
my $bug = Litmus::DB::Resultbug->create({
testresult => $result,
test_result => $result,
last_updated => $time,
submission_time => $time,
user => $user,
@ -84,7 +84,7 @@ if ($c->param && $c->param('id')) {
$c->param('new_comment') and
$c->param('new_comment') ne '') {
my $comment = Litmus::DB::Comment->create({
testresult => $result,
test_result => $result,
last_updated => $time,
submission_time => $time,
user => $user,
@ -92,7 +92,7 @@ if ($c->param && $c->param('id')) {
});
}
}
my $title = 'Test Result #' . $c->param('id') . ' - Details';
my $vars = {
title => $title,

29
webtools/litmus/stats.cgi
View File

@ -42,7 +42,13 @@ my $c = Litmus->cgi();
print $c->header();
# find the number of testcases in the database
my $numtests = Litmus::DB::Test->count_all();
my $numtests = Litmus::DB::Testcase->count_all();
# find the number of subgroups in the database
my $numsubgroups = Litmus::DB::Subgroup->count_all();
# find the number of testgroups in the database
my $numtestgroups = Litmus::DB::Testgroup->count_all();
# find the number of users in the database
my $numusers = Litmus::DB::User->count_all();
@ -52,28 +58,13 @@ my $numresults = Litmus::DB::Testresult->count_all();
# get a list of the top 15 testers of all time, sorted by the number
# of test results submitted:
my $dbh = Litmus::DB::User->db_Main();
my $sth = $dbh->prepare("SELECT users.user_id, users.email, count(*) AS thecount
FROM users, test_results
WHERE
users.user_id=test_results.user_id
GROUP BY user_id
ORDER BY thecount DESC
LIMIT 15;");
$sth->execute();
my @toptesters;
my @curtester;
while (@curtester = $sth->fetchrow_array()) {
my %testerinfo;
$testerinfo{"email"} = $curtester[1];
$testerinfo{"numtests"} = $curtester[2];
push(@toptesters, \%testerinfo);
}
my @toptesters = Litmus::DB::User->search_TopTesters();
my $vars = {
title => "Statistics",
numtests => $numtests,
numsubgroups => $numsubgroups,
numtestgroups => $numtestgroups,
numusers => $numusers,
numresults => $numresults,
toptesters => \@toptesters,

10
webtools/litmus/testlist.cgi
View File

@ -56,15 +56,15 @@ if ($tests) {
}
} else {
Litmus::DB::Test->set_sql('failing' => qq {
SELECT tests.test_id
FROM tests, test_results
SELECT testcases.testcase_id
FROM testcases, test_results
WHERE
test_results.result_id != 1 AND
test_results.test_id = tests.test_id
GROUP BY tests.test_id
test_results.testcase_id = testcases.testcase_id
GROUP BY testcases.testcase_id
});
@testlist = Litmus::DB::Test->search_failing();
@testlist = Litmus::DB::Testcase->search_failing();
}
my $vars = {