From: Rafael Kitover Date: Fri, 25 Dec 2009 09:14:30 +0000 (+0000) Subject: more complete backcompat tests, one last thing to do X-Git-Tag: 0.04999_13~21 X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=a0e0a56a9b622b79fdc4584eabea5d715d309c79;p=dbsrgits%2FDBIx-Class-Schema-Loader.git more complete backcompat tests, one last thing to do --- diff --git a/TODO-BACKCOMPAT b/TODO-BACKCOMPAT index afb0316..b8fe2b1 100644 --- a/TODO-BACKCOMPAT +++ b/TODO-BACKCOMPAT @@ -2,15 +2,9 @@ SL Backcompat Plan: *** 0.04006 mode -* add a loud warning that says that we're running in backcompat mode, and refers - to the ::Manual::UpgradingFromV4 POD. * preserve custom content from un-singularized Results and delete them when in upgrade mode -*** backcompat tests - -Need a comprehensive backcompat.t - *** Catalyst Helper * Add 'upgrade=1' option that upgrades from both old S::L and old helper, diff --git a/lib/DBIx/Class/Schema/Loader.pm b/lib/DBIx/Class/Schema/Loader.pm index c4c128f..4f55c89 100644 --- a/lib/DBIx/Class/Schema/Loader.pm +++ b/lib/DBIx/Class/Schema/Loader.pm @@ -152,7 +152,7 @@ sub _invoke_loader { $args->{schema_class} = $class; weaken($args->{schema}) if ref $self; $args->{dump_directory} ||= $self->dump_to_dir; - $args->{naming} = $self->naming; + $args->{naming} = $self->naming if $self->naming; # XXX this only works for relative storage_type, like ::DBI ... my $impl = $self->loader_class diff --git a/lib/DBIx/Class/Schema/Loader/Base.pm b/lib/DBIx/Class/Schema/Loader/Base.pm index 5403cc2..16507e7 100644 --- a/lib/DBIx/Class/Schema/Loader/Base.pm +++ b/lib/DBIx/Class/Schema/Loader/Base.pm @@ -385,6 +385,9 @@ Dynamic schema detected, will run in 0.04006 mode. Set the 'naming' attribute or the SCHEMA_LOADER_BACKCOMPAT environment variable to disable this warning. + +See perldoc DBIx::Class::Schema::Loader::Manual::UpgradingFromV4 for more +details. EOF } @@ -405,15 +408,30 @@ EOF if (/^# Created by DBIx::Class::Schema::Loader v((\d+)\.(\d+))/) { my $real_ver = $1; - $self->schema_version_to_dump($real_ver); - # XXX when we go past .0 this will need fixing my ($v) = $real_ver =~ /([1-9])/; $v = "v$v"; + last if $v eq CURRENT_V; + + if (not %{ $self->naming }) { + warn <<"EOF" unless $ENV{SCHEMA_LOADER_BACKCOMPAT}; + +Version $real_ver static schema detected, turning on backcompat mode. + +Set the 'naming' attribute or the SCHEMA_LOADER_BACKCOMPAT environment variable +to disable this warning. + +See perldoc DBIx::Class::Schema::Loader::Manual::UpgradingFromV4 for more +details. +EOF + } + $self->naming->{relationships} ||= $v; $self->naming->{monikers} ||= $v; + $self->schema_version_to_dump($real_ver); + last; } } diff --git a/lib/DBIx/Class/Schema/Loader/Manual/UpgradingFromV4.pod b/lib/DBIx/Class/Schema/Loader/Manual/UpgradingFromV4.pod index d64f056..4db5e74 100644 --- a/lib/DBIx/Class/Schema/Loader/Manual/UpgradingFromV4.pod +++ b/lib/DBIx/Class/Schema/Loader/Manual/UpgradingFromV4.pod @@ -20,9 +20,9 @@ C that it didn't set before. RelBuilder -The new RelBuilder will give you much nicer accessor names for relationships, -so you will no longer have conflicts between a foreign key column and the -relationship accessor itself. +The new RelBuilder will give you nicer accessor names for relationships, so you +will no longer have conflicts between a foreign key column and the relationship +accessor itself (if the FK is named C<_id>.) It will also more correctly infer the relationship type, e.g. some relationships that were previously detected as a C will now be a C diff --git a/t/25backcompat_v4.t b/t/25backcompat_v4.t index a7e3575..8c22c2c 100644 --- a/t/25backcompat_v4.t +++ b/t/25backcompat_v4.t @@ -1,25 +1,25 @@ use strict; use warnings; use Test::More; -use File::Path; +use File::Path qw/rmtree make_path/; use Class::Unload; use lib qw(t/lib); use make_dbictest_db2; my $DUMP_DIR = './t/_common_dump'; rmtree $DUMP_DIR; +my $SCHEMA_CLASS = 'DBIXCSL_Test::Schema'; sub run_loader { my %loader_opts = @_; - my $schema_class = 'DBIXCSL_Test::Schema'; - Class::Unload->unload($schema_class); + Class::Unload->unload($SCHEMA_CLASS); my @connect_info = $make_dbictest_db2::dsn; my @loader_warnings; local $SIG{__WARN__} = sub { push(@loader_warnings, $_[0]); }; eval qq{ - package $schema_class; + package $SCHEMA_CLASS; use base qw/DBIx::Class::Schema::Loader/; __PACKAGE__->loader_options(\%loader_opts); @@ -28,12 +28,12 @@ sub run_loader { ok(!$@, "Loader initialization") or diag $@; - my $schema = $schema_class->clone; + my $schema = $SCHEMA_CLASS->clone; my (%monikers, %classes); foreach my $source_name ($schema->sources) { my $table_name = $schema->source($source_name)->from; $monikers{$table_name} = $source_name; - $classes{$table_name} = "${schema_class}::${source_name}"; + $classes{$table_name} = "${SCHEMA_CLASS}::${source_name}"; } return { @@ -44,30 +44,173 @@ sub run_loader { }; } +sub run_v4_tests { + my $res = shift; + my $schema = $res->{schema}; + + is_deeply [ @{ $res->{monikers} }{qw/foos bar bazs quuxs/} ], + [qw/Foos Bar Bazs Quuxs/], + 'correct monikers in 0.04006 mode'; + + ok my $bar = eval { $schema->resultset('Bar')->find(1) }; + + isa_ok eval { $bar->foo_id }, $res->{classes}{foos}, + 'correct rel name in 0.04006 mode'; + + ok my $baz = eval { $schema->resultset('Bazs')->find(1) }; + + isa_ok eval { $baz->quux }, 'DBIx::Class::ResultSet', + 'correct rel type and name for UNIQUE FK in 0.04006 mode'; +} + +sub run_v5_tests { + my $res = shift; + my $schema = $res->{schema}; + + is_deeply [ @{ $res->{monikers} }{qw/foos bar bazs quuxs/} ], + [qw/Foo Bar Baz Quux/], + 'correct monikers in current mode'; + + ok my $bar = eval { $schema->resultset('Bar')->find(1) }; + + isa_ok eval { $bar->foo }, $res->{classes}{foos}, + 'correct rel name in current mode'; + + ok my $baz = eval { $schema->resultset('Baz')->find(1) }; + + isa_ok eval { $baz->quux }, $res->{classes}{quuxs}, + 'correct rel type and name for UNIQUE FK in current mode'; +} + # test dynamic schema in 0.04006 mode { my $res = run_loader(); + my $warning = $res->{warnings}[0]; - like $res->{warnings}[0], qr/dynamic schema/i, + like $warning, qr/dynamic schema/i, 'dynamic schema in backcompat mode detected'; - like $res->{warnings}[0], qr/run in 0\.04006 mode/, + like $warning, qr/run in 0\.04006 mode/i, 'dynamic schema in 0.04006 mode warning'; + like $warning, qr/DBIx::Class::Schema::Loader::Manual::UpgradingFromV4/, + 'warning refers to upgrading doc'; + + run_v4_tests($res); +} - is_deeply [ @{ $res->{monikers} }{qw/foos bar bazes quuxes/} ], - [qw/Foos Bar Bazes Quuxes/], - 'correct monikers in 0.04006 mode'; +# setting naming accessor on dynamic schema should disable warning (even when +# we're setting it to 'v4' .) +{ + my $res = run_loader(naming => 'v4'); - ok my $bar = eval { $res->{schema}->resultset('Bar')->find(1) }; + is_deeply $res->{warnings}, [], 'no warnings with naming attribute set'; +} + +# test upgraded dynamic schema +{ + my $res = run_loader(naming => 'current'); - isa_ok eval { $bar->fooref }, $res->{classes}{foos}, - 'correct rel name'; +# to dump a schema for debugging... +# { +# mkdir '/tmp/HLAGH'; +# $schema->_loader->{dump_directory} = '/tmp/HLAGH'; +# $schema->_loader->_dump_to_dir(values %{ $res->{classes} }); +# } - ok my $baz = eval { $res->{schema}->resultset('Bazes')->find(1) }; + is_deeply $res->{warnings}, [], 'no warnings with naming attribute set'; - isa_ok eval { $baz->quuxes }, 'DBIx::Class::ResultSet', - 'correct rel type and name for UNIQUE FK'; + run_v5_tests($res); +} + + +# test running against v4 schema without upgrade +{ + # write out the 0.04006 Schema.pm we have in __DATA__ + (my $schema_dir = "$DUMP_DIR/$SCHEMA_CLASS") =~ s/::[^:]+\z//; + make_path $schema_dir; + my $schema_pm = "$schema_dir/Schema.pm"; + open my $fh, '>', $schema_pm or die $!; + while () { + print $fh $_; + } + close $fh; + + # now run the loader + my $res = run_loader(dump_directory => $DUMP_DIR); + my $warning = $res->{warnings}[0]; + + like $warning, qr/static schema/i, + 'static schema in backcompat mode detected'; + like $warning, qr/0.04006/, + 'correct version detected'; + like $warning, qr/DBIx::Class::Schema::Loader::Manual::UpgradingFromV4/, + 'refers to upgrading doc'; + + run_v4_tests($res); + + # add some custom content to a Result that will be replaced + my $schema = $res->{schema}; + my $quuxs_pm = $schema->_loader + ->_get_dump_filename($res->{classes}{quuxs}); + { + local ($^I, @ARGV) = ('', $quuxs_pm); + while (<>) { + if (/DO NOT MODIFY THIS OR ANYTHING ABOVE/) { + print; + print "sub a_method { 'mtfnpy' }\n"; + } + else { + print; + } + } + } + + # now upgrade the schema + $res = run_loader(dump_directory => $DUMP_DIR, naming => 'current'); + $schema = $res->{schema}; + + like $res->{warnings}[0], qr/Dumping manual schema/i, + 'correct warnings on upgrading static schema (with "naming" set)'; + + like $res->{warnings}[1], qr/dump completed/i, + 'correct warnings on upgrading static schema (with "naming" set)'; + + is scalar @{ $res->{warnings} }, 2, +'correct number of warnings on upgrading static schema (with "naming" set)'; + + run_v5_tests($res); + + (my $result_dir = "$DUMP_DIR/$SCHEMA_CLASS") =~ s{::}{/}g; + my $result_count =()= glob "$result_dir/*"; + + is $result_count, 4, + 'un-singularized results were replaced during upgrade'; + + # check that custom content was preserved + is eval { $schema->resultset('Quux')->find(1)->a_method }, 'mtfnpy', + 'custom content was carried over from un-singularized Result'; } done_testing; END { rmtree $DUMP_DIR } + +# a Schema.pm made with 0.04006 + +__DATA__ +package DBIXCSL_Test::Schema; + +use strict; +use warnings; + +use base 'DBIx::Class::Schema'; + +__PACKAGE__->load_classes; + + +# Created by DBIx::Class::Schema::Loader v0.04006 @ 2009-12-25 01:49:25 +# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:ibIJTbfM1ji4pyD/lgSEog + + +# You can replace this text with custom content, and it will be preserved on regeneration +1; + diff --git a/t/lib/make_dbictest_db2.pm b/t/lib/make_dbictest_db2.pm index b16761b..5a00179 100644 --- a/t/lib/make_dbictest_db2.pm +++ b/t/lib/make_dbictest_db2.pm @@ -20,29 +20,29 @@ $dbh->do($_) for ( )|, q|CREATE TABLE bar ( barid INTEGER PRIMARY KEY, - fooref INTEGER REFERENCES foos (fooid) + foo_id INTEGER REFERENCES foos (fooid) )|, - q|CREATE TABLE bazes ( + q|CREATE TABLE bazs ( bazid INTEGER PRIMARY KEY, baz_num INTEGER NOT NULL UNIQUE )|, - q|CREATE TABLE quuxes ( + q|CREATE TABLE quuxs ( quuxid INTEGER PRIMARY KEY, - bazref INTEGER NOT NULL, - FOREIGN KEY (bazref) REFERENCES bazes (baz_num) + baz_id INTEGER NOT NULL UNIQUE, + FOREIGN KEY (baz_id) REFERENCES bazs (baz_num) )|, - q|INSERT INTO foos VALUES (1,'Foo text for number 1')|, - q|INSERT INTO foos VALUES (2,'Foo record associated with the Bar with barid 3')|, - q|INSERT INTO foos VALUES (3,'Foo text for number 3')|, - q|INSERT INTO foos VALUES (4,'Foo text for number 4')|, + q|INSERT INTO foos VALUES (1,'Foos text for number 1')|, + q|INSERT INTO foos VALUES (2,'Foos record associated with the Bar with barid 3')|, + q|INSERT INTO foos VALUES (3,'Foos text for number 3')|, + q|INSERT INTO foos VALUES (4,'Foos text for number 4')|, q|INSERT INTO bar VALUES (1,4)|, q|INSERT INTO bar VALUES (2,3)|, q|INSERT INTO bar VALUES (3,2)|, q|INSERT INTO bar VALUES (4,1)|, - q|INSERT INTO bazes VALUES (1,20)|, - q|INSERT INTO bazes VALUES (2,19)|, - q|INSERT INTO quuxes VALUES (1,20)|, - q|INSERT INTO quuxes VALUES (2,19)|, + q|INSERT INTO bazs VALUES (1,20)|, + q|INSERT INTO bazs VALUES (2,19)|, + q|INSERT INTO quuxs VALUES (1,20)|, + q|INSERT INTO quuxs VALUES (2,19)|, ); END { unlink($fn); }