--- /dev/null
+use strict;
+use warnings;
+use Test::More;
+use Test::Exception;
+use File::Path qw/rmtree make_path/;
+use Class::Unload;
+use File::Temp qw/tempfile tempdir/;
+use IO::File;
+use File::Slurp 'slurp';
+use DBIx::Class::Schema::Loader ();
+use Lingua::EN::Inflect::Number ();
+use lib qw(t/lib);
+use make_dbictest_db_with_unique;
+
+my $DUMP_DIR = './t/_common_dump';
+rmtree $DUMP_DIR;
+my $SCHEMA_CLASS = 'DBIXCSL_Test::Schema';
+
+sub class_content_like;
+
+# test dynamic schema in 0.04006 mode
+{
+ my $res = run_loader();
+ my $warning = $res->{warnings}[0];
+
+ like $warning, qr/dynamic schema/i,
+ 'dynamic schema in backcompat mode detected';
+ 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);
+}
+
+# setting naming accessor on dynamic schema should disable warning (even when
+# we're setting it to 'v4' .)
+{
+ my $res = run_loader(naming => 'v4');
+ is_deeply $res->{warnings}, [], 'no warnings with naming attribute set';
+ run_v4_tests($res);
+}
+
+# test upgraded dynamic schema
+{
+ my $res = run_loader(naming => 'current');
+ is_deeply $res->{warnings}, [], 'no warnings with naming attribute set';
+ run_v6_tests($res);
+}
+
+# test upgraded dynamic schema with external content loaded
+{
+ my $temp_dir = setup_load_external({
+ Quuxs => 'Bazs',
+ Bar => 'Foos',
+ });
+
+ my $res = run_loader(naming => 'current');
+ my $schema = $res->{schema};
+
+ is scalar @{ $res->{warnings} }, 1,
+'correct nummber of warnings for upgraded dynamic schema with external ' .
+'content for unsingularized Result.';
+
+ my $warning = $res->{warnings}[0];
+ like $warning, qr/Detected external content/i,
+ 'detected external content warning';
+
+ lives_and { is $schema->resultset('Quux')->find(1)->a_method, 'hlagh' }
+'external custom content for unsingularized Result was loaded by upgraded ' .
+'dynamic Schema';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel,
+ $res->{classes}{bazs} }
+ 'unsingularized class names in external content are translated';
+
+ lives_and { is $schema->resultset('Bar')->find(1)->a_method, 'hlagh' }
+'external content from unchanged Result class';
+
+ lives_and { isa_ok $schema->resultset('Bar')->find(1)->foorel,
+ $res->{classes}{foos} }
+'unsingularized class names in external content from unchanged Result class ' .
+'names are translated';
+
+ run_v6_tests($res);
+}
+
+# test upgraded dynamic schema with use_namespaces with external content loaded
+{
+ my $temp_dir = setup_load_external({
+ Quuxs => 'Bazs',
+ Bar => 'Foos',
+ });
+
+ my $res = run_loader(naming => 'current', use_namespaces => 1);
+ my $schema = $res->{schema};
+
+ is scalar @{ $res->{warnings} }, 2,
+'correct nummber of warnings for upgraded dynamic schema with external ' .
+'content for unsingularized Result with use_namespaces.';
+
+ my $warning = $res->{warnings}[0];
+ like $warning, qr/Detected external content/i,
+ 'detected external content warning';
+
+ lives_and { is $schema->resultset('Quux')->find(1)->a_method, 'hlagh' }
+'external custom content for unsingularized Result was loaded by upgraded ' .
+'dynamic Schema';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel,
+ $res->{classes}{bazs} }
+ 'unsingularized class names in external content are translated';
+
+ lives_and { isa_ok $schema->resultset('Bar')->find(1)->foorel,
+ $res->{classes}{foos} }
+'unsingularized class names in external content from unchanged Result class ' .
+'names are translated';
+
+ run_v6_tests($res);
+}
+
+# test upgraded static schema with external content loaded
+{
+ clean_dumpdir();
+
+ my $temp_dir = setup_load_external({
+ Quuxs => 'Bazs',
+ Bar => 'Foos',
+ });
+
+ write_v4_schema_pm();
+
+ my $res = run_loader(static => 1, naming => 'current');
+ my $schema = $res->{schema};
+
+ run_v6_tests($res);
+
+ lives_and { is $schema->resultset('Quux')->find(1)->a_method, 'hlagh' }
+'external custom content for unsingularized Result was loaded by upgraded ' .
+'static Schema';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel,
+ $res->{classes}{bazs} }
+ 'unsingularized class names in external content are translated';
+
+ lives_and { isa_ok $schema->resultset('Bar')->find(1)->foorel,
+ $res->{classes}{foos} }
+'unsingularized class names in external content from unchanged Result class ' .
+'names are translated in static schema';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/package ${SCHEMA_CLASS}::Quux;/,
+'package line translated correctly from external custom content in static dump';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/sub a_method { 'hlagh' }/,
+'external custom content loaded into static dump correctly';
+}
+
+# test creating static schema in v5 mode then upgrade to current with external
+# content loaded
+# XXX needs real load_external tests
+{
+ clean_dumpdir();
+
+ my $temp_dir = setup_load_external({
+ Quux => 'Baz',
+ Bar => 'Foo',
+ }, { result_namespace => 'Result' });
+
+ write_v5_schema_pm();
+
+ my $res = run_loader(static => 1);
+
+ run_v5_tests($res);
+
+ $res = run_loader(static => 1, naming => 'current');
+ my $schema = $res->{schema};
+
+ run_v6_tests($res);
+}
+
+# test running against v4 schema without upgrade, twice, then upgrade
+{
+ clean_dumpdir();
+ write_v4_schema_pm();
+ my $res = run_loader(static => 1);
+ my $warning = $res->{warnings}[1];
+
+ 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';
+
+ is scalar @{ $res->{warnings} }, 4,
+ 'correct number of warnings for static schema in backcompat mode';
+
+ run_v4_tests($res);
+
+ add_custom_content($res->{schema}, {
+ Quuxs => 'Bazs'
+ });
+
+ # Rerun the loader in backcompat mode to make sure it's still in backcompat
+ # mode.
+ $res = run_loader(static => 1);
+ run_v4_tests($res);
+
+ # now upgrade the schema
+ $res = run_loader(
+ static => 1,
+ naming => 'current',
+ use_namespaces => 1
+ );
+ my $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)'
+ or diag @{ $res->{warnings} };
+
+ run_v6_tests($res);
+
+ is result_count('Result'), 6,
+ 'un-singularized results were replaced during upgrade';
+
+ # check that custom content was preserved
+ lives_and { is $schema->resultset('Quux')->find(1)->b_method, 'dongs' }
+ 'custom content was carried over from un-singularized Result';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel,
+ $res->{classes}{bazs} }
+ 'unsingularized class names in custom content are translated';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/sub b_method { 'dongs' }/,
+'custom content from unsingularized Result loaded into static dump correctly';
+}
+
+# test running against v4 schema without upgrade, then upgrade with
+# use_namespaces not explicitly set
+{
+ clean_dumpdir();
+ write_v4_schema_pm();
+ my $res = run_loader(static => 1);
+ my $warning = $res->{warnings}[1];
+
+ 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';
+
+ is scalar @{ $res->{warnings} }, 4,
+ 'correct number of warnings for static schema in backcompat mode';
+
+ run_v4_tests($res);
+
+ add_custom_content($res->{schema}, {
+ Quuxs => 'Bazs'
+ });
+
+ # now upgrade the schema
+ $res = run_loader(
+ static => 1,
+ naming => 'current'
+ );
+ my $schema = $res->{schema};
+
+ like $res->{warnings}[0], qr/load_classes/i,
+'correct warnings on upgrading static schema (with "naming" set and ' .
+'use_namespaces not set)';
+
+ like $res->{warnings}[1], qr/Dumping manual schema/i,
+'correct warnings on upgrading static schema (with "naming" set and ' .
+'use_namespaces not set)';
+
+ like $res->{warnings}[2], qr/dump completed/i,
+'correct warnings on upgrading static schema (with "naming" set and ' .
+'use_namespaces not set)';
+
+ is scalar @{ $res->{warnings} }, 3,
+'correct number of warnings on upgrading static schema (with "naming" set)'
+ or diag @{ $res->{warnings} };
+
+ run_v6_tests($res);
+
+ is result_count(), 6,
+ 'un-singularized results were replaced during upgrade';
+
+ # check that custom content was preserved
+ lives_and { is $schema->resultset('Quux')->find(1)->b_method, 'dongs' }
+ 'custom content was carried over from un-singularized Result';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel,
+ $res->{classes}{bazs} }
+ 'unsingularized class names in custom content are translated';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/sub b_method { 'dongs' }/,
+'custom content from unsingularized Result loaded into static dump correctly';
+}
+
+# test running against v4 schema with load_namespaces, upgrade to current but
+# downgrade to load_classes, with external content
+{
+ clean_dumpdir();
+
+ my $temp_dir = setup_load_external({
+ Quuxs => 'Bazs',
+ Bar => 'Foos',
+ }, { result_namespace => 'Result' });
+
+ write_v4_schema_pm(use_namespaces => 1);
+
+ my $res = run_loader(static => 1);
+ 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';
+
+ is scalar @{ $res->{warnings} }, 3,
+ 'correct number of warnings for static schema in backcompat mode';
+
+ run_v4_tests($res);
+
+ is $res->{classes}{quuxs}, 'DBIXCSL_Test::Schema::Result::Quuxs',
+ 'use_namespaces in backcompat mode';
+
+ add_custom_content($res->{schema}, {
+ Quuxs => 'Bazs',
+ }, {
+ result_namespace => 'Result',
+ rel_name_map => { QuuxBaz => 'bazrel2' },
+ });
+
+ # now upgrade the schema to current but downgrade to load_classes
+ $res = run_loader(
+ static => 1,
+ naming => 'current',
+ use_namespaces => 0,
+ );
+ my $schema = $res->{schema};
+
+ like $res->{warnings}[0], qr/Dumping manual schema/i,
+'correct warnings on upgrading static schema (with "naming" set and ' .
+'use_namespaces => 0)';
+
+ like $res->{warnings}[1], qr/dump completed/i,
+'correct warnings on upgrading static schema (with "naming" set and ' .
+'use_namespaces => 0)';
+
+ is scalar @{ $res->{warnings} }, 2,
+'correct number of warnings on upgrading static schema (with "naming" set)'
+ or diag @{ $res->{warnings} };
+
+ run_v6_tests($res);
+
+ is result_count(), 6,
+'un-singularized results were replaced during upgrade and Result dir removed';
+
+ ok ((not -d result_dir('Result')),
+ 'Result dir was removed for load_classes downgrade');
+
+ is $res->{classes}{quuxs}, 'DBIXCSL_Test::Schema::Quux',
+ 'load_classes in upgraded mode';
+
+ # check that custom and external content was preserved
+ lives_and { is $schema->resultset('Quux')->find(1)->b_method, 'dongs' }
+ 'custom content was carried over from un-singularized Result';
+
+ lives_and { is $schema->resultset('Quux')->find(1)->a_method, 'hlagh' }
+ 'external content was carried over from un-singularized Result';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel2,
+ $res->{classes}{bazs} }
+ 'unsingularized class names in custom content are translated';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel,
+ $res->{classes}{bazs} }
+ 'unsingularized class names in external content are translated';
+
+ lives_and { isa_ok $schema->resultset('Bar')->find(1)->foorel,
+ $res->{classes}{foos} }
+'unsingularized class names in external content from unchanged Result class ' .
+'names are translated in static schema';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/sub a_method { 'hlagh' }/,
+'external content from unsingularized Result loaded into static dump correctly';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/sub b_method { 'dongs' }/,
+'custom content from unsingularized Result loaded into static dump correctly';
+}
+
+# test a regular schema with use_namespaces => 0 upgraded to
+# use_namespaces => 1
+{
+ my $res = run_loader(
+ clean_dumpdir => 1,
+ static => 1,
+ use_namespaces => 0,
+ );
+
+ like $res->{warnings}[0], qr/Dumping manual schema/i,
+'correct warnings on dumping static schema with use_namespaces => 0';
+
+ like $res->{warnings}[1], qr/dump completed/i,
+'correct warnings on dumping static schema with use_namespaces => 0';
+
+ is scalar @{ $res->{warnings} }, 2,
+'correct number of warnings on dumping static schema with use_namespaces => 0'
+ or diag @{ $res->{warnings} };
+
+ run_v6_tests($res);
+
+ my $schema = $res->{schema};
+ add_custom_content($res->{schema}, {
+ Quux => 'Baz'
+ });
+
+ # test that with no use_namespaces option, there is a warning and
+ # load_classes is preserved
+ $res = run_loader(static => 1);
+
+ like $res->{warnings}[0], qr/load_classes/i,
+'correct warnings on re-dumping static schema with load_classes';
+
+ like $res->{warnings}[1], qr/Dumping manual schema/i,
+'correct warnings on re-dumping static schema with load_classes';
+
+ like $res->{warnings}[2], qr/dump completed/i,
+'correct warnings on re-dumping static schema with load_classes';
+
+ is scalar @{ $res->{warnings} }, 3,
+'correct number of warnings on re-dumping static schema with load_classes'
+ or diag @{ $res->{warnings} };
+
+ is $res->{classes}{quuxs}, 'DBIXCSL_Test::Schema::Quux',
+ 'load_classes preserved on re-dump';
+
+ run_v6_tests($res);
+
+ # now upgrade the schema to use_namespaces
+ $res = run_loader(
+ static => 1,
+ use_namespaces => 1,
+ );
+ $schema = $res->{schema};
+
+ like $res->{warnings}[0], qr/Dumping manual schema/i,
+'correct warnings on upgrading to use_namespaces';
+
+ like $res->{warnings}[1], qr/dump completed/i,
+'correct warnings on upgrading to use_namespaces';
+
+ is scalar @{ $res->{warnings} }, 2,
+'correct number of warnings on upgrading to use_namespaces'
+ or diag @{ $res->{warnings} };
+
+ run_v6_tests($res);
+
+ my @schema_files = schema_files();
+
+ is 1, (scalar @schema_files),
+ "schema dir contains only 1 entry";
+
+ like $schema_files[0], qr{/Result\z},
+ "schema dir contains only a Result/ directory";
+
+ # check that custom content was preserved
+ lives_and { is $schema->resultset('Quux')->find(1)->b_method, 'dongs' }
+ 'custom content was carried over during use_namespaces upgrade';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel,
+ $res->{classes}{bazs} }
+ 'un-namespaced class names in custom content are translated';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/sub b_method { 'dongs' }/,
+'custom content from un-namespaced Result loaded into static dump correctly';
+}
+
+# test a regular schema with default use_namespaces => 1, redump, and downgrade
+# to load_classes
+{
+ my $res = run_loader(clean_dumpdir => 1, static => 1);
+
+ like $res->{warnings}[0], qr/Dumping manual schema/i,
+'correct warnings on dumping static schema';
+
+ like $res->{warnings}[1], qr/dump completed/i,
+'correct warnings on dumping static schema';
+
+ is scalar @{ $res->{warnings} }, 2,
+'correct number of warnings on dumping static schema'
+ or diag @{ $res->{warnings} };
+
+ run_v6_tests($res);
+
+ is $res->{classes}{quuxs}, 'DBIXCSL_Test::Schema::Result::Quux',
+ 'defaults to use_namespaces on regular dump';
+
+ add_custom_content($res->{schema}, { Quux => 'Baz' }, { result_namespace => 'Result' });
+
+ # test that with no use_namespaces option, use_namespaces is preserved
+ $res = run_loader(static => 1);
+
+ like $res->{warnings}[0], qr/Dumping manual schema/i,
+'correct warnings on re-dumping static schema';
+
+ like $res->{warnings}[1], qr/dump completed/i,
+'correct warnings on re-dumping static schema';
+
+ is scalar @{ $res->{warnings} }, 2,
+'correct number of warnings on re-dumping static schema'
+ or diag @{ $res->{warnings} };
+
+ is $res->{classes}{quuxs}, 'DBIXCSL_Test::Schema::Result::Quux',
+ 'use_namespaces preserved on re-dump';
+
+ run_v6_tests($res);
+
+ # now downgrade the schema to load_classes
+ $res = run_loader(
+ static => 1,
+ use_namespaces => 0,
+ );
+ my $schema = $res->{schema};
+
+ like $res->{warnings}[0], qr/Dumping manual schema/i,
+'correct warnings on downgrading to load_classes';
+
+ like $res->{warnings}[1], qr/dump completed/i,
+'correct warnings on downgrading to load_classes';
+
+ is scalar @{ $res->{warnings} }, 2,
+'correct number of warnings on downgrading to load_classes'
+ or diag @{ $res->{warnings} };
+
+ run_v6_tests($res);
+
+ is $res->{classes}{quuxs}, 'DBIXCSL_Test::Schema::Quux',
+ 'load_classes downgrade correct';
+
+ is result_count(), 6,
+'correct number of Results after upgrade and Result dir removed';
+
+ ok ((not -d result_dir('Result')),
+ 'Result dir was removed for load_classes downgrade');
+
+ # check that custom content was preserved
+ lives_and { is $schema->resultset('Quux')->find(1)->b_method, 'dongs' }
+ 'custom content was carried over during load_classes downgrade';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel,
+ $res->{classes}{bazs} }
+'namespaced class names in custom content are translated during load_classes '.
+'downgrade';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/sub b_method { 'dongs' }/,
+'custom content from namespaced Result loaded into static dump correctly '.
+'during load_classes downgrade';
+}
+
+# test a regular schema with use_namespaces => 1 and a custom result_namespace
+# downgraded to load_classes
+{
+ my $res = run_loader(
+ clean_dumpdir => 1,
+ static => 1,
+ result_namespace => 'MyResult',
+ );
+
+ like $res->{warnings}[0], qr/Dumping manual schema/i,
+'correct warnings on dumping static schema';
+
+ like $res->{warnings}[1], qr/dump completed/i,
+'correct warnings on dumping static schema';
+
+ is scalar @{ $res->{warnings} }, 2,
+'correct number of warnings on dumping static schema'
+ or diag @{ $res->{warnings} };
+
+ run_v6_tests($res);
+
+ is $res->{classes}{quuxs}, 'DBIXCSL_Test::Schema::MyResult::Quux',
+ 'defaults to use_namespaces and uses custom result_namespace';
+
+ add_custom_content($res->{schema}, { Quux => 'Baz' }, { result_namespace => 'MyResult' });
+
+ # test that with no use_namespaces option, use_namespaces is preserved, and
+ # the custom result_namespace is preserved
+ $res = run_loader(static => 1);
+
+ like $res->{warnings}[0], qr/Dumping manual schema/i,
+'correct warnings on re-dumping static schema';
+
+ like $res->{warnings}[1], qr/dump completed/i,
+'correct warnings on re-dumping static schema';
+
+ is scalar @{ $res->{warnings} }, 2,
+'correct number of warnings on re-dumping static schema'
+ or diag @{ $res->{warnings} };
+
+ is $res->{classes}{quuxs}, 'DBIXCSL_Test::Schema::MyResult::Quux',
+ 'use_namespaces and custom result_namespace preserved on re-dump';
+
+ run_v6_tests($res);
+
+ # now downgrade the schema to load_classes
+ $res = run_loader(
+ static => 1,
+ use_namespaces => 0,
+ );
+ my $schema = $res->{schema};
+
+ like $res->{warnings}[0], qr/Dumping manual schema/i,
+'correct warnings on downgrading to load_classes';
+
+ like $res->{warnings}[1], qr/dump completed/i,
+'correct warnings on downgrading to load_classes';
+
+ is scalar @{ $res->{warnings} }, 2,
+'correct number of warnings on downgrading to load_classes'
+ or diag @{ $res->{warnings} };
+
+ run_v6_tests($res);
+
+ is $res->{classes}{quuxs}, 'DBIXCSL_Test::Schema::Quux',
+ 'load_classes downgrade correct';
+
+ is result_count(), 6,
+'correct number of Results after upgrade and Result dir removed';
+
+ ok ((not -d result_dir('MyResult')),
+ 'Result dir was removed for load_classes downgrade');
+
+ # check that custom content was preserved
+ lives_and { is $schema->resultset('Quux')->find(1)->b_method, 'dongs' }
+ 'custom content was carried over during load_classes downgrade';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel,
+ $res->{classes}{bazs} }
+'namespaced class names in custom content are translated during load_classes '.
+'downgrade';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/sub b_method { 'dongs' }/,
+'custom content from namespaced Result loaded into static dump correctly '.
+'during load_classes downgrade';
+}
+
+# rewrite from one result_namespace to another, with external content
+{
+ clean_dumpdir();
+ my $temp_dir = setup_load_external({ Quux => 'Baz', Bar => 'Foo' }, { result_namespace => 'Result' });
+
+ my $res = run_loader(static => 1);
+
+ # add some custom content to a Result that will be replaced
+ add_custom_content($res->{schema}, { Quux => 'Baz' }, { result_namespace => 'Result', rel_name_map => { QuuxBaz => 'bazrel2' } });
+
+ # Rewrite implicit 'Result' to 'MyResult'
+ $res = run_loader(
+ static => 1,
+ result_namespace => 'MyResult',
+ );
+ my $schema = $res->{schema};
+
+ is $res->{classes}{quuxs}, 'DBIXCSL_Test::Schema::MyResult::Quux',
+ 'using new result_namespace';
+
+ is result_count('MyResult'), 6,
+'correct number of Results after rewritten result_namespace';
+
+ ok ((not -d schema_dir('Result')),
+ 'original Result dir was removed when rewriting result_namespace');
+
+ # check that custom content was preserved
+ lives_and { is $schema->resultset('Quux')->find(1)->b_method, 'dongs' }
+ 'custom content was carried over when rewriting result_namespace';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel2,
+ $res->{classes}{bazs} }
+'class names in custom content are translated when rewriting result_namespace';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/sub b_method { 'dongs' }/,
+'custom content from namespaced Result loaded into static dump correctly '.
+'when rewriting result_namespace';
+
+ # Now rewrite 'MyResult' to 'Mtfnpy'
+ $res = run_loader(
+ static => 1,
+ result_namespace => 'Mtfnpy',
+ );
+ $schema = $res->{schema};
+
+ is $res->{classes}{quuxs}, 'DBIXCSL_Test::Schema::Mtfnpy::Quux',
+ 'using new result_namespace';
+
+ is result_count('Mtfnpy'), 6,
+'correct number of Results after rewritten result_namespace';
+
+ ok ((not -d result_dir('MyResult')),
+ 'original Result dir was removed when rewriting result_namespace');
+
+ # check that custom and external content was preserved
+ lives_and { is $schema->resultset('Quux')->find(1)->a_method, 'hlagh' }
+ 'external content was carried over when rewriting result_namespace';
+
+ lives_and { is $schema->resultset('Quux')->find(1)->b_method, 'dongs' }
+ 'custom content was carried over when rewriting result_namespace';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel2,
+ $res->{classes}{bazs} }
+'class names in custom content are translated when rewriting result_namespace';
+
+ lives_and { isa_ok $schema->resultset('Quux')->find(1)->bazrel,
+ $res->{classes}{bazs} }
+'class names in external content are translated when rewriting '.
+'result_namespace';
+
+ lives_and { isa_ok $schema->resultset('Bar')->find(1)->foorel,
+ $res->{classes}{foos} }
+'class names in external content are translated when rewriting '.
+'result_namespace';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/sub b_method { 'dongs' }/,
+'custom content from namespaced Result loaded into static dump correctly '.
+'when rewriting result_namespace';
+
+ class_content_like $schema, $res->{classes}{quuxs}, qr/sub a_method { 'hlagh' }/,
+'external content from unsingularized Result loaded into static dump correctly';
+}
+
+# test upgrading a v4 schema, then check that the version string is correct
+{
+ clean_dumpdir();
+ write_v4_schema_pm();
+ run_loader(static => 1);
+ my $res = run_loader(static => 1, naming => 'current');
+ my $schema = $res->{schema};
+
+ my $file = $schema->_loader->_get_dump_filename($SCHEMA_CLASS);
+ my $code = slurp $file;
+
+ my ($dumped_ver) =
+ $code =~ /^# Created by DBIx::Class::Schema::Loader v(\S+)/m;
+
+ is $dumped_ver, $DBIx::Class::Schema::Loader::VERSION,
+ 'correct version dumped after upgrade of v4 static schema';
+}
+
+# Test upgrading an already singular result with custom content that refers to
+# old class names.
+{
+ clean_dumpdir();
+ write_v4_schema_pm();
+ my $res = run_loader(static => 1);
+ my $schema = $res->{schema};
+ run_v4_tests($res);
+
+ # add some custom content to a Result that will be replaced
+ add_custom_content($schema, { Bar => 'Foos' });
+
+ # now upgrade the schema
+ $res = run_loader(static => 1, naming => 'current');
+ $schema = $res->{schema};
+ run_v6_tests($res);
+
+ # check that custom content was preserved
+ lives_and { is $schema->resultset('Bar')->find(1)->b_method, 'dongs' }
+ 'custom content was preserved from Result pre-upgrade';
+
+ lives_and { isa_ok $schema->resultset('Bar')->find(1)->foorel,
+ $res->{classes}{foos} }
+'unsingularized class names in custom content from Result with unchanged ' .
+'name are translated';
+
+ class_content_like $schema, $res->{classes}{bar}, qr/sub b_method { 'dongs' }/,
+'custom content from Result with unchanged name loaded into static dump ' .
+'correctly';
+}
+
+done_testing;
+
+END {
+ rmtree $DUMP_DIR unless $ENV{SCHEMA_LOADER_TESTS_NOCLEANUP};
+}
+
+sub clean_dumpdir {
+ rmtree $DUMP_DIR;
+ make_path $DUMP_DIR;
+}
+
+sub run_loader {
+ my %loader_opts = @_;
+
+ $loader_opts{dump_directory} = $DUMP_DIR if delete $loader_opts{static};
+
+ clean_dumpdir() if delete $loader_opts{clean_dumpdir};
+
+ eval {
+ foreach my $source_name ($SCHEMA_CLASS->clone->sources) {
+ Class::Unload->unload("${SCHEMA_CLASS}::${source_name}");
+ }
+
+ Class::Unload->unload($SCHEMA_CLASS);
+ };
+ undef $@;
+
+ my @connect_info = $make_dbictest_db_with_unique::dsn;
+ my @loader_warnings;
+ local $SIG{__WARN__} = sub { push(@loader_warnings, $_[0]); };
+ eval qq{
+ package $SCHEMA_CLASS;
+ use base qw/DBIx::Class::Schema::Loader/;
+
+ __PACKAGE__->loader_options(\%loader_opts);
+ __PACKAGE__->connection(\@connect_info);
+ };
+
+ ok(!$@, "Loader initialization") or diag $@;
+
+ 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->source($source_name)->result_class;
+ }
+
+ return {
+ schema => $schema,
+ warnings => \@loader_warnings,
+ monikers => \%monikers,
+ classes => \%classes,
+ };
+}
+
+sub write_v4_schema_pm {
+ my %opts = @_;
+
+ (my $schema_dir = "$DUMP_DIR/$SCHEMA_CLASS") =~ s/::[^:]+\z//;
+ rmtree $schema_dir;
+ make_path $schema_dir;
+ my $schema_pm = "$schema_dir/Schema.pm";
+ open my $fh, '>', $schema_pm or die $!;
+ if (not $opts{use_namespaces}) {
+ print $fh <<'EOF';
+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;
+EOF
+ }
+ else {
+ print $fh <<'EOF';
+package DBIXCSL_Test::Schema;
+
+use strict;
+use warnings;
+
+use base 'DBIx::Class::Schema';
+
+__PACKAGE__->load_namespaces;
+
+
+# Created by DBIx::Class::Schema::Loader v0.04006 @ 2010-01-12 16:04:12
+# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:d3wRVsHBNisyhxeaWJZcZQ
+
+
+# You can replace this text with custom content, and it will be preserved on
+# regeneration
+1;
+EOF
+ }
+}
+
+sub write_v5_schema_pm {
+ my %opts = @_;
+
+ (my $schema_dir = "$DUMP_DIR/$SCHEMA_CLASS") =~ s/::[^:]+\z//;
+ rmtree $schema_dir;
+ make_path $schema_dir;
+ my $schema_pm = "$schema_dir/Schema.pm";
+ open my $fh, '>', $schema_pm or die $!;
+ if (exists $opts{use_namespaces} && $opts{use_namespaces} == 0) {
+ print $fh <<'EOF';
+package DBIXCSL_Test::Schema;
+
+# Created by DBIx::Class::Schema::Loader
+# DO NOT MODIFY THE FIRST PART OF THIS FILE
+
+use strict;
+use warnings;
+
+use base 'DBIx::Class::Schema';
+
+__PACKAGE__->load_classes;
+
+
+# Created by DBIx::Class::Schema::Loader v0.05003 @ 2010-03-27 17:07:37
+# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:LIzC/LT5IYvWpgusfbqMrg
+
+
+# You can replace this text with custom content, and it will be preserved on regeneration
+1;
+EOF
+ }
+ else {
+ print $fh <<'EOF';
+package DBIXCSL_Test::Schema;
+
+# Created by DBIx::Class::Schema::Loader
+# DO NOT MODIFY THE FIRST PART OF THIS FILE
+
+use strict;
+use warnings;
+
+use base 'DBIx::Class::Schema';
+
+__PACKAGE__->load_classes;
+
+
+# Created by DBIx::Class::Schema::Loader v0.05003 @ 2010-03-27 17:07:37
+# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:LIzC/LT5IYvWpgusfbqMrg
+
+
+# You can replace this text with custom content, and it will be preserved on regeneration
+1;
+EOF
+ }
+}
+
+sub run_v4_tests {
+ my $res = shift;
+ my $schema = $res->{schema};
+
+ is_deeply [ @{ $res->{monikers} }{qw/foos bar bazs quuxs stations_visited email/} ],
+ [qw/Foos Bar Bazs Quuxs StationsVisited Email/],
+ 'correct monikers in 0.04006 mode';
+
+ isa_ok ((my $bar = eval { $schema->resultset('Bar')->find(1) }),
+ $res->{classes}{bar},
+ 'found a bar');
+
+ 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';
+
+ ok my $foo = eval { $schema->resultset('Foos')->find(1) };
+
+ isa_ok eval { $foo->email_to_ids }, 'DBIx::Class::ResultSet',
+ 'correct rel name inflection in 0.04006 mode';
+}
+
+sub run_v5_tests {
+ my $res = shift;
+ my $schema = $res->{schema};
+
+ is_deeply [ @{ $res->{monikers} }{qw/foos bar bazs quuxs stations_visited email/} ],
+ [qw/Foo Bar Baz Quux StationsVisited Email/],
+ '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 v5 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 v5 mode';
+
+ ok my $foo = eval { $schema->resultset('Foo')->find(1) };
+
+ isa_ok eval { $foo->email_to_ids }, 'DBIx::Class::ResultSet',
+ 'correct rel name inflection in v5 mode';
+}
+
+sub run_v6_tests {
+ my $res = shift;
+ my $schema = $res->{schema};
+
+ is_deeply [ @{ $res->{monikers} }{qw/foos bar bazs quuxs stations_visited email/} ],
+ [qw/Foo Bar Baz Quux StationVisited Email/],
+ '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';
+
+ ok my $foo = eval { $schema->resultset('Foo')->find(1) };
+
+ isa_ok eval { $foo->emails_to }, 'DBIx::Class::ResultSet',
+ 'correct rel name inflection in current mode';
+}
+
+{
+ package DBICSL::Test::TempExtDir;
+
+ use overload '""' => sub { ${$_[0]} };
+
+ sub DESTROY {
+ pop @INC;
+ File::Path::rmtree ${$_[0]};
+ }
+}
+
+sub setup_load_external {
+ my ($rels, $opts) = @_;
+
+ my $temp_dir = tempdir(CLEANUP => 1);
+ push @INC, $temp_dir;
+
+ my $external_result_dir = join '/', $temp_dir, (split /::/, $SCHEMA_CLASS),
+ ($opts->{result_namespace} || ());
+
+ make_path $external_result_dir;
+
+ while (my ($from, $to) = each %$rels) {
+ write_ext_result($external_result_dir, $from, $to, $opts);
+ }
+
+ my $guard = bless \$temp_dir, 'DBICSL::Test::TempExtDir';
+
+ return $guard;
+}
+
+sub write_ext_result {
+ my ($result_dir, $from, $to, $opts) = @_;
+
+ my $relname = $opts->{rel_name_map}{_rel_key($from, $to)} || _relname($to);
+ my $from_class = _qualify_class($from, $opts->{result_namespace});
+ my $to_class = _qualify_class($to, $opts->{result_namespace});
+ my $condition = _rel_condition($from, $to);
+
+ IO::File->new(">$result_dir/${from}.pm")->print(<<"EOF");
+package ${from_class};
+sub a_method { 'hlagh' }
+
+__PACKAGE__->has_one('$relname', '$to_class',
+{ $condition });
+
+1;
+EOF
+
+ return $relname;
+}
+
+sub _relname {
+ my $to = shift;
+
+ return Lingua::EN::Inflect::Number::to_S(lc $to) . 'rel';
+}
+
+sub _qualify_class {
+ my ($class, $result_namespace) = @_;
+
+ return $SCHEMA_CLASS . '::'
+ . ($result_namespace ? $result_namespace . '::' : '')
+ . $class;
+}
+
+sub _rel_key {
+ my ($from, $to) = @_;
+
+ return join '', map ucfirst(Lingua::EN::Inflect::Number::to_S(lc($_))), $from, $to;
+}
+
+sub _rel_condition {
+ my ($from, $to) = @_;
+
+ return +{
+ QuuxBaz => q{'foreign.baz_num' => 'self.baz_id'},
+ BarFoo => q{'foreign.fooid' => 'self.foo_id'},
+ }->{_rel_key($from, $to)};
+}
+
+sub class_content_like {
+ my ($schema, $class, $re, $test_name) = @_;
+
+ my $file = $schema->_loader->_get_dump_filename($class);
+ my $code = slurp $file;
+
+ like $code, $re, $test_name;
+}
+
+sub add_custom_content {
+ my ($schema, $rels, $opts) = @_;
+
+ while (my ($from, $to) = each %$rels) {
+ my $relname = $opts->{rel_name_map}{_rel_key($from, $to)} || _relname($to);
+ my $from_class = _qualify_class($from, $opts->{result_namespace});
+ my $to_class = _qualify_class($to, $opts->{result_namespace});
+ my $condition = _rel_condition($from, $to);
+
+ my $content = <<"EOF";
+package ${from_class};
+sub b_method { 'dongs' }
+
+__PACKAGE__->has_one('$relname', '$to_class',
+{ $condition });
+
+1;
+EOF
+
+ _write_custom_content($schema, $from_class, $content);
+ }
+}
+
+sub _write_custom_content {
+ my ($schema, $class, $content) = @_;
+
+ my $pm = $schema->_loader->_get_dump_filename($class);
+ {
+ local ($^I, @ARGV) = ('.bak', $pm);
+ while (<>) {
+ if (/DO NOT MODIFY THIS OR ANYTHING ABOVE/) {
+ print;
+ print $content;
+ }
+ else {
+ print;
+ }
+ }
+ close ARGV;
+ unlink "${pm}.bak" or die $^E;
+ }
+}
+
+sub result_count {
+ my $path = shift || '';
+
+ my $dir = result_dir($path);
+
+ my $file_count =()= glob "$dir/*";
+
+ return $file_count;
+}
+
+sub result_files {
+ my $path = shift || '';
+
+ my $dir = result_dir($path);
+
+ return glob "$dir/*";
+}
+
+sub schema_files { result_files(@_) }
+
+sub result_dir {
+ my $path = shift || '';
+
+ (my $dir = "$DUMP_DIR/$SCHEMA_CLASS/$path") =~ s{::}{/}g;
+ $dir =~ s{/+\z}{};
+
+ return $dir;
+}
+
+sub schema_dir { result_dir(@_) }
+
+# vim:et sts=4 sw=4 tw=0: