X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=t%2Frelationship%2Fcustom.t;h=f79b605d95d95debdfc6e971f88685f3bd2bed3e;hb=c200d94979bde5ac74070d3e898927433b0e667c;hp=5d44d183ca4e1769e3eeed0ae9e0d63794229577;hpb=c8d7a1d11a50a699f4a59c1b3e76410d10181bde;p=dbsrgits%2FDBIx-Class-Historic.git diff --git a/t/relationship/custom.t b/t/relationship/custom.t index 5d44d18..f79b605 100644 --- a/t/relationship/custom.t +++ b/t/relationship/custom.t @@ -3,9 +3,9 @@ use warnings; use Test::More; use Test::Exception; +use Test::Warn; use lib qw(t/lib); -use DBICTest; -use DBIC::SqlMakerTest; +use DBICTest ':DiffSQL'; my $schema = DBICTest->init_schema(); @@ -43,10 +43,19 @@ is_same_sql_bind( WHERE ( ( me.artist = ? AND ( me.year < ? AND me.year > ? ) ) ) )', [ - [ 'me.artist' => 21 ], - [ 'me.year' => 1990 ], - [ 'me.year' => 1979 ], - ] + [ + {} + => 21 + ], + [ + { sqlt_datatype => 'varchar', sqlt_size => 100, dbic_colname => 'me.year' } + => 1990 + ], + [ + { sqlt_datatype => 'varchar', sqlt_size => 100, dbic_colname => 'me.year' } + => 1979 + ], + ], ); my @cds_80s = $cds_80s_rs->all; is(@cds_80s, 6, '6 80s cds found (1980 - 1985)'); @@ -64,11 +73,52 @@ is_same_sql_bind( WHERE ( artist__row.artistid = ? ) )', [ - [ 'me.year' => 2000 ], - [ 'me.year' => 1989 ], - [ 'artist__row.artistid' => 22 ], + [ + { sqlt_datatype => 'varchar', sqlt_size => 100, dbic_colname => 'me.year' } + => 2000 + ], + [ + { sqlt_datatype => 'varchar', sqlt_size => 100, dbic_colname => 'me.year' } + => 1989 + ], + [ { sqlt_datatype => 'integer', dbic_colname => 'artist__row.artistid' } + => 22 + ], ] ); + +# re-test with ::-containing moniker name +# (we don't have any currently, so fudge it with lots of local() ) +{ + local $schema->source('Artist')->{source_name} = 'Ar::Tist'; + local $artist2->{related_resultsets}; + + is_same_sql_bind( + $artist2->cds_90s->as_query, + '( + SELECT me.cdid, me.artist, me.title, me.year, me.genreid, me.single_track + FROM artist ar_tist__row + JOIN cd me + ON ( me.artist = ar_tist__row.artistid AND ( me.year < ? AND me.year > ? ) ) + WHERE ( ar_tist__row.artistid = ? ) + )', + [ + [ + { sqlt_datatype => 'varchar', sqlt_size => 100, dbic_colname => 'me.year' } + => 2000 + ], + [ + { sqlt_datatype => 'varchar', sqlt_size => 100, dbic_colname => 'me.year' } + => 1989 + ], + [ { sqlt_datatype => 'integer', dbic_colname => 'ar_tist__row.artistid' } + => 22 + ], + ] + ); +} + + my @cds_90s = $cds_90s_rs->all; is(@cds_90s, 6, '6 90s cds found (1990 - 1995) even with non-optimized search'); map { ok($_->year < 2000 && $_->year > 1989) } @cds_90s; @@ -89,9 +139,6 @@ is_deeply( '16 correct cds found' ); -TODO: { -local $TODO = 'Prefetch on custom rels can not work until the collapse rewrite is finished ' - . '(currently collapser requires a right-side (which is indeterministic) order-by)'; lives_ok { my @all_artists_with_80_cds_pref = $schema->resultset("Artist")->search @@ -104,16 +151,21 @@ is_deeply( ); } 'prefetchy-fetchy-fetch'; -} # end of TODO +# create_related a plain cd via the equoivalent coderef cond, with no extra conditions +lives_ok { + $artist->create_related('cds_cref_cond', { title => 'related creation via coderef cond', year => '2010' } ); +} 'created_related with simple condition works'; # try to create_related a 80s cd throws_ok { $artist->create_related('cds_80s', { title => 'related creation 1' }); -} qr/\Qunable to set_from_related via complex 'cds_80s' condition on column(s): 'year'/, 'Create failed - complex cond'; +} qr/\QUnable to complete value inferrence - custom relationship 'cds_80s' on source 'Artist' returns conditions instead of values for column(s): 'year'/, +'Create failed - complex cond'; # now supply an explicit arg overwriting the ambiguous cond -my $id_2020 = $artist->create_related('cds_80s', { title => 'related creation 2', year => '2020' })->id; +my $cd_2020 = $artist->create_related('cds_80s', { title => 'related creation 2', year => '2020' }); +my $id_2020 = $cd_2020->id; is( $schema->resultset('CD')->find($id_2020)->title, 'related creation 2', @@ -131,7 +183,8 @@ is( # try a specific everything via a non-simplified rel throws_ok { $artist->create_related('cds_90s', { title => 'related_creation 4', year => '2038' }); -} qr/\Qunable to set_from_related - no simplified condition available for 'cds_90s'/, 'Create failed - non-simplified rel'; +} qr/\QRelationship 'cds_90s' on source 'Artist' does not resolve to a join-free condition fragment/, +'Create failed - non-simplified rel'; # Do a self-join last-entry search my @last_tracks; @@ -142,8 +195,8 @@ for my $cd ($schema->resultset('CD')->search ({}, { order_by => 'cdid'})->all) { } my $last_tracks_rs = $schema->resultset('Track')->search ( - {'next_track.trackid' => undef}, - { join => 'next_track', order_by => 'me.cd' }, + {'next_tracks.trackid' => undef}, + { join => 'next_tracks', order_by => 'me.cd' }, ); is_deeply ( @@ -152,6 +205,18 @@ is_deeply ( 'last group-entry via self-join works', ); +is_deeply ( + [map { $_->last_track->id } grep { $_->last_track } $schema->resultset('CD')->search ({}, { order_by => 'cdid', prefetch => 'last_track'})->all], + [ map { $_->trackid } @last_tracks ], + 'last_track via insane subquery condition works', +); + +is_deeply ( + [map { $_->last_track->id } grep { $_->last_track } $schema->resultset('CD')->search ({}, { order_by => 'cdid'})->all], + [ map { $_->trackid } @last_tracks ], + 'last_track via insane subquery condition works, even without prefetch', +); + my $artwork = $schema->resultset('Artwork')->search({},{ order_by => 'cd_id' })->first; my @artists = $artwork->artists->all; is(scalar @artists, 2, 'the two artists are associated'); @@ -209,4 +274,71 @@ is_deeply ( 'Prefetched singles in proper order' ); +# test set_from_related/find_related with a belongs_to custom condition +my $preexisting_cd = $schema->resultset('CD')->find(1); + +my $cd_single_track = $schema->resultset('CD')->create({ + artist => $artist, + title => 'one one one', + year => 2001, + tracks => [{ title => 'uno uno uno' }] +}); + +my $single_track = $cd_single_track->tracks->next; + +is( + $single_track->cd_cref_cond->title, + $cd_single_track->title, + 'Got back the expected single-track cd title', +); + +is_deeply + { $schema->resultset('Track')->find({ cd_cref_cond => { cdid => $cd_single_track->id } })->get_columns }, + { $single_track->get_columns }, + 'Proper find with related via coderef cond', +; + +warnings_exist { + is_same_sql_bind( + $single_track->deliberately_broken_all_cd_tracks->as_query, + '( + SELECT me.trackid, me.cd, me.position, me.title, me.last_updated_on, me.last_updated_at + FROM track track__row + JOIN track me + ON me.cd = ? + WHERE track__row.trackid = ? + )', + [ + [{ dbic_colname => "me.cd", sqlt_datatype => "integer" } + => "track__row.cd" ], + [{ dbic_colname => "track__row.trackid", sqlt_datatype => "integer" } + => 19 ], + ], + 'Expected nonsensical JOIN cond', + ), +} qr/\Qrelationship 'deliberately_broken_all_cd_tracks' on source 'Track' specifies equality of column 'cd' and the *VALUE* 'cd' (you did not use the { -ident => ... } operator)/, + 'Warning on 99.9999% malformed custom cond' +; + +$single_track->set_from_related( cd_cref_cond => undef ); +ok $single_track->is_column_changed('cd'); +is $single_track->get_column('cd'), undef, 'UNset from related via coderef cond'; +is $single_track->cd, undef, 'UNset related object via coderef cond'; + +$single_track->discard_changes; + +$single_track->set_from_related( cd_cref_cond => $preexisting_cd ); +ok $single_track->is_column_changed('cd'); +is $single_track->get_column('cd'), 1, 'set from related via coderef cond'; +is_deeply + { $single_track->cd->get_columns }, + { $preexisting_cd->get_columns }, + 'set from related via coderef cond inflates properly', +; + +throws_ok { + local $schema->source('Track')->relationship_info('cd_cref_cond')->{cond} = sub { 1,2,3 }; + $schema->resultset('Track')->find({ cd_cref_cond => {} }); +} qr/\QA custom condition coderef can return at most 2 conditions, but relationship 'cd_cref_cond' on source 'Track' returned extra values: 3/; + done_testing;