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

Merge branch 'Crud' into WebGUI8

Browse source
This commit is contained in:
Colin Kuskie 2010-11-11 14:23:11 -08:00
commit 7dc51b6c2b
25 changed files with 1033 additions and 772 deletions
Download patch file Download diff file Expand all files Collapse all files

26
t/Asset/Wobject/Survey/Test.t
View file

@ -19,7 +19,6 @@ my $session = WebGUI::Test->session;
#----------------------------------------------------------------------------
# Tests
plan tests => 94;
my $tp = use_ok('TAP::Parser');
my $tpa = use_ok('TAP::Parser::Aggregator');
@ -152,10 +151,29 @@ cmp_deeply(
'surveyOrderIndex correct'
);
my $t1 = WebGUI::Asset::Wobject::Survey::Test->create( $session, { assetId => $s->getId } );
my $t1 = WebGUI::Asset::Wobject::Survey::Test->new( $session, { assetId => $s->getId } );
WebGUI::Test->addToCleanup(sub {$t1->delete();});
my $spec;
can_ok($t1, qw/assetId name test lastUpdated testId session dateCreated sequenceNumber update set get/);
$t1->name('test name');
is $t1->name, 'test name', 'name: direct mutator works okay';
$t1->test('some test');
is $t1->test, 'some test', 'test: mutator check';
$t1->set({ name => 'tested name' });
is $t1->name, 'tested name', 'name: set works okay';
$t1->set({test => 'tested some'});
is $t1->test, 'tested some', 'test: set';
$t1->update({ name => 'different name' });
is $t1->name, 'different name', 'update: updated name';
$t1->update({ test => 'another test', name => 'another name', });
is $t1->name, 'another name', 'update: name, test and name together';
is $t1->test, 'another test', 'update: test';
my $name_prop = $t1->meta->find_attribute_by_name('name');
ok $name_prop->does('WebGUI::Definition::Meta::Property'), '::Test property does Meta::Property';
ok $name_prop->does('WebGUI::Definition::Meta::Settable'), '::Test property does Meta::Settable';
# No tests
$spec = <<END_SPEC;
[ ]
@ -686,7 +704,7 @@ sub try_it {
my ( $test, $spec, $opts ) = @_;
chomp($spec);
$test->update( { test => $spec } );
$test->test($spec);
my $result = $t1->run();
ok( $result, 'Tests ran ok' );
@ -724,4 +742,6 @@ Hashes differ on element: a
expect : '2'
END_CMP
done_testing;
#vim:ft=perl

168
t/Crud.t
View file

@ -16,7 +16,32 @@ use strict;
use Test::More;
use WebGUI::Test; # Must use this before any other WebGUI modules
use WebGUI::Session;
use WebGUI::Crud;
BEGIN {
$INC{'WebGUI/Cruddy.pm'} = __FILE__;
}
package WebGUI::Cruddy;
use Moose;
use WebGUI::Definition::Crud;
extends 'WebGUI::Crud';
define tableName => 'some_crud_table';
define tableKey => 'id';
has id => (
required => 1,
is => 'ro',
);
property prop => (
label => 'prop',
fieldType => 'text',
default => 'propeller',
);
package main;
#----------------------------------------------------------------------------
# Init
@ -26,14 +51,10 @@ my $session = WebGUI::Test->session;
#----------------------------------------------------------------------------
# Tests
plan tests => 55; # Increment this number for each test you create
#----------------------------------------------------------------------------
# check table structure
WebGUI::Crud->crud_createTable($session);
WebGUI::Test->addToCleanup(sub { WebGUI::Crud->crud_dropTable($session); });
my $sth = $session->db->read("describe unnamed_crud_table");
WebGUI::Cruddy->crud_createTable($session);
WebGUI::Test->addToCleanup(sub { WebGUI::Cruddy->crud_dropTable($session); });
my $sth = $session->db->read("describe some_crud_table");
my ($col, $type) = $sth->array();
is($col, 'id', "structure: id name");
is($type, 'char(22)', "structure: id type");
@ -49,93 +70,114 @@ is($type, 'datetime', "structure: lastUpdated type");
$sth->finish;
# check data
my $record1 = WebGUI::Crud->create($session);
isa_ok($record1, "WebGUI::Crud", "isa WebGUI::Crud");
like($record1->get('dateCreated'), qr/\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}/, "dateCreated looks like a date");
like($record1->get('lastUpdated'), qr/\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}/, "lastUpdated looks like a date");
like($record1->get('sequenceNumber'), qr/\d+/, "sequenceNumber looks like a number");
is($record1->get('sequenceNumber'), 1, "record 1 sequenceNumber is 1");
like($record1->get('id'), qr/[A-Za-z0-9_-]{22}/, "id looks like a guid");
my $record1 = WebGUI::Cruddy->new($session);
$record1->write;
can_ok($record1, 'id');
isa_ok($record1, "WebGUI::Crud");
like($record1->dateCreated, qr/\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}/, "dateCreated looks like a date");
like($record1->lastUpdated, qr/\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}/, "lastUpdated looks like a date");
like($record1->sequenceNumber, qr/\d+/, "sequenceNumber looks like a number");
is($record1->sequenceNumber, 1, "record 1 sequenceNumber is 1");
like($record1->id, qr/[A-Za-z0-9_-]{22}/, "id looks like a guid");
can_ok($record1, 'prop');
my $prop = $record1->meta->find_attribute_by_name('prop');
ok($prop->does('WebGUI::Definition::Meta::Property'), 'prop does WebGUI::Definition::Meta::Property');
ok($prop->does('WebGUI::Definition::Meta::Property::Crud'), 'prop does WebGUI::Definition::Meta::Property::Crud');
ok($prop->does('WebGUI::Definition::Meta::Settable'), 'prop does WebGUI::Definition::Meta::Settable');
$record1->update({ prop => 'proposition', });
is $record1->prop, 'proposition', 'update works';
my $dbBday = WebGUI::DateTime->new($session, WebGUI::Test->webguiBirthday)->toDatabase;
$record1->update({
prop => '',
lastUpdated => $dbBday,
});
isnt $record1->lastUpdated, $dbBday, 'lastUpdated overwritten';
# custom id
my $record2 = WebGUI::Crud->create($session,{},{id=>'theshawshankredemption'});
is($record2->get('id'),'theshawshankredemption',"custom id works");
my $record2 = WebGUI::Cruddy->new($session, {id=>'theshawshankredemption'});
is($record2->id,'theshawshankredemption',"custom id works");
$record2->delete;
# instanciation
my $record2 = WebGUI::Crud->create($session);
$record2 = WebGUI::Cruddy->new($session);
$record2->write;
isnt($record1->getId, $record2->getId, "can retrieve unique rows");
my $copyOfRecord2 = WebGUI::Crud->new($session, $record2->getId);
my $copyOfRecord2 = WebGUI::Cruddy->new($session, $record2->getId);
is($record2->getId, $copyOfRecord2->getId, "can reinstanciate record");
# sequencing
is($record2->get('sequenceNumber'), 2, "record 1 sequenceNumber is 2");
my $record3 = WebGUI::Crud->create($session);
is($record3->get('sequenceNumber'), 3, "record 1 sequenceNumber is 3");
my $record4 = WebGUI::Crud->create($session);
is($record4->get('sequenceNumber'), 4, "record 1 sequenceNumber is 4");
is($record2->sequenceNumber, 2, "record 1 sequenceNumber is 2");
my $record3 = WebGUI::Cruddy->new($session);
$record3->write;
is($record3->sequenceNumber, 3, "record 1 sequenceNumber is 3");
my $record4 = WebGUI::Cruddy->new($session);
$record4->write;
is($record4->sequenceNumber, 4, "record 1 sequenceNumber is 4");
ok($record4->demote, "demotion reports success");
is($record4->get('sequenceNumber'), 4, "can't demote further than end");
is($record4->sequenceNumber, 4, "can't demote further than end");
ok($record1->promote, "promotion reports success");
is($record1->get('sequenceNumber'), 1, "can't promote further than beginning");
is($record1->sequenceNumber, 1, "can't promote further than beginning");
$record4->promote;
is($record4->get('sequenceNumber'), 3, "promotion from end works");
is($record4->sequenceNumber, 3, "promotion from end works");
$record4->demote;
is($record4->get('sequenceNumber'), 4, "demotion to end works");
is($record4->sequenceNumber, 4, "demotion to end works");
$record1->demote;
is($record1->get('sequenceNumber'), 2, "demotion from beginning works");
is($record1->sequenceNumber, 2, "demotion from beginning works");
$record1->promote;
is($record1->get('sequenceNumber'), 1, "promotion to beginning works");
is($record1->sequenceNumber, 1, "promotion to beginning works");
$record2->demote;
is($record2->get('sequenceNumber'), 3, "demotion from middle works");
is($record2->sequenceNumber, 3, "demotion from middle works");
$record2->promote;
is($record2->get('sequenceNumber'), 2, "promotion from middle works");
is($record2->sequenceNumber, 2, "promotion from middle works");
# deleting
ok($record2->delete, "deletion reports success");
my $copyOfRecord3 = WebGUI::Crud->new($session, $record3->getId);
my $copyOfRecord4 = WebGUI::Crud->new($session, $record4->getId);
is($copyOfRecord3->get('sequenceNumber'), '2', "deletion of record 2 moved record 3 to sequence 2");
is($copyOfRecord4->get('sequenceNumber'), '3', "deletion of record 2 moved record 4 to sequence 3");
my $copyOfRecord3 = WebGUI::Cruddy->new($session, $record3->getId);
my $copyOfRecord4 = WebGUI::Cruddy->new($session, $record4->getId);
is($copyOfRecord3->sequenceNumber, '2', "deletion of record 2 moved record 3 to sequence 2");
is($copyOfRecord4->sequenceNumber, '3', "deletion of record 2 moved record 4 to sequence 3");
# updating
sleep 1;
$copyOfRecord4->dateCreated(WebGUI::DateTime->new($session, WebGUI::Test->webguiBirthday)->toMysql);
ok($copyOfRecord4->update, "update returns success");
isnt($copyOfRecord4->get('lastUpdated'), $copyOfRecord4->get('dateCreated'), "updates work");
isnt($copyOfRecord4->lastUpdated, $copyOfRecord4->get('dateCreated'), "updates work");
# retrieve data
my ($sql, $params) = WebGUI::Crud->getAllSql($session);
is($sql, "select `unnamed_crud_table`.`id` from `unnamed_crud_table` order by `unnamed_crud_table`.`sequenceNumber`", "getAllSql() SQL no options");
($sql, $params) = WebGUI::Crud->getAllSql($session, {sequenceKeyValue=>1});
is($sql, "select `unnamed_crud_table`.`id` from `unnamed_crud_table` order by `unnamed_crud_table`.`sequenceNumber`", "getAllSql() SQL sequence key value with no key specified");
my ($sql, $params) = WebGUI::Cruddy->getAllSql($session);
is($sql, "select `some_crud_table`.`id` from `some_crud_table` order by `some_crud_table`.`sequenceNumber`", "getAllSql() SQL no options");
($sql, $params) = WebGUI::Cruddy->getAllSql($session, {sequenceKeyValue=>1});
is($sql, "select `some_crud_table`.`id` from `some_crud_table` order by `some_crud_table`.`sequenceNumber`", "getAllSql() SQL sequence key value with no key specified");
is($params->[0], undef, "getAllSql() PARAMS sequence key value with no key specified");
($sql, $params) = WebGUI::Crud->getAllSql($session, {limit=>5});
is($sql, "select `unnamed_crud_table`.`id` from `unnamed_crud_table` order by `unnamed_crud_table`.`sequenceNumber` limit 5", "getAllSql() SQL with a row limit");
($sql, $params) = WebGUI::Crud->getAllSql($session,{limit=>[10,20]});
is($sql, "select `unnamed_crud_table`.`id` from `unnamed_crud_table` order by `unnamed_crud_table`.`sequenceNumber` limit 10,20", "getAllSql() SQL with a start and row limit");
($sql, $params) = WebGUI::Crud->getAllSql($session,{orderBy=>'lastUpdated'});
is($sql, "select `unnamed_crud_table`.`id` from `unnamed_crud_table` order by lastUpdated", "getAllSql() with a custom order by clause");
($sql, $params) = WebGUI::Crud->getAllSql($session,{join=>['someTable using (someId)']});
is($sql, "select `unnamed_crud_table`.`id` from `unnamed_crud_table` left join someTable using (someId) order by `unnamed_crud_table`.`sequenceNumber`", "getAllSql() with a custom join");
($sql, $params) = WebGUI::Crud->getAllSql($session,{joinUsing=>[{myTable => 'myId'}]});
is($sql, "select `unnamed_crud_table`.`id` from `unnamed_crud_table` left join `myTable` using (`myId`) order by `unnamed_crud_table`.`sequenceNumber`", "getAllSql() with a custom joinUsing");
($sql, $params) = WebGUI::Crud->getAllSql($session,{constraints=>[{'sequenceNumber=?'=>1}]});
is($sql, "select `unnamed_crud_table`.`id` from `unnamed_crud_table` where (sequenceNumber=?) order by `unnamed_crud_table`.`sequenceNumber`", "getAllSql() SQL with a constraint");
($sql, $params) = WebGUI::Cruddy->getAllSql($session, {limit=>5});
is($sql, "select `some_crud_table`.`id` from `some_crud_table` order by `some_crud_table`.`sequenceNumber` limit 5", "getAllSql() SQL with a row limit");
($sql, $params) = WebGUI::Cruddy->getAllSql($session,{limit=>[10,20]});
is($sql, "select `some_crud_table`.`id` from `some_crud_table` order by `some_crud_table`.`sequenceNumber` limit 10,20", "getAllSql() SQL with a start and row limit");
($sql, $params) = WebGUI::Cruddy->getAllSql($session,{orderBy=>'lastUpdated'});
is($sql, "select `some_crud_table`.`id` from `some_crud_table` order by lastUpdated", "getAllSql() with a custom order by clause");
($sql, $params) = WebGUI::Cruddy->getAllSql($session,{join=>['someTable using (someId)']});
is($sql, "select `some_crud_table`.`id` from `some_crud_table` left join someTable using (someId) order by `some_crud_table`.`sequenceNumber`", "getAllSql() with a custom join");
($sql, $params) = WebGUI::Cruddy->getAllSql($session,{joinUsing=>[{myTable => 'myId'}]});
is($sql, "select `some_crud_table`.`id` from `some_crud_table` left join `myTable` using (`myId`) order by `some_crud_table`.`sequenceNumber`", "getAllSql() with a custom joinUsing");
($sql, $params) = WebGUI::Cruddy->getAllSql($session,{constraints=>[{'sequenceNumber=?'=>1}]});
is($sql, "select `some_crud_table`.`id` from `some_crud_table` where (sequenceNumber=?) order by `some_crud_table`.`sequenceNumber`", "getAllSql() SQL with a constraint");
is($params->[0], 1, "getAllSql PARAMS with a constraint");
($sql, $params) = WebGUI::Crud->getAllSql($session,{constraints=>[{'sequenceNumber=? or sequenceNumber=?'=>[1,2]}]});
is($sql, "select `unnamed_crud_table`.`id` from `unnamed_crud_table` where (sequenceNumber=? or sequenceNumber=?) order by `unnamed_crud_table`.`sequenceNumber`", "getAllSql() SQL with two constraints");
($sql, $params) = WebGUI::Cruddy->getAllSql($session,{constraints=>[{'sequenceNumber=? or sequenceNumber=?'=>[1,2]}]});
is($sql, "select `some_crud_table`.`id` from `some_crud_table` where (sequenceNumber=? or sequenceNumber=?) order by `some_crud_table`.`sequenceNumber`", "getAllSql() SQL with two constraints");
is($params->[1], 2, "getAllSql PARAMS with two constraints");
is(scalar(@{WebGUI::Crud->getAllIds($session)}), 3, "getAllIds()");
my $iterator = WebGUI::Crud->getAllIterator($session);
is(scalar(@{WebGUI::Cruddy->getAllIds($session)}), 3, "getAllIds()");
my $iterator = WebGUI::Cruddy->getAllIterator($session);
while (my $object = $iterator->()) {
isa_ok($object, 'WebGUI::Crud', 'Put your trust in the Lord. Your ass belongs to me.');
isa_ok($object, 'WebGUI::Cruddy', 'Put your trust in the Lord. Your ass belongs to me.');
}
#crud management stuff
is(ref WebGUI::Crud->crud_getProperties($session), 'HASH', 'properties work');
is(WebGUI::Crud->crud_getTableKey($session), 'id', 'default key is id');
is(WebGUI::Crud->crud_getTableName($session), 'unnamed_crud_table', 'default table is unnamed_crud_table');
is(WebGUI::Crud->crud_getSequenceKey($session), '', 'default sequence key is blank');
is(ref WebGUI::Cruddy->crud_getProperties($session), 'HASH', 'properties work');
is(WebGUI::Cruddy->crud_getTableKey(), 'id', 'default key is id');
is(WebGUI::Cruddy->crud_getTableName(), 'some_crud_table', 'default table is some_crud_table');
is(WebGUI::Cruddy->crud_getSequenceKey(), undef, 'default sequence key is blank');
done_testing();
#vim:ft=perl

6
t/Crud/Subclass.t
View file

@ -29,12 +29,12 @@ plan tests => 4; # Increment this number for each test you create
# Create
WebGUI::Crud::Subclass->crud_createTable($session);
WebGUI::Test->addToCleanup(sub { WebGUI::Crud::Subclass->crud_dropTable($session); });
my $record1 = WebGUI::Crud::Subclass->create($session, { field1 => 10 });
my $record1 = WebGUI::Crud::Subclass->new($session, { field1 => 10 });
isa_ok($record1, "WebGUI::Crud", "isa WebGUI::Crud");
is($record1->get('field1'), 10, "got back correct field1 value");
# bug #10660 (zero should not trigger defaultValue)
is(WebGUI::Crud::Subclass->create($session, { field1 => 0 })->get('field1'), 0, 'zero does not trigger default');
is(WebGUI::Crud::Subclass->create($session, { field1 => '' })->get('field1'), 5, '..but empty string intentionally triggers default');
is(WebGUI::Crud::Subclass->new($session, { field1 => 0 })->get('field1'), 0, 'zero does not trigger default');
is(WebGUI::Crud::Subclass->new($session, { field1 => '' })->get('field1'), '', '..but empty string does not trigger default either');
#vim:ft=perl

9
t/Crud/serialize.t
View file

@ -36,7 +36,8 @@ WebGUI::Test->addToCleanup(sub {
WebGUI::Serialize->crud_dropTable($session);
});
my $cereal = WebGUI::Serialize->create($session);
my $cereal = WebGUI::Serialize->new($session);
$cereal->write;
isa_ok($cereal, 'WebGUI::Serialize');
cmp_deeply(
$cereal->get,
@ -99,18 +100,20 @@ cmp_deeply(
'new: deserialized data correctly'
);
use Data::Dumper;
my $objData = $cereal->get('jsonField');
$objData->[0]->{fiber} = 0;
cmp_deeply(
$cereal->get('jsonField'),
[
{
fiber => 0,
sugarContent => 50,
averageNutrition => 3,
foodColoring => 15,
},
],
'get: returns safe references'
);
'get: returns unsafe references'
) or diag Dumper($cereal->jsonField);
#vim:ft=perl

7
t/FilePump/Bundle.t
View file

@ -32,16 +32,17 @@ my $session = WebGUI::Test->session;
#----------------------------------------------------------------------------
# Tests
plan tests => 64;
plan tests => 65;
#----------------------------------------------------------------------------
# put your tests here
use WebGUI::FilePump::Bundle;
my $bundle = WebGUI::FilePump::Bundle->create($session);
my $bundle = WebGUI::FilePump::Bundle->new($session);
isa_ok($bundle, 'WebGUI::FilePump::Bundle');
isa_ok($bundle, 'WebGUI::Crud');
can_ok($bundle, qw/update write getJSONCollateralDataIndex/);
is($bundle->get('lastModified'), 0, 'by default, lastModified is 0');
@ -449,7 +450,7 @@ ok(!-e $buildDir->stringify, 'delete deletes the current build directory');
my @jsFiles = qw/hoverhelp.js inputcheck.js/;
foreach my $jsFile (@jsFiles) {
my $bundle = WebGUI::FilePump::Bundle->create($session);
my $bundle = WebGUI::FilePump::Bundle->new($session);
$bundle->addFile('JS', 'file:extras/'.$jsFile);
lives_ok { $bundle->build } "built file $jsFile";
$bundle->delete;

2
t/Macro/FilePump.t
View file

@ -32,7 +32,7 @@ plan tests => 11;
#----------------------------------------------------------------------------
# put your tests here
my $bundle = WebGUI::FilePump::Bundle->create($session, { bundleName => 'test bundle'});
my $bundle = WebGUI::FilePump::Bundle->new($session, { bundleName => 'test bundle'});
my $root = WebGUI::Asset->getRoot($session);

2
t/Workflow/Activity/BucketPassiveAnalytics.t
View file

@ -59,7 +59,7 @@ my @ruleSets = (
my @url2 = @ruleSets;
while (my $spec = shift @url2) {
my ($bucket, undef, $regexp) = @{ $spec };
WebGUI::PassiveAnalytics::Rule->create($session, { bucketName => $bucket, regexp => $regexp });
WebGUI::PassiveAnalytics::Rule->new($session, { bucketName => $bucket, regexp => $regexp });
}
my @urls = map {$_->[1]} @ruleSets;

43
t/lib/WebGUI/Serialize.pm
View file

@ -1,6 +1,28 @@
package WebGUI::Serialize;
use base qw/WebGUI::Crud/;
use Moose;
use WebGUI::Definition::Crud;
extends qw/WebGUI::Crud/;
define tableName => 'crudSerialize';
define tableKey => 'serializeId';
has serializeId => (
required => 1,
is => 'ro',
);
property someName => (
label => 'someName',
fieldType => 'text',
default => 'someName',
);
property jsonField => (
label => 'jsonField',
fieldType => 'textarea',
default => sub { return []; },
isa => 'WebGUI::Type::JSONArray',
coerce => 1,
traits => ['Array', 'WebGUI::Definition::Meta::Property::Serialize',],
);
#-------------------------------------------------------------------
@ -33,22 +55,9 @@ JSON blob text field.
=cut
sub crud_definition {
my ($class, $session) = @_;
my $definition = $class->SUPER::crud_definition($session);
$definition->{tableName} = 'crudSerialize';
$definition->{tableKey} = 'serializeId';
$definition->{sequenceKey} = '';
my $properties = $definition->{properties};
$properties->{someName} = {
fieldType => 'text',
defaultValue => 'someName',
};
$properties->{jsonField} = {
fieldType => 'textarea',
defaultValue => [],
serialize => 1,
};
return $definition;
my ($class, $session) = @_;
my $definition = $class->SUPER::crud_definition($session);
return $definition;
}

28
t/lib/WebGUI/SubClass.pm
View file

@ -2,20 +2,20 @@ package WebGUI::Crud::Subclass;
use strict;
use base 'WebGUI::Crud';
use Moose;
use WebGUI::Definition::Crud;
extends 'WebGUI::Crud';
define tableName => 'crudSubclass';
define tableKey => 'crudSubclassId';
has crudSubclassId => (
required => 1,
is => 'ro',
);
sub crud_definition {
my ($class, $session) = @_;
my $definition = $class->SUPER::crud_definition($session);
$definition->{tableName} = 'crudSubclass';
$definition->{tableKey} = 'crudSubclassId';
$definition->{sequenceKey} = '';
my $properties = $definition->{properties};
$properties->{field1} = {
fieldType => 'integer',
defaultValue => 5,
};
return $definition;
}
property field1 => (
label => 'field1',
fieldType => 'integer',
defaultValue => 5,
);
1;