X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=t%2F13schema.t;h=e72da0213f56f18af947c77a99112355a8c11c20;hb=cc00c034bcfb007c0e4db411949a3af5c0ff6900;hp=3e978e1a8209078149ee08ca43f1384fcc2b6b75;hpb=adfdb552e3d52ddb61880d8d76cfcfc3a63ae331;p=dbsrgits%2FSQL-Translator.git diff --git a/t/13schema.t b/t/13schema.t index 3e978e1..e72da02 100644 --- a/t/13schema.t +++ b/t/13schema.t @@ -4,9 +4,10 @@ $| = 1; use strict; -use Test::More tests => 150; +use Test::More tests => 229; use SQL::Translator::Schema::Constants; +require_ok( 'SQL::Translator' ); require_ok( 'SQL::Translator::Schema' ); { @@ -51,24 +52,57 @@ require_ok( 'SQL::Translator::Schema' ); my $redundant_table = $schema->add_table(name => 'foo'); is( $redundant_table, undef, qq[Can't create another "foo" table...] ); - like( $schema->error, qr/can't use table name/i, '... because "foo" exists' ); + like( $schema->error, qr/can't use table name/i, + '... because "foo" exists' ); + $redundant_table = $schema->add_table(name => ''); + is( $redundant_table, undef, qq[Can't add an anonymous table...] ); + like( $schema->error, qr/No table name/i, + '... because it has no name ' ); + + $redundant_table = SQL::Translator::Schema::Table->new(name => ''); + is( $redundant_table, undef, qq[Can't create an anonymous table] ); + like( SQL::Translator::Schema::Table->error, qr/No table name/i, + '... because it has no name ' ); + + # + # $schema-> drop_table + # + my $dropped_table = $schema->drop_table($foo_table->name, cascade => 1); + isa_ok($dropped_table, 'SQL::Translator::Schema::Table', 'Dropped table "foo"' ); + $schema->add_table($foo_table); + my $dropped_table2 = $schema->drop_table($foo_table, cascade => 1); + isa_ok($dropped_table2, 'SQL::Translator::Schema::Table', 'Dropped table "foo" by object' ); + my $dropped_table3 = $schema->drop_table($foo_table->name, cascade => 1); + like( $schema->error, qr/doesn't exist/, qq[Can't drop non-existant table "foo"] ); + + $schema->add_table($foo_table); # # Table default new # is( $foo_table->name, 'foo', 'Table name is "foo"' ); + is( "$foo_table", 'foo', 'Table stringifies to "foo"' ); is( $foo_table->is_valid, undef, 'Table "foo" is not yet valid' ); my $fields = $foo_table->get_fields; is( scalar @{ $fields || [] }, 0, 'Table "foo" has no fields' ); like( $foo_table->error, qr/no fields/i, 'Error for no fields' ); + is( $foo_table->comments, undef, 'No comments' ); + # # New table with args # - my $person_table = $schema->add_table( name => 'person' ); + my $person_table = $schema->add_table( + name => 'person', + comments => 'foo', + ); is( $person_table->name, 'person', 'Table name is "person"' ); is( $person_table->is_valid, undef, 'Table is not yet valid' ); + is( $person_table->comments, 'foo', 'Comments = "foo"' ); + is( join(',', $person_table->comments('bar')), 'foo,bar', + 'Table comments = "foo,bar"' ); + is( $person_table->comments, "foo\nbar", 'Table comments = "foo,bar"' ); # # Field default new @@ -77,21 +111,32 @@ require_ok( 'SQL::Translator::Schema' ); warn $person_table->error; isa_ok( $f1, 'SQL::Translator::Schema::Field', 'Field' ); is( $f1->name, 'foo', 'Field name is "foo"' ); + is( $f1->full_name, 'person.foo', 'Field full_name is "person.foo"' ); + is( "$f1", 'foo', 'Field stringifies to "foo"' ); is( $f1->data_type, '', 'Field data type is blank' ); is( $f1->size, 0, 'Field size is "0"' ); is( $f1->is_primary_key, '0', 'Field is_primary_key is false' ); is( $f1->is_nullable, 1, 'Field can be NULL' ); is( $f1->default_value, undef, 'Field default is undefined' ); - - my $f2 = SQL::Translator::Schema::Field->new (name => 'f2') or - warn SQL::Translator::Schema::Field->error; + is( $f1->comments, '', 'No comments' ); + is( $f1->table, 'person', 'Field table is person' ); + is( $f1->schema->database, 'PostgreSQL', 'Field schema shortcut works' ); + + my $f2 = SQL::Translator::Schema::Field->new ( + name => 'f2', + comments => 'foo', + ) or warn SQL::Translator::Schema::Field->error; $f2 = $person_table->add_field( $f2 ); isa_ok( $f1, 'SQL::Translator::Schema::Field', 'f2' ); is( $f2->name, 'f2', 'Add field "f2"' ); is( $f2->is_nullable(0), 0, 'Field cannot be NULL' ); is( $f2->is_nullable(''), 0, 'Field cannot be NULL' ); is( $f2->is_nullable('0'), 0, 'Field cannot be NULL' ); - is( $f1->default_value(''), '', 'Field default is empty string' ); + is( $f2->default_value(''), '', 'Field default is empty string' ); + is( $f2->comments, 'foo', 'Field comment = "foo"' ); + is( join(',', $f2->comments('bar')), 'foo,bar', + 'Field comment = "foo,bar"' ); + is( $f2->comments, "foo\nbar", 'Field comment = "foo,bar"' ); $person_table = $f2->table( $person_table ); isa_ok( $person_table, 'SQL::Translator::Schema::Table', 'person_table' ); @@ -104,16 +149,41 @@ require_ok( 'SQL::Translator::Schema' ); like( $person_table->error, qr/can't use field/i, '... because it exists' ); + $redundant_field = $person_table->add_field(name => ''); + is( $redundant_field, undef, qq[Didn't add a "" field...] ); + like( $person_table->error, qr/No field name/i, + '... because it has no name' ); + + $redundant_field = SQL::Translator::Schema::Field->new(name => ''); + is( $redundant_field, undef, qq[Didn't create a "" field...] ); + like( SQL::Translator::Schema::Field->error, qr/No field name/i, + '... because it has no name' ); + my @fields = $person_table->get_fields; is( scalar @fields, 2, 'Table "foo" has 2 fields' ); is( $fields[0]->name, 'foo', 'First field is "foo"' ); is( $fields[1]->name, 'f2', 'Second field is "f2"' ); + is( join(",",$person_table->field_names), 'foo,f2', + 'field_names is "foo,f2"' ); + + # + # $table-> drop_field + # + my $dropped_field = $person_table->drop_field($f2->name, cascade => 1); + isa_ok($dropped_field, 'SQL::Translator::Schema::Field', 'Dropped field "f2"' ); + $person_table->add_field($f2); + my $dropped_field2 = $person_table->drop_field($f2, cascade => 1); + isa_ok($dropped_field2, 'SQL::Translator::Schema::Field', 'Dropped field "f2" by object' ); + my $dropped_field3 = $person_table->drop_field($f2->name, cascade => 1); + like( $person_table->error, qr/doesn't exist/, qq[Can't drop non-existant field "f2"] ); + + $person_table->add_field($f2); # # Field methods # - is( $f1->name('person_name'), 'person_name', + is( $f1->name('person_name'), 'person_name', 'Field name is "person_name"' ); is( $f1->data_type('varchar'), 'varchar', 'Field data type is "varchar"' ); is( $f1->size('30'), '30', 'Field size is "30"' ); @@ -180,6 +250,20 @@ require_ok( 'SQL::Translator::Schema' ); is( $indices->[1]->name, 'bar', '"bar" index' ); # + # $table-> drop_index + # + my $dropped_index = $person_table->drop_index($index1->name); + isa_ok($dropped_index, 'SQL::Translator::Schema::Index', 'Dropped index "foo"' ); + $person_table->add_index($index1); + my $dropped_index2 = $person_table->drop_index($index1); + isa_ok($dropped_index2, 'SQL::Translator::Schema::Index', 'Dropped index "foo" by object' ); + is($dropped_index2->name, $index1->name, 'Dropped correct index "foo"'); + my $dropped_index3 = $person_table->drop_index($index1->name); + like( $person_table->error, qr/doesn't exist/, qq[Can't drop non-existant index "foo"] ); + + $person_table->add_index($index1); + + # # Constraint # my @constraints = $person_table->get_constraints; @@ -191,26 +275,33 @@ require_ok( 'SQL::Translator::Schema' ); isa_ok( $constraint1, 'SQL::Translator::Schema::Constraint', 'Constraint' ); is( $constraint1->name, 'foo', 'Constraint name is "foo"' ); - $fields = join(',', $constraint1->fields('id') ); - is( $fields, 'id', 'Constraint field = "id"' ); + $fields = join(',', $constraint1->fields('age') ); + is( $fields, 'age', 'Constraint field = "age"' ); + + $fields = $constraint1->fields; + ok( ref $fields[0] && $fields[0]->isa("SQL::Translator::Schema::Field"), + 'Constraint fields returns a SQL::Translator::Schema::Field' ); - $fields = join(',', $constraint1->fields('id,id') ); - is( $fields, 'id', 'Constraint field = "id"' ); + $fields = join(',', $constraint1->fields('age,age') ); + is( $fields, 'age', 'Constraint field = "age"' ); - $fields = join(',', $constraint1->fields('id', 'name') ); - is( $fields, 'id,name', 'Constraint field = "id,name"' ); + $fields = join(',', $constraint1->fields('age', 'name') ); + is( $fields, 'age,name', 'Constraint field = "age,name"' ); - $fields = join(',', $constraint1->fields( 'id,name,id' ) ); - is( $fields, 'id,name', 'Constraint field = "id,name"' ); + $fields = join(',', $constraint1->fields( 'age,name,age' ) ); + is( $fields, 'age,name', 'Constraint field = "age,name"' ); - $fields = join(',', $constraint1->fields( 'id, name' ) ); - is( $fields, 'id,name', 'Constraint field = "id,name"' ); + $fields = join(',', $constraint1->fields( 'age, name' ) ); + is( $fields, 'age,name', 'Constraint field = "age,name"' ); - $fields = join(',', $constraint1->fields( [ 'id', 'name' ] ) ); - is( $fields, 'id,name', 'Constraint field = "id,name"' ); + $fields = join(',', $constraint1->fields( [ 'age', 'name' ] ) ); + is( $fields, 'age,name', 'Constraint field = "age,name"' ); - $fields = join(',', $constraint1->fields( qw[ id name ] ) ); - is( $fields, 'id,name', 'Constraint field = "id,name"' ); + $fields = join(',', $constraint1->fields( qw[ age name ] ) ); + is( $fields, 'age,name', 'Constraint field = "age,name"' ); + + $fields = join(',', $constraint1->field_names ); + is( $fields, 'age,name', 'Constraint field_names = "age,name"' ); is( $constraint1->match_type, '', 'Constraint match type is empty' ); is( $constraint1->match_type('foo'), undef, @@ -225,12 +316,35 @@ require_ok( 'SQL::Translator::Schema' ); isa_ok( $constraint2, 'SQL::Translator::Schema::Constraint', 'Constraint' ); is( $constraint2->name, 'bar', 'Constraint name is "bar"' ); + my $constraint3 = $person_table->add_constraint( + type => 'check', + expression => 'foo bar', + ) or die $person_table->error; + isa_ok( $constraint3, 'SQL::Translator::Schema::Constraint', 'Constraint' ); + is( $constraint3->type, CHECK_C, 'Constraint type is "CHECK"' ); + is( $constraint3->expression, 'foo bar', + 'Constraint expression is "foo bar"' ); + my $constraints = $person_table->get_constraints; - is( scalar @$constraints, 2, 'Two constraints' ); + is( scalar @$constraints, 3, 'Three constraints' ); is( $constraints->[0]->name, 'foo', '"foo" constraint' ); is( $constraints->[1]->name, 'bar', '"bar" constraint' ); # + # $table-> drop_constraint + # + my $dropped_con = $person_table->drop_constraint($constraint1->name); + isa_ok($dropped_con, 'SQL::Translator::Schema::Constraint', 'Dropped constraint "foo"' ); + $person_table->add_constraint($constraint1); + my $dropped_con2 = $person_table->drop_constraint($constraint1); + isa_ok($dropped_con2, 'SQL::Translator::Schema::Constraint', 'Dropped constraint "foo" by object' ); + is($dropped_con2->name, $constraint1->name, 'Dropped correct constraint "foo"'); + my $dropped_con3 = $person_table->drop_constraint($constraint1->name); + like( $person_table->error, qr/doesn't exist/, qq[Can't drop non-existant constraint "foo"] ); + + $person_table->add_constraint($constraint1); + + # # View # my $view = $schema->add_view( name => 'view1' ) or warn $schema->error; @@ -248,6 +362,20 @@ require_ok( 'SQL::Translator::Schema' ); like( $schema->error, qr/can't create view/i, '... because it exists' ); # + # $schema-> drop_view + # + my $dropped_view = $schema->drop_view($view->name); + isa_ok($dropped_view, 'SQL::Translator::Schema::View', 'Dropped view "view1"' ); + $schema->add_view($view); + my $dropped_view2 = $schema->drop_view($view); + isa_ok($dropped_view2, 'SQL::Translator::Schema::View', 'Dropped view "view1" by object' ); + is($dropped_view2->name, $view->name, 'Dropped correct view "view1"'); + my $dropped_view3 = $schema->drop_view($view->name); + like( $schema->error, qr/doesn't exist/, qq[Can't drop non-existant view "view1"] ); + + $schema->add_view($view); + + # # $schema->get_* # my $bad_table = $schema->get_table; @@ -279,6 +407,7 @@ require_ok( 'SQL::Translator::Schema' ); my @views = $schema->get_views; is( scalar @views, 2, 'Found 1 view' ); + } # @@ -289,7 +418,7 @@ require_ok( 'SQL::Translator::Schema' ); name => 'foo', database => 'PostgreSQL', ); - my $t = $s->add_table( name => 'person' ) or warn $s->erro; + my $t = $s->add_table( name => 'person' ) or warn $s->error; my $f = $t->add_field( name => 'person_id' ) or warn $t->error; $f->data_type('serial'); @@ -376,7 +505,6 @@ require_ok( 'SQL::Translator::Schema' ); my $t = $s->add_table( name => 'person' ); is( $t->primary_key, undef, 'No primary key' ); - like( $t->error, qr/no primary key/i, 'No primary key error' ); is( $t->primary_key('person_id'), undef, q[Can't make PK on "person_id"...] ); @@ -422,18 +550,128 @@ require_ok( 'SQL::Translator::Schema' ); # View # { + my $s = SQL::Translator::Schema->new( name => 'ViewTest' ); my $name = 'foo_view'; my $sql = 'select name, age from person'; my $fields = 'name, age'; - my $s = SQL::Translator::Schema->new; my $v = $s->add_view( name => $name, sql => $sql, fields => $fields, + schema => $s, ); isa_ok( $v, 'SQL::Translator::Schema::View', 'View' ); + isa_ok( $v->schema, 'SQL::Translator::Schema', 'Schema' ); + is( $v->schema->name, 'ViewTest', qq[Schema name is "'ViewTest'"] ); is( $v->name, $name, qq[Name is "$name"] ); is( $v->sql, $sql, qq[Name is "$sql"] ); is( join(':', $v->fields), 'name:age', qq[Fields are "$fields"] ); + + my @views = $s->get_views; + is( scalar @views, 1, 'Number of views is 1' ); + + my $v1 = $s->get_view( $name ); + isa_ok( $v1, 'SQL::Translator::Schema::View', 'View' ); + is( $v1->name, $name, qq[Name is "$name"] ); +} + +# +# Trigger +# +{ + my $s = SQL::Translator::Schema->new(name => 'TrigTest'); + $s->add_table(name=>'foo') or die "Couldn't create table: ", $s->error; + my $name = 'foo_trigger'; + my $perform_action_when = 'after'; + my $database_event = 'insert'; + my $on_table = 'foo'; + my $action = 'update modified=timestamp();'; + my $t = $s->add_trigger( + name => $name, + perform_action_when => $perform_action_when, + database_event => $database_event, + on_table => $on_table, + action => $action, + ) or die $s->error; + + isa_ok( $t, 'SQL::Translator::Schema::Trigger', 'Trigger' ); + isa_ok( $t->schema, 'SQL::Translator::Schema', 'Schema' ); + is( $t->schema->name, 'TrigTest', qq[Schema name is "'TrigTest'"] ); + is( $t->name, $name, qq[Name is "$name"] ); + is( $t->perform_action_when, $perform_action_when, + qq[Perform action when is "$perform_action_when"] ); + is( $t->database_event, $database_event, + qq[Database event is "$database_event"] ); + isa_ok( $t->table, 'SQL::Translator::Schema::Table', qq[table is a Table"] ); + is( $t->action, $action, qq[Action is "$action"] ); + + my @triggs = $s->get_triggers; + is( scalar @triggs, 1, 'Number of triggers is 1' ); + + my $t1 = $s->get_trigger( $name ); + isa_ok( $t1, 'SQL::Translator::Schema::Trigger', 'Trigger' ); + is( $t1->name, $name, qq[Name is "$name"] ); + + # + # $schema-> drop_trigger + # + my $dropped_trig = $s->drop_trigger($t->name); + isa_ok($dropped_trig, 'SQL::Translator::Schema::Trigger', 'Dropped trigger "foo_trigger"' ); + $s->add_trigger($t); + my $dropped_trig2 = $s->drop_trigger($t); + isa_ok($dropped_trig2, 'SQL::Translator::Schema::Trigger', 'Dropped trigger "foo_trigger" by object' ); + is($dropped_trig2->name, $t->name, 'Dropped correct trigger "foo_trigger"'); + my $dropped_trig3 = $s->drop_trigger($t->name); + like( $s->error, qr/doesn't exist/, qq[Can't drop non-existant trigger "foo_trigger"] ); + + $s->add_trigger($t); +} + +# +# Procedure +# +{ + my $s = SQL::Translator::Schema->new( name => 'ProcTest' ); + my $name = 'foo_proc'; + my $sql = 'select foo from bar'; + my $parameters = 'foo, bar'; + my $owner = 'Nomar'; + my $comments = 'Go Sox!'; + my $p = $s->add_procedure( + name => $name, + sql => $sql, + parameters => $parameters, + owner => $owner, + comments => $comments, + ) or die $s->error; + + isa_ok( $p, 'SQL::Translator::Schema::Procedure', 'Procedure' ); + isa_ok( $p->schema, 'SQL::Translator::Schema', 'Schema' ); + is( $p->schema->name, 'ProcTest', qq[Schema name is "'ProcTest'"] ); + is( $p->name, $name, qq[Name is "$name"] ); + is( $p->sql, $sql, qq[SQL is "$sql"] ); + is( join(',', $p->parameters), 'foo,bar', qq[Params = 'foo,bar'] ); + is( $p->comments, $comments, qq[Comments = "$comments"] ); + + my @procs = $s->get_procedures; + is( scalar @procs, 1, 'Number of procedures is 1' ); + + my $p1 = $s->get_procedure( $name ); + isa_ok( $p1, 'SQL::Translator::Schema::Procedure', 'Procedure' ); + is( $p1->name, $name, qq[Name is "$name"] ); + + # + # $schema-> drop_procedure + # + my $dropped_proc = $s->drop_procedure($p->name); + isa_ok($dropped_proc, 'SQL::Translator::Schema::Procedure', 'Dropped procedure "foo_proc"' ); + $s->add_procedure($p); + my $dropped_proc2 = $s->drop_procedure($p); + isa_ok($dropped_proc2, 'SQL::Translator::Schema::Procedure', 'Dropped procedure "foo_proc" by object' ); + is($dropped_proc2->name, $p->name, 'Dropped correct procedure "foo_proc"'); + my $dropped_proc3 = $s->drop_procedure($p->name); + like( $s->error, qr/doesn't exist/, qq[Can't drop non-existant procedure "foo_proc"] ); + + $s->add_procedure($p); }