5 use File::Path qw/rmtree make_path/;
7 use File::Temp qw/tempfile tempdir/;
9 use DBIx::Class::Schema::Loader ();
11 use make_dbictest_db2;
13 my $DUMP_DIR = './t/_common_dump';
15 my $SCHEMA_CLASS = 'DBIXCSL_Test::Schema';
17 # test dynamic schema in 0.04006 mode
19 my $res = run_loader();
20 my $warning = $res->{warnings}[0];
22 like $warning, qr/dynamic schema/i,
23 'dynamic schema in backcompat mode detected';
24 like $warning, qr/run in 0\.04006 mode/i,
25 'dynamic schema in 0.04006 mode warning';
26 like $warning, qr/DBIx::Class::Schema::Loader::Manual::UpgradingFromV4/,
27 'warning refers to upgrading doc';
32 # setting naming accessor on dynamic schema should disable warning (even when
33 # we're setting it to 'v4' .)
35 my $res = run_loader(naming => 'v4');
37 is_deeply $res->{warnings}, [], 'no warnings with naming attribute set';
42 # test upgraded dynamic schema
44 my $res = run_loader(naming => 'current');
46 # to dump a schema for debugging...
49 # $schema->_loader->{dump_directory} = '/tmp/HLAGH';
50 # $schema->_loader->_dump_to_dir(values %{ $res->{classes} });
53 is_deeply $res->{warnings}, [], 'no warnings with naming attribute set';
58 # test upgraded dynamic schema with external content loaded
60 my $temp_dir = tempdir;
63 my $external_result_dir = join '/', $temp_dir, split /::/, $SCHEMA_CLASS;
64 make_path $external_result_dir;
66 # make external content for Result that will be singularized
67 IO::File->new(">$external_result_dir/Quuxs.pm")->print(<<"EOF");
68 package ${SCHEMA_CLASS}::Quuxs;
69 sub a_method { 'hlagh' }
71 __PACKAGE__->has_one('bazrel', 'DBIXCSL_Test::Schema::Bazs',
72 { 'foreign.baz_num' => 'self.baz_id' });
77 # make external content for Result that will NOT be singularized
78 IO::File->new(">$external_result_dir/Bar.pm")->print(<<"EOF");
79 package ${SCHEMA_CLASS}::Bar;
81 __PACKAGE__->has_one('foorel', 'DBIXCSL_Test::Schema::Foos',
82 { 'foreign.fooid' => 'self.foo_id' });
87 my $res = run_loader(naming => 'current');
88 my $schema = $res->{schema};
90 is scalar @{ $res->{warnings} }, 1,
91 'correct nummber of warnings for upgraded dynamic schema with external ' .
92 'content for unsingularized Result.';
94 my $warning = $res->{warnings}[0];
95 like $warning, qr/Detected external content/i,
96 'detected external content warning';
98 lives_and { is $schema->resultset('Quux')->find(1)->a_method, 'hlagh' }
99 'external custom content for unsingularized Result was loaded by upgraded ' .
102 lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel,
103 $res->{classes}{bazs} }
104 'unsingularized class names in external content are translated';
106 lives_and { isa_ok $schema->resultset('Bar')->find(1)->foorel,
107 $res->{classes}{foos} }
108 'unsingularized class names in external content from unchanged Result class ' .
109 'names are translated';
117 # test upgraded dynamic schema with use_namespaces with external content loaded
119 my $temp_dir = tempdir;
120 push @INC, $temp_dir;
122 my $external_result_dir = join '/', $temp_dir, split /::/, $SCHEMA_CLASS;
123 make_path $external_result_dir;
125 # make external content for Result that will be singularized
126 IO::File->new(">$external_result_dir/Quuxs.pm")->print(<<"EOF");
127 package ${SCHEMA_CLASS}::Quuxs;
128 sub a_method { 'hlagh' }
130 __PACKAGE__->has_one('bazrel4', 'DBIXCSL_Test::Schema::Bazs',
131 { 'foreign.baz_num' => 'self.baz_id' });
136 # make external content for Result that will NOT be singularized
137 IO::File->new(">$external_result_dir/Bar.pm")->print(<<"EOF");
138 package ${SCHEMA_CLASS}::Bar;
140 __PACKAGE__->has_one('foorel4', 'DBIXCSL_Test::Schema::Foos',
141 { 'foreign.fooid' => 'self.foo_id' });
146 my $res = run_loader(naming => 'current', use_namespaces => 1);
147 my $schema = $res->{schema};
149 is scalar @{ $res->{warnings} }, 2,
150 'correct nummber of warnings for upgraded dynamic schema with external ' .
151 'content for unsingularized Result with use_namespaces.';
153 my $warning = $res->{warnings}[0];
154 like $warning, qr/Detected external content/i,
155 'detected external content warning';
157 lives_and { is $schema->resultset('Quux')->find(1)->a_method, 'hlagh' }
158 'external custom content for unsingularized Result was loaded by upgraded ' .
161 lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel4,
162 $res->{classes}{bazs} }
163 'unsingularized class names in external content are translated';
165 lives_and { isa_ok $schema->resultset('Bar')->find(1)->foorel4,
166 $res->{classes}{foos} }
167 'unsingularized class names in external content from unchanged Result class ' .
168 'names are translated';
177 # test upgraded static schema with external content loaded
179 my $temp_dir = tempdir;
180 push @INC, $temp_dir;
182 my $external_result_dir = join '/', $temp_dir, split /::/, $SCHEMA_CLASS;
183 make_path $external_result_dir;
185 # make external content for Result that will be singularized
186 IO::File->new(">$external_result_dir/Quuxs.pm")->print(<<"EOF");
187 package ${SCHEMA_CLASS}::Quuxs;
188 sub a_method { 'dongs' }
190 __PACKAGE__->has_one('bazrel2', 'DBIXCSL_Test::Schema::Bazs',
191 { 'foreign.baz_num' => 'self.baz_id' });
196 # make external content for Result that will NOT be singularized
197 IO::File->new(">$external_result_dir/Bar.pm")->print(<<"EOF");
198 package ${SCHEMA_CLASS}::Bar;
200 __PACKAGE__->has_one('foorel2', 'DBIXCSL_Test::Schema::Foos',
201 { 'foreign.fooid' => 'self.foo_id' });
206 write_v4_schema_pm();
208 my $res = run_loader(dump_directory => $DUMP_DIR, naming => 'current');
209 my $schema = $res->{schema};
213 lives_and { is $schema->resultset('Quux')->find(1)->a_method, 'dongs' }
214 'external custom content for unsingularized Result was loaded by upgraded ' .
217 lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel2,
218 $res->{classes}{bazs} }
219 'unsingularized class names in external content are translated';
221 lives_and { isa_ok $schema->resultset('Bar')->find(1)->foorel2,
222 $res->{classes}{foos} }
223 'unsingularized class names in external content from unchanged Result class ' .
224 'names are translated in static schema';
226 my $file = $schema->_loader->_get_dump_filename($res->{classes}{quuxs});
227 my $code = do { local ($/, @ARGV) = (undef, $file); <> };
229 like $code, qr/package ${SCHEMA_CLASS}::Quux;/,
230 'package line translated correctly from external custom content in static dump';
232 like $code, qr/sub a_method { 'dongs' }/,
233 'external custom content loaded into static dump correctly';
239 # test running against v4 schema without upgrade, twice, then upgrade
241 write_v4_schema_pm();
242 my $res = run_loader(dump_directory => $DUMP_DIR);
243 my $warning = $res->{warnings}[1];
245 like $warning, qr/static schema/i,
246 'static schema in backcompat mode detected';
247 like $warning, qr/0.04006/,
248 'correct version detected';
249 like $warning, qr/DBIx::Class::Schema::Loader::Manual::UpgradingFromV4/,
250 'refers to upgrading doc';
252 is scalar @{ $res->{warnings} }, 4,
253 'correct number of warnings for static schema in backcompat mode';
257 # add some custom content to a Result that will be replaced
258 my $schema = $res->{schema};
259 my $quuxs_pm = $schema->_loader
260 ->_get_dump_filename($res->{classes}{quuxs});
262 local ($^I, @ARGV) = ('', $quuxs_pm);
264 if (/DO NOT MODIFY THIS OR ANYTHING ABOVE/) {
267 sub a_method { 'mtfnpy' }
269 __PACKAGE__->has_one('bazrel3', 'DBIXCSL_Test::Schema::Bazs',
270 { 'foreign.baz_num' => 'self.baz_id' });
279 # Rerun the loader in backcompat mode to make sure it's still in backcompat
281 $res = run_loader(dump_directory => $DUMP_DIR);
284 # now upgrade the schema
286 dump_directory => $DUMP_DIR,
290 $schema = $res->{schema};
292 like $res->{warnings}[0], qr/Dumping manual schema/i,
293 'correct warnings on upgrading static schema (with "naming" set)';
295 like $res->{warnings}[1], qr/dump completed/i,
296 'correct warnings on upgrading static schema (with "naming" set)';
298 is scalar @{ $res->{warnings} }, 2,
299 'correct number of warnings on upgrading static schema (with "naming" set)'
300 or diag @{ $res->{warnings} };
304 (my $result_dir = "$DUMP_DIR/$SCHEMA_CLASS/Result") =~ s{::}{/}g;
305 my $result_count =()= glob "$result_dir/*";
308 'un-singularized results were replaced during upgrade';
310 # check that custom content was preserved
311 lives_and { is $schema->resultset('Quux')->find(1)->a_method, 'mtfnpy' }
312 'custom content was carried over from un-singularized Result';
314 lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel3,
315 $res->{classes}{bazs} }
316 'unsingularized class names in custom content are translated';
318 my $file = $schema->_loader->_get_dump_filename($res->{classes}{quuxs});
319 my $code = do { local ($/, @ARGV) = (undef, $file); <> };
321 like $code, qr/sub a_method { 'mtfnpy' }/,
322 'custom content from unsingularized Result loaded into static dump correctly';
325 # test running against v4 schema without upgrade, then upgrade with
326 # use_namespaces not explicitly set
328 write_v4_schema_pm();
329 my $res = run_loader(dump_directory => $DUMP_DIR);
330 my $warning = $res->{warnings}[1];
332 like $warning, qr/static schema/i,
333 'static schema in backcompat mode detected';
334 like $warning, qr/0.04006/,
335 'correct version detected';
336 like $warning, qr/DBIx::Class::Schema::Loader::Manual::UpgradingFromV4/,
337 'refers to upgrading doc';
339 is scalar @{ $res->{warnings} }, 4,
340 'correct number of warnings for static schema in backcompat mode';
344 # add some custom content to a Result that will be replaced
345 my $schema = $res->{schema};
346 my $quuxs_pm = $schema->_loader
347 ->_get_dump_filename($res->{classes}{quuxs});
349 local ($^I, @ARGV) = ('', $quuxs_pm);
351 if (/DO NOT MODIFY THIS OR ANYTHING ABOVE/) {
354 sub a_method { 'mtfnpy' }
356 __PACKAGE__->has_one('bazrel5', 'DBIXCSL_Test::Schema::Bazs',
357 { 'foreign.baz_num' => 'self.baz_id' });
366 # now upgrade the schema
368 dump_directory => $DUMP_DIR,
371 $schema = $res->{schema};
373 like $res->{warnings}[0], qr/load_classes/i,
374 'correct warnings on upgrading static schema (with "naming" set and ' .
375 'use_namespaces not set)';
377 like $res->{warnings}[1], qr/Dumping manual schema/i,
378 'correct warnings on upgrading static schema (with "naming" set and ' .
379 'use_namespaces not set)';
381 like $res->{warnings}[2], qr/dump completed/i,
382 'correct warnings on upgrading static schema (with "naming" set and ' .
383 'use_namespaces not set)';
385 is scalar @{ $res->{warnings} }, 3,
386 'correct number of warnings on upgrading static schema (with "naming" set)'
387 or diag @{ $res->{warnings} };
391 (my $result_dir = "$DUMP_DIR/$SCHEMA_CLASS") =~ s{::}{/}g;
392 my $result_count =()= glob "$result_dir/*";
395 'un-singularized results were replaced during upgrade';
397 # check that custom content was preserved
398 lives_and { is $schema->resultset('Quux')->find(1)->a_method, 'mtfnpy' }
399 'custom content was carried over from un-singularized Result';
401 lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel5,
402 $res->{classes}{bazs} }
403 'unsingularized class names in custom content are translated';
405 my $file = $schema->_loader->_get_dump_filename($res->{classes}{quuxs});
406 my $code = do { local ($/, @ARGV) = (undef, $file); <> };
408 like $code, qr/sub a_method { 'mtfnpy' }/,
409 'custom content from unsingularized Result loaded into static dump correctly';
412 # test running against v4 schema with load_namespaces, upgrade to v5 but
413 # downgrade to load_classes
415 write_v4_schema_pm(use_namespaces => 1);
416 my $res = run_loader(dump_directory => $DUMP_DIR);
417 my $warning = $res->{warnings}[0];
419 like $warning, qr/static schema/i,
420 'static schema in backcompat mode detected';
421 like $warning, qr/0.04006/,
422 'correct version detected';
423 like $warning, qr/DBIx::Class::Schema::Loader::Manual::UpgradingFromV4/,
424 'refers to upgrading doc';
426 is scalar @{ $res->{warnings} }, 3,
427 'correct number of warnings for static schema in backcompat mode';
431 # add some custom content to a Result that will be replaced
432 my $schema = $res->{schema};
433 my $quuxs_pm = $schema->_loader
434 ->_get_dump_filename($res->{classes}{quuxs});
436 local ($^I, @ARGV) = ('', $quuxs_pm);
438 if (/DO NOT MODIFY THIS OR ANYTHING ABOVE/) {
441 sub a_method { 'mtfnpy' }
443 __PACKAGE__->has_one('bazrel6', 'DBIXCSL_Test::Schema::Result::Bazs',
444 { 'foreign.baz_num' => 'self.baz_id' });
453 # now upgrade the schema to v5 but downgrade to load_classes
455 dump_directory => $DUMP_DIR,
459 $schema = $res->{schema};
461 like $res->{warnings}[0], qr/Dumping manual schema/i,
462 'correct warnings on upgrading static schema (with "naming" set and ' .
463 'use_namespaces => 0)';
465 like $res->{warnings}[1], qr/dump completed/i,
466 'correct warnings on upgrading static schema (with "naming" set and ' .
467 'use_namespaces => 0)';
469 is scalar @{ $res->{warnings} }, 2,
470 'correct number of warnings on upgrading static schema (with "naming" set)'
471 or diag @{ $res->{warnings} };
475 (my $result_dir = "$DUMP_DIR/$SCHEMA_CLASS") =~ s{::}{/}g;
476 my $result_count =()= glob "$result_dir/*";
479 'un-singularized results were replaced during upgrade and Result dir removed';
481 ok ((not -d "$result_dir/Result"),
482 'Result dir was removed for load_classes downgrade');
484 # check that custom content was preserved
485 lives_and { is $schema->resultset('Quux')->find(1)->a_method, 'mtfnpy' }
486 'custom content was carried over from un-singularized Result';
488 lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel6,
489 $res->{classes}{bazs} }
490 'unsingularized class names in custom content are translated';
492 my $file = $schema->_loader->_get_dump_filename($res->{classes}{quuxs});
493 my $code = do { local ($/, @ARGV) = (undef, $file); <> };
495 like $code, qr/sub a_method { 'mtfnpy' }/,
496 'custom content from unsingularized Result loaded into static dump correctly';
499 # test upgrading a v4 schema, the check that the version string is correct
501 write_v4_schema_pm();
502 run_loader(dump_directory => $DUMP_DIR);
503 my $res = run_loader(dump_directory => $DUMP_DIR, naming => 'current');
504 my $schema = $res->{schema};
506 my $file = $schema->_loader->_get_dump_filename($SCHEMA_CLASS);
507 my $code = do { local ($/, @ARGV) = (undef, $file); <> };
510 $code =~ /^# Created by DBIx::Class::Schema::Loader v(\S+)/m;
512 is $dumped_ver, $DBIx::Class::Schema::Loader::VERSION,
513 'correct version dumped after upgrade of v4 static schema';
516 # Test upgrading an already singular result with custom content that refers to
519 write_v4_schema_pm();
520 my $res = run_loader(dump_directory => $DUMP_DIR);
521 my $schema = $res->{schema};
524 # add some custom content to a Result that will be replaced
525 my $bar_pm = $schema->_loader
526 ->_get_dump_filename($res->{classes}{bar});
528 local ($^I, @ARGV) = ('', $bar_pm);
530 if (/DO NOT MODIFY THIS OR ANYTHING ABOVE/) {
533 sub a_method { 'lalala' }
535 __PACKAGE__->has_one('foorel3', 'DBIXCSL_Test::Schema::Foos',
536 { 'foreign.fooid' => 'self.foo_id' });
545 # now upgrade the schema
546 $res = run_loader(dump_directory => $DUMP_DIR, naming => 'current');
547 $schema = $res->{schema};
550 # check that custom content was preserved
551 lives_and { is $schema->resultset('Bar')->find(1)->a_method, 'lalala' }
552 'custom content was preserved from Result pre-upgrade';
554 lives_and { isa_ok $schema->resultset('Bar')->find(1)->foorel3,
555 $res->{classes}{foos} }
556 'unsingularized class names in custom content from Result with unchanged ' .
557 'name are translated';
559 my $file = $schema->_loader->_get_dump_filename($res->{classes}{bar});
560 my $code = do { local ($/, @ARGV) = (undef, $file); <> };
562 like $code, qr/sub a_method { 'lalala' }/,
563 'custom content from Result with unchanged name loaded into static dump ' .
570 rmtree $DUMP_DIR unless $ENV{SCHEMA_LOADER_TESTS_NOCLEANUP};
574 my %loader_opts = @_;
577 foreach my $source_name ($SCHEMA_CLASS->clone->sources) {
578 Class::Unload->unload("${SCHEMA_CLASS}::${source_name}");
581 Class::Unload->unload($SCHEMA_CLASS);
585 my @connect_info = $make_dbictest_db2::dsn;
587 local $SIG{__WARN__} = sub { push(@loader_warnings, $_[0]); };
589 package $SCHEMA_CLASS;
590 use base qw/DBIx::Class::Schema::Loader/;
592 __PACKAGE__->loader_options(\%loader_opts);
593 __PACKAGE__->connection(\@connect_info);
596 ok(!$@, "Loader initialization") or diag $@;
598 my $schema = $SCHEMA_CLASS->clone;
599 my (%monikers, %classes);
600 foreach my $source_name ($schema->sources) {
601 my $table_name = $schema->source($source_name)->from;
602 $monikers{$table_name} = $source_name;
603 $classes{$table_name} = $schema->source($source_name)->result_class;
608 warnings => \@loader_warnings,
609 monikers => \%monikers,
610 classes => \%classes,
614 sub write_v4_schema_pm {
617 (my $schema_dir = "$DUMP_DIR/$SCHEMA_CLASS") =~ s/::[^:]+\z//;
619 make_path $schema_dir;
620 my $schema_pm = "$schema_dir/Schema.pm";
621 open my $fh, '>', $schema_pm or die $!;
622 if (not $opts{use_namespaces}) {
624 package DBIXCSL_Test::Schema;
629 use base 'DBIx::Class::Schema';
631 __PACKAGE__->load_classes;
634 # Created by DBIx::Class::Schema::Loader v0.04006 @ 2009-12-25 01:49:25
635 # DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:ibIJTbfM1ji4pyD/lgSEog
638 # You can replace this text with custom content, and it will be preserved on regeneration
644 package DBIXCSL_Test::Schema;
649 use base 'DBIx::Class::Schema';
651 __PACKAGE__->load_namespaces;
654 # Created by DBIx::Class::Schema::Loader v0.04006 @ 2010-01-12 16:04:12
655 # DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:d3wRVsHBNisyhxeaWJZcZQ
658 # You can replace this text with custom content, and it will be preserved on
667 my $schema = $res->{schema};
669 is_deeply [ @{ $res->{monikers} }{qw/foos bar bazs quuxs/} ],
670 [qw/Foos Bar Bazs Quuxs/],
671 'correct monikers in 0.04006 mode';
673 isa_ok ((my $bar = eval { $schema->resultset('Bar')->find(1) }),
674 $res->{classes}{bar},
677 isa_ok eval { $bar->foo_id }, $res->{classes}{foos},
678 'correct rel name in 0.04006 mode';
680 ok my $baz = eval { $schema->resultset('Bazs')->find(1) };
682 isa_ok eval { $baz->quux }, 'DBIx::Class::ResultSet',
683 'correct rel type and name for UNIQUE FK in 0.04006 mode';
688 my $schema = $res->{schema};
690 is_deeply [ @{ $res->{monikers} }{qw/foos bar bazs quuxs/} ],
691 [qw/Foo Bar Baz Quux/],
692 'correct monikers in current mode';
694 ok my $bar = eval { $schema->resultset('Bar')->find(1) };
696 isa_ok eval { $bar->foo }, $res->{classes}{foos},
697 'correct rel name in current mode';
699 ok my $baz = eval { $schema->resultset('Baz')->find(1) };
701 isa_ok eval { $baz->quux }, $res->{classes}{quuxs},
702 'correct rel type and name for UNIQUE FK in current mode';