oqapi/webgui
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

- added: Inbox is now pruned after 1 year

Browse source 
- Added about a hundred tests for Collaboration system, Post, and Thread 
permissions
- Cleaned up code tested by the aforementioned tests
- Fixed all Test::WWW::Mechanize tests and updated the skeleton. Should be 
usable now.
This commit is contained in:
Doug Bell 2008-04-26 02:23:10 +00:00
parent ea1dac4064
commit 98992b8920
16 changed files with 742 additions and 120 deletions
Download patch file Download diff file Expand all files Collapse all files

6
docs/changelog/7.x.x.txt
View file

@ -31,6 +31,12 @@
displayed displayed
- fixed: Thingy: thing view screen always displays all fields - fixed: Thingy: thing view screen always displays all fields
- fixed: Thingy: search result "sort by" not working - fixed: Thingy: search result "sort by" not working
- added: Inbox is now pruned after 1 year
- Added about a hundred tests for Collaboration system, Post, and Thread
permissions
- Cleaned up code tested by the aforementioned tests
- Fixed all Test::WWW::Mechanize tests and updated the skeleton. Should be
usable now.
7.5.10 7.5.10

13
docs/upgrades/upgrade_7.5.10-7.5.11.pl
View file

@ -25,6 +25,7 @@ my $session = start(); # this line required
# upgrade functions go here # upgrade functions go here
addCalendarEventWorkflow( $session ); addCalendarEventWorkflow( $session );
addPurgeOldInboxActivity( $session );
addingInStoreCredit($session); addingInStoreCredit($session);
insertCommerceTaxTable($session); insertCommerceTaxTable($session);
migrateOldTaxTable($session); migrateOldTaxTable($session);
@ -63,6 +64,12 @@ sub addCalendarEventWorkflow {
print "DONE!\n" unless $quiet; print "DONE!\n" unless $quiet;
} }
#----------------------------------------------------------------------------
# Add the new PurgeOldInboxMessages activity to the config file
sub addPurgeOldInboxActivity {
my $session = shift;
print "\tAdding Purge Old Inbox Messages workflow activity... " unless $quiet;
#------------------------------------------------- #-------------------------------------------------
sub addingInStoreCredit { sub addingInStoreCredit {
my $session = shift; my $session = shift;
@ -77,6 +84,12 @@ sub addingInStoreCredit {
)"); )");
} }
my $activity = $session->config->get( "workflowActivities" );
push @{ $activity->{"None"} }, 'WebGUI::Workflow::Activity::PurgeOldInboxMessages';
$session->config->set( "workflowActivities", $activity );
print "DONE!\n" unless $quiet;
}
#------------------------------------------------- #-------------------------------------------------
sub upgradeEMS { sub upgradeEMS {

40
lib/WebGUI/Asset/Post.pm
View file

@ -92,13 +92,36 @@ sub canAdd {
#------------------------------------------------------------------- #-------------------------------------------------------------------
sub canEdit { sub canEdit {
my $self = shift; my $self = shift;
return (($self->session->form->process("func") eq "add" || ($self->session->form->process("assetId") eq "new" && $self->session->form->process("func") eq "editSave" && $self->session->form->process("class","className") eq "WebGUI::Asset::Post")) && $self->getThread->getParent->canPost) || # account for new posts my $userId = shift || $self->session->user->userId;
my $session = $self->session;
my $form = $self->session->form;
my $user = WebGUI::User->new( $session, $userId );
($self->isPoster && $self->getThread->getParent->get("editTimeout") > ($self->session->datetime->time() - $self->get("revisionDate"))) || # Handle adding new posts
$self->session->user->isInGroup($self->getThread->getParent->get('groupToEditPost')) || if (
$self->getThread->getParent->canEdit; ( $form->get("func") eq "add"
|| ( $form->get("func") eq "editSave" && $form->get("assetId") eq "new" )
)
&& $form->get("class") eq "WebGUI::Asset::Post"
) {
return $self->getThread->getParent->canPost;
}
# User who posted can edit their own post
if ( $self->isPoster( $userId ) ) {
my $editTimeout = $self->getThread->getParent->get( 'editTimeout' );
if ( $editTimeout > time - $self->get( "revisionDate" ) ) {
return 1;
}
}
# Users in groupToEditPost of the Collab can edit any post
if ( $user->isInGroup( $self->getThread->getParent->get('groupToEditPost') ) ) {
return 1;
}
return $self->getThread->getParent->canEdit( $userId );
} }
#------------------------------------------------------------------- #-------------------------------------------------------------------
@ -690,15 +713,16 @@ sub isNew {
#------------------------------------------------------------------- #-------------------------------------------------------------------
=head2 isPoster ( ) =head2 isPoster ( userId )
Returns a boolean that is true if the current user created this post and is not a visitor. Returns a boolean that is true if the current user created this post and is not a visitor.
=cut =cut
sub isPoster { sub isPoster {
my $self = shift; my $self = shift;
return ($self->session->user->userId ne "1" && $self->session->user->userId eq $self->get("ownerUserId")); my $userId = shift || $self->session->user->userId;
return ( $userId ne "1" && $userId eq $self->get("ownerUserId") );
} }

13
lib/WebGUI/Asset/Post/Thread.pm
View file

@ -47,14 +47,19 @@ sub canAdd {
#------------------------------------------------------------------- #-------------------------------------------------------------------
sub canReply { sub canReply {
my $self = shift; my $self = shift;
return !$self->isThreadLocked && $self->getParent->get("allowReplies") && $self->getParent->canPost; my $userId = shift || $self->session->user->userId;
return !$self->isThreadLocked
&& $self->getParent->get("allowReplies")
&& $self->getParent->canPost( $userId )
;
} }
#------------------------------------------------------------------- #-------------------------------------------------------------------
sub canSubscribe { sub canSubscribe {
my $self = shift; my $self = shift;
return ($self->session->user->userId ne "1" && $self->canView); my $userId = shift || $self->session->user->userId;
return ($userId ne "1" && $self->canView( $userId ) );
} }
#------------------------------------------------------------------- #-------------------------------------------------------------------

129
lib/WebGUI/Asset/Wobject/Collaboration.pm
View file

@ -248,7 +248,8 @@ sub appendTemplateLabels {
#------------------------------------------------------------------- #-------------------------------------------------------------------
sub canEdit { sub canEdit {
my $self = shift; my $self = shift;
my $userId = shift || $self->session->user->userId;
return ( return (
( (
( (
@ -259,85 +260,109 @@ sub canEdit {
$self->session->form->process("class") eq "WebGUI::Asset::Post::Thread" $self->session->form->process("class") eq "WebGUI::Asset::Post::Thread"
) )
) && ) &&
$self->canPost $self->canStartThread( $userId )
) || # account for new posts ) || # account for new threads
$self->SUPER::canEdit() $self->SUPER::canEdit( $userId )
); );
} }
#------------------------------------------------------------------- #-------------------------------------------------------------------
sub canModerate { sub canModerate {
my $self = shift; my $self = shift;
return $self->SUPER::canEdit; my $userId = shift || $self->session->user->userId;
return $self->SUPER::canEdit( $userId );
} }
#------------------------------------------------------------------- #-------------------------------------------------------------------
sub canPost { sub canPost {
my $self = shift; my $self = shift;
return ( my $userId = shift;
( my $session = $self->session;
$self->get("status") eq "approved" || my $user = $userId
$self->getTagCount > 1 # checks to make sure that the cs has been committed at least once ? WebGUI::User->new( $session, $userId )
) && ( : $self->session->user
$self->session->user->isInGroup($self->get("postGroupId")) ;
|| $self->SUPER::canEdit
) # checks to make sure that the cs has been committed at least once
); if ( $self->get("status") ne "approved" && $self->getTagCount <= 1 ) {
return 0;
}
# Users in the postGroupId can post
elsif ( $user->isInGroup( $self->get("postGroupId") ) ) {
return 1;
}
# Users who can edit the collab can post
else {
return $self->SUPER::canEdit( $userId );
}
} }
#------------------------------------------------------------------- #-------------------------------------------------------------------
sub canSubscribe { sub canSubscribe {
my $self = shift; my $self = shift;
return ($self->session->user->userId ne "1" && $self->canView); my $userId = shift;
my $session = $self->session;
my $user = $userId
? WebGUI::User->new( $session, $userId )
: $self->session->user
;
return ($user->userId ne "1" && $self->canView( $userId ) );
} }
#------------------------------------------------------------------- #-------------------------------------------------------------------
sub canStartThread { sub canStartThread {
my $self = shift; my $self = shift;
return ( my $userId = shift;
( my $session = $self->session;
$self->get("status") eq "approved" || my $user = $userId
$self->getTagCount > 1 # checks to make sure that the cs has been committed at least once ? WebGUI::User->new( $session, $userId )
) && ( : $self->session->user
$self->session->user->isInGroup($self->get("canStartThreadGroupId")) ;
|| $self->SUPER::canEdit return (
) (
); $self->get("status") eq "approved" ||
$self->getTagCount > 1 # checks to make sure that the cs has been committed at least once
) && (
$user->isInGroup($self->get("canStartThreadGroupId"))
|| $self->SUPER::canEdit( $userId )
)
);
} }
#------------------------------------------------------------------- #-------------------------------------------------------------------
sub canView { sub canView {
my $self = shift; my $self = shift;
return $self->SUPER::canView || $self->canPost; my $userId = shift || $self->session->user->userId;
return $self->SUPER::canView( $userId ) || $self->canPost( $userId );
} }
#------------------------------------------------------------------- #-------------------------------------------------------------------
sub commit { sub commit {
my $self = shift; my $self = shift;
$self->SUPER::commit; $self->SUPER::commit;
my $cron = undef; my $cron = undef;
if ($self->get("getMailCronId")) { if ($self->get("getMailCronId")) {
$cron = WebGUI::Workflow::Cron->new($self->session, $self->get("getMailCronId")); $cron = WebGUI::Workflow::Cron->new($self->session, $self->get("getMailCronId"));
} }
my $i18n = WebGUI::International->new($self->session, "Asset_Collaboration"); my $i18n = WebGUI::International->new($self->session, "Asset_Collaboration");
unless (defined $cron) { unless (defined $cron) {
$cron = WebGUI::Workflow::Cron->create($self->session, { $cron = WebGUI::Workflow::Cron->create($self->session, {
title=>$self->getTitle." ".$i18n->get("mail"), title=>$self->getTitle." ".$i18n->get("mail"),
minuteOfHour=>"*/".($self->get("getMailInterval")/60), minuteOfHour=>"*/".($self->get("getMailInterval")/60),
className=>(ref $self), className=>(ref $self),
methodName=>"new", methodName=>"new",
parameters=>$self->getId, parameters=>$self->getId,
workflowId=>"csworkflow000000000001" workflowId=>"csworkflow000000000001"
}); });
$self->update({getMailCronId=>$cron->getId}); $self->update({getMailCronId=>$cron->getId});
} }
if ($self->get("getMail")) { if ($self->get("getMail")) {
$cron->set({enabled=>1,title=>$self->getTitle." ".$i18n->get("mail"), minuteOfHour=>"*/".($self->get("getMailInterval")/60)}); $cron->set({enabled=>1,title=>$self->getTitle." ".$i18n->get("mail"), minuteOfHour=>"*/".($self->get("getMailInterval")/60)});
} else { } else {
$cron->set({enabled=>0,title=>$self->getTitle." ".$i18n->get("mail"), minuteOfHour=>"*/".($self->get("getMailInterval")/60)}); $cron->set({enabled=>0,title=>$self->getTitle." ".$i18n->get("mail"), minuteOfHour=>"*/".($self->get("getMailInterval")/60)});
} }
} }
#------------------------------------------------------------------- #-------------------------------------------------------------------

124
lib/WebGUI/Workflow/Activity/PurgeOldInboxMessages.pm Normal file
View file

@ -0,0 +1,124 @@
package WebGUI::Workflow::Activity::PurgeOldInboxMessages;
=head1 LEGAL
-------------------------------------------------------------------
WebGUI is Copyright 2001-2008 Plain Black Corporation.
-------------------------------------------------------------------
Please read the legal notices (docs/legal.txt) and the license
(docs/license.txt) that came with this distribution before using
this software.
-------------------------------------------------------------------
http://www.plainblack.com info@plainblack.com
-------------------------------------------------------------------
=cut
use strict;
use base 'WebGUI::Workflow::Activity';
use WebGUI::Asset;
=head1 NAME
Package WebGUI::Workflow::Activity::PurgeOldInboxMessages
=head1 DESCRIPTION
Removes old, completed inbox messages from the database
=head1 SYNOPSIS
See WebGUI::Workflow::Activity for details on how to use any activity.
=head1 METHODS
These methods are available from this class:
=cut
#-------------------------------------------------------------------
=head2 definition ( session, definition )
See WebGUI::Workflow::Activity::defintion() for details.
=cut
sub definition {
my $class = shift;
my $session = shift;
my $definition = shift;
my $i18n = WebGUI::International->new($session, "Workflow_Activity_PurgeOldInboxMessages");
push @{$definition}, {
name => $i18n->get("activityName"),
properties => {
purgeAfter => {
fieldType => "interval",
defaultValue => 60 * 60 * 24 * 365,
label => $i18n->get("editForm purgeAfter label"),
hoverHelp => $i18n->get("editForm purgeAfter description"),
},
},
};
return $class->SUPER::definition($session,$definition);
}
#-------------------------------------------------------------------
=head2 execute ( )
See WebGUI::Workflow::Activity::execute() for details.
=cut
sub execute {
my ($self, $nothing, $instance) = @_;
my $session = $self->session;
my $log = $session->errorHandler;
# keep track of how much time it's taking
my $start = time;
# Only purge this many per operation to prevent MySQL returning
# a half-million rows (which will take longer than the time we have)
my $limit = 2_500;
my $sth
= $session->db->read(
"SELECT messageId FROM inbox WHERE completedOn IS NOT NULL AND dateStamp < ? ORDER BY dateStamp ASC LIMIT $limit",
[ $start - $self->get('purgeAfter') ],
);
while ( ( my $messageId ) = $sth->array ) {
$session->db->write(
"DELETE FROM inbox WHERE messageId = ?",
[ $messageId ],
);
# give up if we're taking too long
if (time - $start > 120) {
$sth->finish;
return $self->WAITING;
}
}
# If there are more messages waiting to be purged, return WAITING
if ( $sth->rows >= $limit ) {
return $self->WAITING;
}
else {
return $self->COMPLETE;
}
}
1;

25
lib/WebGUI/i18n/English/Workflow_Activity_PurgeOldInboxMessages.pm Normal file
View file

@ -0,0 +1,25 @@
package WebGUI::i18n::English::Workflow_Activity_PurgeOldInboxMessages;
use strict;
our $I18N = {
'activityName' => {
message => q{Purge Old Inbox Messages},
lastUpdated => 0,
context => 'Title of workflow activity',
},
'editForm purgeAfter label' => {
message => q{Purge After},
lastUpdated => 0,
context => 'Label for workflow property',
},
'editForm purgeAfter description' => {
message => q{The length of time a message is allowed to remain in the inbox after it has been set to "completed"},
lastUpdated => 0,
context => 'Description of workflow property',
},
};
1;

11
t/Asset/Event/edit.t
View file

@ -65,9 +65,16 @@ $versionTags[-1]->commit;
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# Tests # Tests
plan tests => 9; # Increment this number for each test you create if ( !eval { require Test::WWW::Mechanize; 1; } ) {
plan skip_all => 'Cannot load Test::WWW::Mechanize. Will not test.';
}
$mech = Test::WWW::Mechanize->new;
$mech->get( $baseUrl );
if ( !$mech->success ) {
plan skip_all => "Cannot load URL '$baseUrl'. Will not test.";
}
use_ok( 'Test::WWW::Mechanize' ) or BAIL_OUT("Cannot continue without Test::WWW::Mechanize"); plan tests => 8; # Increment this number for each test you create
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# Add event: Users without permission are not shown form # Add event: Users without permission are not shown form

101
t/Asset/File/GalleryFile/Photo/edit.t
View file

@ -31,6 +31,9 @@ my %oldSettings;
# userFunctionStyleId # userFunctionStyleId
$oldSettings{ userFunctionStyleId } = $session->setting->get( 'userFunctionStyleId' ); $oldSettings{ userFunctionStyleId } = $session->setting->get( 'userFunctionStyleId' );
$session->setting->set( 'userFunctionStyleId', 'PBtmpl0000000000000132' ); $session->setting->set( 'userFunctionStyleId', 'PBtmpl0000000000000132' );
# specialState
$oldSettings{ specialState } = $session->setting->get( 'specialState' );
$session->setting->set( 'specialState', '' );
# Create a user for testing purposes # Create a user for testing purposes
my $user = WebGUI::User->new( $session, "new" ); my $user = WebGUI::User->new( $session, "new" );
@ -67,62 +70,66 @@ my $photo;
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# Tests # Tests
plan tests => 6; # Increment this number for each test you create if ( !eval { require Test::WWW::Mechanize; 1; } ) {
plan skip_all => 'Cannot load Test::WWW::Mechanize. Will not test.';
}
$mech = Test::WWW::Mechanize->new;
$mech->get( $baseUrl );
if ( !$mech->success ) {
plan skip_all => "Cannot load URL '$baseUrl'. Will not test.";
}
SKIP: { plan tests => 5; # Increment this number for each test you create
use_ok( 'Test::WWW::Mechanize' ) or skip( "Cannot continue without Test::WWW::Mechanize", 5 ); #----------------------------------------------------------------------------
# Test permissions for new photos
$mech = Test::WWW::Mechanize->new;
#---------------------------------------------------------------------------- # Save a new photo
# Test permissions for new photos $mech->get( $baseUrl . $album->getUrl("func=add;class=WebGUI::Asset::File::GalleryFile::Photo") );
$mech = Test::WWW::Mechanize->new; $mech->content_lacks( 'value="editSave"' );
# Save a new photo #----------------------------------------------------------------------------
$mech->get( $baseUrl . $album->getUrl("func=add;class=WebGUI::Asset::File::GalleryFile::Photo") ); # Test creating a new Photo
$mech->content_lacks( 'value="editSave"' ); SKIP: {
skip "File control needs to be fixed to be more 508-compliant before this can be used", 4;
$mech = getMechLogin( $baseUrl, $user, $identifier );
$mech->get_ok( $baseUrl . $album->getUrl("func=add;class=WebGUI::Asset::File::GalleryFile::Photo") );
#---------------------------------------------------------------------------- open my $file, '<', WebGUI::Test->getTestCollateralPath( 'lamp.jpg' )
# Test creating a new Photo or die( "Couldn't open test collateral 'lamp.jpg' for reading: $!" );
SKIP: { my $properties = {
skip "File control needs to be fixed to be more 508-compliant before this can be used", 4; title => 'Photo Title' . time,
$mech = getMechLogin( $baseUrl, $user, $identifier ); synopsis => '<p>Photo Synopsis' . time . '</p>',
$mech->get_ok( $baseUrl . $album->getUrl("func=add;class=WebGUI::Asset::File::GalleryFile::Photo") ); newFile_file => $file,
};
open my $file, '<', WebGUI::Test->getTestCollateralPath( 'lamp.jpg' ) $mech->submit_form_ok(
or die( "Couldn't open test collateral 'lamp.jpg' for reading: $!" ); {
my $properties = { form_number => 1,
title => 'Photo Title' . time, fields => $properties,
synopsis => '<p>Photo Synopsis' . time . '</p>', },
newFile_file => $file, 'Submit new Photo'
}; );
$mech->submit_form_ok( # Add properties that should be default and remove those that should be different
{ delete $properties->{ newFile_file };
form_number => 1, $properties = {
fields => $properties, %{ $properties },
}, ownerUserId => $user->userId,
'Submit new Photo' filename => 'lamp.jpg',
); };
# Add properties that should be default and remove those that should be different # Make sure properties were saved
delete $properties->{ newFile_file }; my $photo = WebGUI::Asset->newByDynamicClass( $session, $album->getFileIds->[0] );
$properties = { cmp_deeply( $photo->get, superhashof( $properties ), "Photo properties saved correctly" );
%{ $properties },
ownerUserId => $user->userId,
filename => 'lamp.jpg',
};
# Make sure properties were saved # First File in an album should update assetIdThumbnail
my $photo = WebGUI::Asset->newByDynamicClass( $session, $album->getFileIds->[0] ); my $album = WebGUI::Asset->newByDynamicClass( $session, $album->getId );
cmp_deeply( $photo->get, superhashof( $properties ), "Photo properties saved correctly" ); is(
$album->get('assetIdThumbnail'), $photo->getId,
# First File in an album should update assetIdThumbnail "Album assetIdThumbnail gets set by first File added",
my $album = WebGUI::Asset->newByDynamicClass( $session, $album->getId ); );
is(
$album->get('assetIdThumbnail'), $photo->getId,
"Album assetIdThumbnail gets set by first File added",
);
}
} }
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------

129
t/Asset/Post/Thread/permission.t Normal file
View file

@ -0,0 +1,129 @@
# vim:syntax=perl
#-------------------------------------------------------------------
# WebGUI is Copyright 2001-2008 Plain Black Corporation.
#-------------------------------------------------------------------
# Please read the legal notices (docs/legal.txt) and the license
# (docs/license.txt) that came with this distribution before using
# this software.
#------------------------------------------------------------------
# http://www.plainblack.com info@plainblack.com
#------------------------------------------------------------------
# Write a little about what this script tests.
#
#
use FindBin;
use strict;
use lib "$FindBin::Bin/../../../lib";
use Test::More;
use WebGUI::Test; # Must use this before any other WebGUI modules
use WebGUI::Session;
use WebGUI::Test::Maker::Permission;
#----------------------------------------------------------------------------
# Init
my $session = WebGUI::Test->session;
$session->user( { userId => 3 } );
my $maker = WebGUI::Test::Maker::Permission->new;
my $node = WebGUI::Asset->getImportNode( $session );
my %user;
$user{"2"} = WebGUI::User->new( $session, "new" );
$user{"2"}->addToGroups( ['2'] ); # Registered user
my $versionTag = WebGUI::VersionTag->getWorking( $session );
$versionTag->set( { name => "Collaboration Test" } );
my @addArgs = ( undef, undef, { skipAutoCommitWorkflows => 1 } );
my $collab
= $node->addChild({
className => "WebGUI::Asset::Wobject::Collaboration",
groupIdView => 7, # Everyone
groupIdEdit => 3, # Admins
groupToEditPost => 3, # Admins
ownerUserId => 3, # Admin
postGroupId => 2, # Registered Users
canStartThreadGroupId => 3, # Admin
allowReplies => 1,
editTimeout => 60 * 60 * 24, # 24 hours
}, @addArgs );
my $thread
= $collab->addChild({
className => 'WebGUI::Asset::Post::Thread',
ownerUserId => $user{"2"}->userId,
groupIdView => 7,
}, @addArgs );
$versionTag->commit( { timeout => 1_000_000 } );
# Re-load the collab to get the newly committed properties
$collab = WebGUI::Asset->newByDynamicClass( $session, $collab->getId );
$thread = WebGUI::Asset->newByDynamicClass( $session, $thread->getId );
#----------------------------------------------------------------------------
# Tests
plan tests => 36;
#----------------------------------------------------------------------------
# Permissions for threads
# View
$maker->prepare( {
object => $thread,
method => 'canView',
pass => [ '1', $user{"2"}, '3', ],
} )->run;
# Subscribe
$maker->prepare( {
object => $thread,
method => 'canSubscribe',
pass => [ $user{"2"}, '3', ],
fail => [ '1', ],
} )->run;
# Edit
$maker->prepare( {
object => $thread,
method => 'canEdit',
pass => [ $user{"2"}, '3', ],
fail => [ '1', ],
} )->run;
# Reply
$maker->prepare( {
object => $thread,
method => 'canReply',
pass => [ $user{"2"}, '3', ],
fail => [ '1', ],
} )->run;
# Reply with allowReplies = 0
$collab->update({ allowReplies => 0 });
$thread = WebGUI::Asset->newByDynamicClass( $session, $thread->getId );
$maker->prepare( {
object => $thread,
method => 'canReply',
fail => [ '1', $user{"2"}, '3', ],
} )->run;
$collab->update({ allowReplies => 1 });
# Reply with thread isLocked
$thread->lock;
$maker->prepare( {
object => $thread,
method => 'canReply',
fail => [ '1', $user{"2"}, '3', ],
} )->run;
$thread->unlock;
#----------------------------------------------------------------------------
# Cleanup
END {
for my $user ( values %user ) {
$user->delete;
}
$versionTag->rollback;
}

100
t/Asset/Post/permission.t Normal file
View file

@ -0,0 +1,100 @@
# vim:syntax=perl
#-------------------------------------------------------------------
# WebGUI is Copyright 2001-2008 Plain Black Corporation.
#-------------------------------------------------------------------
# Please read the legal notices (docs/legal.txt) and the license
# (docs/license.txt) that came with this distribution before using
# this software.
#------------------------------------------------------------------
# http://www.plainblack.com info@plainblack.com
#------------------------------------------------------------------
# Write a little about what this script tests.
#
#
use FindBin;
use strict;
use lib "$FindBin::Bin/../../lib";
use Test::More;
use WebGUI::Test; # Must use this before any other WebGUI modules
use WebGUI::Session;
use WebGUI::Test::Maker::Permission;
#----------------------------------------------------------------------------
# Init
my $session = WebGUI::Test->session;
$session->user( { userId => 3 } );
my $maker = WebGUI::Test::Maker::Permission->new;
my $node = WebGUI::Asset->getImportNode( $session );
my %user;
$user{"2"} = WebGUI::User->new( $session, "new" );
$user{"2"}->addToGroups( ['2'] ); # Registered user
my $versionTag = WebGUI::VersionTag->getWorking( $session );
$versionTag->set( { name => "Collaboration Test" } );
my @addArgs = ( undef, undef, { skipAutoCommitWorkflows => 1 } );
my $collab
= $node->addChild({
className => "WebGUI::Asset::Wobject::Collaboration",
groupIdView => 7, # Everyone
groupIdEdit => 3, # Admins
groupToEditPost => 3, # Admins
ownerUserId => 3, # Admin
postGroupId => 2, # Registered Users
canStartThreadGroupId => 3, # Admin
allowReplies => 1,
editTimeout => 60 * 60 * 24, # 24 hours
}, @addArgs );
my $thread
= $collab->addChild({
className => 'WebGUI::Asset::Post::Thread',
ownerUserId => $user{"2"}->userId,
}, @addArgs );
my $post
= $thread->addChild({
className => 'WebGUI::Asset::Post',
ownerUserId => $user{"2"}->userId,
}, @addArgs );
$versionTag->commit( { timeout => 1_000_000 } );
# Re-load the collab to get the newly committed properties
$collab = WebGUI::Asset->newByDynamicClass( $session, $collab->getId );
$thread = WebGUI::Asset->newByDynamicClass( $session, $thread->getId );
$post = WebGUI::Asset->newByDynamicClass( $session, $post->getId );
#----------------------------------------------------------------------------
# Tests
plan tests => 12;
#----------------------------------------------------------------------------
# Permissions for posts
# View
$maker->prepare( {
object => $post,
method => 'canView',
pass => [ '1', $user{"2"}, '3', ],
} )->run;
# Edit
$maker->prepare( {
object => $post,
method => 'canEdit',
pass => [ $user{"2"}, '3', ],
fail => [ '1', ],
} )->run;
#----------------------------------------------------------------------------
# Cleanup
END {
for my $user ( values %user ) {
$user->delete;
}
$versionTag->rollback;
}

16
t/Asset/Redirect/mech.t
View file

@ -33,10 +33,13 @@ my %oldSettings;
# userFunctionStyleId # userFunctionStyleId
$oldSettings{ userFunctionStyleId } = $session->setting->get( 'userFunctionStyleId' ); $oldSettings{ userFunctionStyleId } = $session->setting->get( 'userFunctionStyleId' );
$session->setting->set( 'userFunctionStyleId', 'PBtmpl0000000000000132' ); $session->setting->set( 'userFunctionStyleId', 'PBtmpl0000000000000132' );
# specialState
$oldSettings{ specialState } = $session->setting->get( 'specialState' );
$session->setting->set( 'specialState', '' );
# Create a user for testing purposes # Create a user for testing purposes
my $user = WebGUI::User->new( $session, "new" ); my $user = WebGUI::User->new( $session, "new" );
$user->username( 'dufresne' . time ); $user->username( 'dufresne' );
my $identifier = 'ritahayworth'; my $identifier = 'ritahayworth';
my $auth = WebGUI::Operation::Auth::getInstance( $session, $user->authMethod, $user->userId ); my $auth = WebGUI::Operation::Auth::getInstance( $session, $user->authMethod, $user->userId );
$auth->saveParams( $user->userId, $user->authMethod, { $auth->saveParams( $user->userId, $user->authMethod, {
@ -65,9 +68,16 @@ $versionTags[-1]->commit;
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# Tests # Tests
plan tests => 13; # Increment this number for each test you create if ( !eval { require Test::WWW::Mechanize; 1; } ) {
plan skip_all => 'Cannot load Test::WWW::Mechanize. Will not test.';
}
$mech = Test::WWW::Mechanize->new;
$mech->get( $baseUrl );
if ( !$mech->success ) {
plan skip_all => "Cannot load URL '$baseUrl'. Will not test.";
}
use_ok( 'Test::WWW::Mechanize' ); plan tests => 12; # Increment this number for each test you create
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# Test operation with a public Redirect # Test operation with a public Redirect

115
t/Asset/Wobject/Collaboration/permission.t Normal file
View file

@ -0,0 +1,115 @@
# vim:syntax=perl
#-------------------------------------------------------------------
# WebGUI is Copyright 2001-2008 Plain Black Corporation.
#-------------------------------------------------------------------
# Please read the legal notices (docs/legal.txt) and the license
# (docs/license.txt) that came with this distribution before using
# this software.
#------------------------------------------------------------------
# http://www.plainblack.com info@plainblack.com
#------------------------------------------------------------------
# Write a little about what this script tests.
#
#
use FindBin;
use strict;
use lib "$FindBin::Bin/../../../lib";
use Test::More;
use WebGUI::Test; # Must use this before any other WebGUI modules
use WebGUI::Session;
use WebGUI::Test::Maker::Permission;
#----------------------------------------------------------------------------
# Init
my $session = WebGUI::Test->session;
$session->user( { userId => 3 } );
my $maker = WebGUI::Test::Maker::Permission->new;
my $node = WebGUI::Asset->getImportNode( $session );
my %user;
$user{"2"} = WebGUI::User->new( $session, "new" );
$user{"2"}->addToGroups( ['2'] ); # Registered user
my $versionTag = WebGUI::VersionTag->getWorking( $session );
$versionTag->set( { name => "Collaboration Test" } );
my @addArgs = ( undef, undef, { skipAutoCommitWorkflows => 1 } );
my $collab
= $node->addChild({
className => "WebGUI::Asset::Wobject::Collaboration",
groupIdView => 7, # Everyone
groupIdEdit => 3, # Admins
ownerUserId => 3, # Admin
postGroupId => 2, # Registered Users
canStartThreadGroupId => 3, # Admin
}, @addArgs );
$versionTag->commit( { timeout => 1_000_000 } );
# Re-load the collab to get the newly committed properties
$collab = WebGUI::Asset->newByDynamicClass( $session, $collab->getId );
#----------------------------------------------------------------------------
# Tests
plan tests => 36;
#----------------------------------------------------------------------------
# Permissions for collaboration systems
# View
$maker->prepare( {
object => $collab,
method => 'canView',
pass => [ '1', $user{"2"}, '3', ],
} )->run;
# Edit
$maker->prepare( {
object => $collab,
method => 'canEdit',
pass => [ '3', ],
fail => [ '1', $user{"2"}, ],
} )->run;
# Post
$maker->prepare( {
object => $collab,
method => 'canPost',
pass => [ $user{"2"}, '3', ],
fail => [ '1', ],
} )->run;
# Post Thread
$maker->prepare( {
object => $collab,
method => 'canStartThread',
pass => [ '3', ],
fail => [ '1', $user{"2"}, ],
} )->run;
# Subscribe
$maker->prepare( {
object => $collab,
method => 'canSubscribe',
pass => [ $user{"2"}, '3', ],
fail => [ '1', ],
} )->run;
# Moderate
$maker->prepare( {
object => $collab,
method => 'canModerate',
pass => [ '3', ],
fail => [ '1', $user{"2"}, ],
} )->run;
#----------------------------------------------------------------------------
# Cleanup
END {
for my $user ( values %user ) {
$user->delete;
}
$versionTag->rollback;
}

12
t/Asset/Wobject/GalleryAlbum/edit.t
View file

@ -33,6 +33,9 @@ my %oldSettings;
# userFunctionStyleId # userFunctionStyleId
$oldSettings{ userFunctionStyleId } = $session->setting->get( 'userFunctionStyleId' ); $oldSettings{ userFunctionStyleId } = $session->setting->get( 'userFunctionStyleId' );
$session->setting->set( 'userFunctionStyleId', 'PBtmpl0000000000000132' ); $session->setting->set( 'userFunctionStyleId', 'PBtmpl0000000000000132' );
# specialState
$oldSettings{ specialState } = $session->setting->get( 'specialState' );
$session->setting->set( 'specialState', '' );
# Create a user for testing purposes # Create a user for testing purposes
my $user = WebGUI::User->new( $session, "new" ); my $user = WebGUI::User->new( $session, "new" );
@ -62,6 +65,15 @@ $versionTags[-1]->commit;
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# Tests # Tests
if ( !eval { require Test::WWW::Mechanize; 1; } ) {
plan skip_all => 'Cannot load Test::WWW::Mechanize. Will not test.';
}
$mech = Test::WWW::Mechanize->new;
$mech->get( $baseUrl );
if ( !$mech->success ) {
plan skip_all => "Cannot load URL '$baseUrl'. Will not test.";
}
plan tests => 6; # Increment this number for each test you create plan tests => 6; # Increment this number for each test you create
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------

14
t/Auth/mech.t
View file

@ -38,6 +38,9 @@ my %oldSettings;
# userFunctionStyleId # userFunctionStyleId
$oldSettings{ userFunctionStyleId } = $session->setting->get( 'userFunctionStyleId' ); $oldSettings{ userFunctionStyleId } = $session->setting->get( 'userFunctionStyleId' );
$session->setting->set( 'userFunctionStyleId', 'PBtmpl0000000000000132' ); $session->setting->set( 'userFunctionStyleId', 'PBtmpl0000000000000132' );
# specialState
$oldSettings{ specialState } = $session->setting->get( 'specialState' );
$session->setting->set( 'specialState', '' );
# Create a user for testing purposes # Create a user for testing purposes
my $USERNAME = 'dufresne'; my $USERNAME = 'dufresne';
@ -72,9 +75,16 @@ my $assetUrl = $baseUrl . $asset->get('url');
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# Tests # Tests
plan tests => 41; # Increment this number for each test you create if ( !eval { require Test::WWW::Mechanize; 1; } ) {
plan skip_all => 'Cannot load Test::WWW::Mechanize. Will not test.';
}
$mech = Test::WWW::Mechanize->new;
$mech->get( $baseUrl );
if ( !$mech->success ) {
plan skip_all => "Cannot load URL '$baseUrl'. Will not test.";
}
use_ok( 'Test::WWW::Mechanize' ); plan tests => 40; # Increment this number for each test you create
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# no form: Test logging in on a normal page sends the user back to the same page # no form: Test logging in on a normal page sends the user back to the same page

14
t/_test.skeleton.mech
View file

@ -43,6 +43,9 @@ my %oldSettings;
# userFunctionStyleId # userFunctionStyleId
$oldSettings{ userFunctionStyleId } = $session->setting->get( 'userFunctionStyleId' ); $oldSettings{ userFunctionStyleId } = $session->setting->get( 'userFunctionStyleId' );
$session->setting->set( 'userFunctionStyleId', 'PBtmpl0000000000000132' ); $session->setting->set( 'userFunctionStyleId', 'PBtmpl0000000000000132' );
# specialState
$oldSettings{ specialState } = $session->setting->get( 'specialState' );
$session->setting->set( 'specialState', '' );
# Create a user for testing purposes # Create a user for testing purposes
my $user = WebGUI::User->new( $session, "new" ); my $user = WebGUI::User->new( $session, "new" );
@ -62,9 +65,16 @@ my $baseUrl = 'http://' . $session->config->get('sitename')->[0];
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# Tests # Tests
plan tests => 1; # Increment this number for each test you create if ( !eval { require Test::WWW::Mechanize; 1; } ) {
plan skip_all => 'Cannot load Test::WWW::Mechanize. Will not test.';
}
$mech = Test::WWW::Mechanize->new;
$mech->get( $baseUrl );
if ( !$mech->success ) {
plan skip_all => "Cannot load URL '$baseUrl'. Will not test.";
}
use_ok( 'Test::WWW::Mechanize' ) or BAIL_OUT( "Cannot continue without Test::WWW::Mechanize" ); plan tests => 1; # Increment this number for each test you create
#---------------------------------------------------------------------------- #----------------------------------------------------------------------------
# put your tests here # put your tests here