Bundle trial SQLA for the trial of DBIC (reuse dq technique f4a8b21e)
[dbsrgits/DBIx-Class.git] / t / 101populate_rs.t
1 ## ----------------------------------------------------------------------------
2 ## Tests for the $resultset->populate method.
3 ##
4 ## GOALS:  We need to test the method for both void and array context for all
5 ## the following relationship types: belongs_to, has_many.  Additionally we
6 ## need to test each of those for both specified PK's and autogenerated PK's
7 ##
8 ## Also need to test some stuff that should generate errors.
9 ## ----------------------------------------------------------------------------
10
11 use strict;
12 use warnings;
13
14 use Test::More;
15 use Test::Warn;
16 use lib qw(t/lib);
17 use DBICTest;
18
19
20 ## ----------------------------------------------------------------------------
21 ## Get a Schema and some ResultSets we can play with.
22 ## ----------------------------------------------------------------------------
23
24 my $schema  = DBICTest->init_schema();
25 my $art_rs  = $schema->resultset('Artist');
26 my $cd_rs  = $schema->resultset('CD');
27
28 my $restricted_art_rs  = $art_rs->search({ -and => [ rank => 42, charfield => { '=', \['(SELECT MAX(artistid) FROM artist) + ?', 6] } ] });
29
30 ok( $schema, 'Got a Schema object');
31 ok( $art_rs, 'Got Good Artist Resultset');
32 ok( $cd_rs, 'Got Good CD Resultset');
33
34
35 ## ----------------------------------------------------------------------------
36 ## Schema populate Tests
37 ## ----------------------------------------------------------------------------
38
39 SCHEMA_POPULATE1: {
40
41   # throw a monkey wrench
42   my $post_jnap_monkeywrench = $schema->resultset('Artist')->find(1)->update({ name => undef });
43
44   warnings_exist { $schema->populate('Artist', [
45
46     [qw/name cds/],
47     ["001First Artist", [
48       {title=>"001Title1", year=>2000},
49       {title=>"001Title2", year=>2001},
50       {title=>"001Title3", year=>2002},
51     ]],
52     ["002Second Artist", []],
53     ["003Third Artist", [
54       {title=>"003Title1", year=>2005},
55     ]],
56     [undef, [
57       {title=>"004Title1", year=>2010}
58     ]],
59   ]) } qr/\QFast-path populate() of non-uniquely identifiable rows with related data is not possible/;
60
61   isa_ok $schema, 'DBIx::Class::Schema';
62
63   my ( $preexisting_undef, $artist1, $artist2, $artist3, $undef ) = $schema->resultset('Artist')->search({
64     name=>["001First Artist","002Second Artist","003Third Artist", undef]},
65     {order_by => { -asc => 'artistid' }})->all;
66
67   isa_ok  $artist1, 'DBICTest::Artist';
68   isa_ok  $artist2, 'DBICTest::Artist';
69   isa_ok  $artist3, 'DBICTest::Artist';
70   isa_ok  $undef, 'DBICTest::Artist';
71
72   ok $artist1->name eq '001First Artist', "Got Expected Artist Name for Artist001";
73   ok $artist2->name eq '002Second Artist', "Got Expected Artist Name for Artist002";
74   ok $artist3->name eq '003Third Artist', "Got Expected Artist Name for Artist003";
75   ok !defined $undef->name, "Got Expected Artist Name for Artist004";
76
77   ok $artist1->cds->count eq 3, "Got Right number of CDs for Artist1";
78   ok $artist2->cds->count eq 0, "Got Right number of CDs for Artist2";
79   ok $artist3->cds->count eq 1, "Got Right number of CDs for Artist3";
80   ok $undef->cds->count eq 1, "Got Right number of CDs for Artist4";
81
82   $post_jnap_monkeywrench->delete;
83
84   ARTIST1CDS: {
85
86     my ($cd1, $cd2, $cd3) = $artist1->cds->search(undef, {order_by=>'year ASC'});
87
88     isa_ok $cd1, 'DBICTest::CD';
89     isa_ok $cd2, 'DBICTest::CD';
90     isa_ok $cd3, 'DBICTest::CD';
91
92     ok $cd1->year == 2000;
93     ok $cd2->year == 2001;
94     ok $cd3->year == 2002;
95
96     ok $cd1->title eq '001Title1';
97     ok $cd2->title eq '001Title2';
98     ok $cd3->title eq '001Title3';
99   }
100
101   ARTIST3CDS: {
102
103     my ($cd1) = $artist3->cds->search(undef, {order_by=>'year ASC'});
104
105     isa_ok $cd1, 'DBICTest::CD';
106
107     ok $cd1->year == 2005;
108     ok $cd1->title eq '003Title1';
109   }
110
111   ARTIST4CDS: {
112
113     my ($cd1) = $undef->cds->search(undef, {order_by=>'year ASC'});
114
115     isa_ok $cd1, 'DBICTest::CD';
116
117     ok $cd1->year == 2010;
118     ok $cd1->title eq '004Title1';
119   }
120
121   ## Need to do some cleanup so that later tests don't get borked
122
123   $undef->delete;
124 }
125
126
127 ## ----------------------------------------------------------------------------
128 ## Array context tests
129 ## ----------------------------------------------------------------------------
130
131 ARRAY_CONTEXT: {
132
133   ## These first set of tests are cake because array context just delegates
134   ## all its processing to $resultset->create
135
136   HAS_MANY_NO_PKS: {
137
138     ## This first group of tests checks to make sure we can call populate
139     ## with the parent having many children and let the keys be automatic
140
141     my $artists = [
142       {
143         name => 'Angsty-Whiny Girl',
144         cds => [
145           { title => 'My First CD', year => 2006 },
146           { title => 'Yet More Tweeny-Pop crap', year => 2007 },
147         ],
148       },
149       {
150         name => 'Manufactured Crap',
151       },
152       {
153         name => 'Like I Give a Damn',
154         cds => [
155           { title => 'My parents sold me to a record company' ,year => 2005 },
156           { title => 'Why Am I So Ugly?', year => 2006 },
157           { title => 'I Got Surgery and am now Popular', year => 2007 }
158         ],
159       },
160       {
161         name => 'Formerly Named',
162         cds => [
163           { title => 'One Hit Wonder', year => 2006 },
164         ],
165       },
166     ];
167
168     ## Get the result row objects.
169
170     my ($girl, $crap, $damn, $formerly) = $art_rs->populate($artists);
171
172     ## Do we have the right object?
173
174     isa_ok( $crap, 'DBICTest::Artist', "Got 'Artist'");
175     isa_ok( $girl, 'DBICTest::Artist', "Got 'Artist'");
176     isa_ok( $damn, 'DBICTest::Artist', "Got 'Artist'");
177     isa_ok( $formerly, 'DBICTest::Artist', "Got 'Artist'");
178
179     ## Find the expected information?
180
181     ok( $crap->name eq 'Manufactured Crap', "Got Correct name for result object");
182     ok( $girl->name eq 'Angsty-Whiny Girl', "Got Correct name for result object");
183     ok( $damn->name eq 'Like I Give a Damn', "Got Correct name for result object");
184     ok( $formerly->name eq 'Formerly Named', "Got Correct name for result object");
185
186     ## Create the expected children sub objects?
187
188     ok( $crap->cds->count == 0, "got Expected Number of Cds");
189     ok( $girl->cds->count == 2, "got Expected Number of Cds");
190     ok( $damn->cds->count == 3, "got Expected Number of Cds");
191     ok( $formerly->cds->count == 1, "got Expected Number of Cds");
192
193     ## Did the cds get expected information?
194
195     my ($cd1, $cd2) = $girl->cds->search({},{order_by=>'year'});
196
197     ok( $cd1->title eq "My First CD", "Got Expected CD Title");
198     ok( $cd2->title eq "Yet More Tweeny-Pop crap", "Got Expected CD Title");
199   }
200
201   HAS_MANY_WITH_PKS: {
202
203     ## This group tests the ability to specify the PK in the parent and let
204     ## DBIC transparently pass the PK down to the Child and also let's the
205     ## child create any other needed PK's for itself.
206
207     my $aid    =  $art_rs->get_column('artistid')->max || 0;
208
209     my $first_aid = ++$aid;
210
211     my $artists = [
212       {
213         artistid => $first_aid,
214         name => 'PK_Angsty-Whiny Girl',
215         cds => [
216           { artist => $first_aid, title => 'PK_My First CD', year => 2006 },
217           { artist => $first_aid, title => 'PK_Yet More Tweeny-Pop crap', year => 2007 },
218         ],
219       },
220       {
221         artistid => ++$aid,
222         name => 'PK_Manufactured Crap',
223       },
224       {
225         artistid => ++$aid,
226         name => 'PK_Like I Give a Damn',
227         cds => [
228           { title => 'PK_My parents sold me to a record company' ,year => 2005 },
229           { title => 'PK_Why Am I So Ugly?', year => 2006 },
230           { title => 'PK_I Got Surgery and am now Popular', year => 2007 }
231         ],
232       },
233       {
234         artistid => ++$aid,
235         name => 'PK_Formerly Named',
236         cds => [
237           { title => 'PK_One Hit Wonder', year => 2006 },
238         ],
239       },
240     ];
241
242     ## Get the result row objects.
243
244     my ($girl, $crap, $damn, $formerly) = $art_rs->populate($artists);
245
246     ## Do we have the right object?
247
248     isa_ok( $crap, 'DBICTest::Artist', "Got 'Artist'");
249     isa_ok( $girl, 'DBICTest::Artist', "Got 'Artist'");
250     isa_ok( $damn, 'DBICTest::Artist', "Got 'Artist'");
251     isa_ok( $formerly, 'DBICTest::Artist', "Got 'Artist'");
252
253     ## Find the expected information?
254
255     ok( $crap->name eq 'PK_Manufactured Crap', "Got Correct name for result object");
256     ok( $girl->name eq 'PK_Angsty-Whiny Girl', "Got Correct name for result object");
257     ok( $girl->artistid == $first_aid, "Got Correct artist PK for result object");
258     ok( $damn->name eq 'PK_Like I Give a Damn', "Got Correct name for result object");
259     ok( $formerly->name eq 'PK_Formerly Named', "Got Correct name for result object");
260
261     ## Create the expected children sub objects?
262
263     ok( $crap->cds->count == 0, "got Expected Number of Cds");
264     ok( $girl->cds->count == 2, "got Expected Number of Cds");
265     ok( $damn->cds->count == 3, "got Expected Number of Cds");
266     ok( $formerly->cds->count == 1, "got Expected Number of Cds");
267
268     ## Did the cds get expected information?
269
270     my ($cd1, $cd2) = $girl->cds->search({},{order_by=>'year ASC'});
271
272     ok( $cd1->title eq "PK_My First CD", "Got Expected CD Title");
273     ok( $cd2->title eq "PK_Yet More Tweeny-Pop crap", "Got Expected CD Title");
274   }
275
276   BELONGS_TO_NO_PKs: {
277
278     ## Test from a belongs_to perspective, should create artist first,
279     ## then CD with artistid.  This test we let the system automatically
280     ## create the PK's.  Chances are good you'll use it this way mostly.
281
282     my $cds = [
283       {
284         title => 'Some CD3',
285         year => '1997',
286         artist => { name => 'Fred BloggsC'},
287       },
288       {
289         title => 'Some CD4',
290         year => '1997',
291         artist => { name => 'Fred BloggsD'},
292       },
293     ];
294
295     my ($cdA, $cdB) = $cd_rs->populate($cds);
296
297
298     isa_ok($cdA, 'DBICTest::CD', 'Created CD');
299     isa_ok($cdA->artist, 'DBICTest::Artist', 'Set Artist');
300     is($cdA->artist->name, 'Fred BloggsC', 'Set Artist to FredC');
301
302
303     isa_ok($cdB, 'DBICTest::CD', 'Created CD');
304     isa_ok($cdB->artist, 'DBICTest::Artist', 'Set Artist');
305     is($cdB->artist->name, 'Fred BloggsD', 'Set Artist to FredD');
306   }
307
308   BELONGS_TO_WITH_PKs: {
309
310     ## Test from a belongs_to perspective, should create artist first,
311     ## then CD with artistid.  This time we try setting the PK's
312
313     my $aid  = $art_rs->get_column('artistid')->max || 0;
314
315     my $cds = [
316       {
317         title => 'Some CD3',
318         year => '1997',
319         artist => { artistid=> ++$aid, name => 'Fred BloggsE'},
320       },
321       {
322         title => 'Some CD4',
323         year => '1997',
324         artist => { artistid=> ++$aid, name => 'Fred BloggsF'},
325       },
326     ];
327
328     my ($cdA, $cdB) = $cd_rs->populate($cds);
329
330     isa_ok($cdA, 'DBICTest::CD', 'Created CD');
331     isa_ok($cdA->artist, 'DBICTest::Artist', 'Set Artist');
332     is($cdA->artist->name, 'Fred BloggsE', 'Set Artist to FredE');
333
334     isa_ok($cdB, 'DBICTest::CD', 'Created CD');
335     isa_ok($cdB->artist, 'DBICTest::Artist', 'Set Artist');
336     is($cdB->artist->name, 'Fred BloggsF', 'Set Artist to FredF');
337     ok($cdB->artist->artistid == $aid, "Got Expected Artist ID");
338   }
339
340   WITH_COND_FROM_RS: {
341
342     my ($more_crap) = $restricted_art_rs->populate([
343       {
344         name => 'More Manufactured Crap',
345       },
346     ]);
347
348     ## Did it use the condition in the resultset?
349     $more_crap->discard_changes;
350     cmp_ok( $more_crap->rank, '==', 42, "Got Correct rank for result object");
351     cmp_ok( $more_crap->charfield, '==', $more_crap->id + 5, "Got Correct charfield for result object");
352   }
353 }
354
355
356 ## ----------------------------------------------------------------------------
357 ## Void context tests
358 ## ----------------------------------------------------------------------------
359
360 VOID_CONTEXT: {
361
362   ## All these tests check the ability to use populate without asking for
363   ## any returned resultsets.  This uses bulk_insert as much as possible
364   ## in order to increase speed.
365
366   HAS_MANY_WITH_PKS: {
367
368     ## This first group of tests checks to make sure we can call populate
369     ## with the parent having many children and the parent PK is set
370
371     my $aid = $art_rs->get_column('artistid')->max || 0;
372
373     my $first_aid = ++$aid;
374
375     my $artists = [
376       {
377         artistid => $first_aid,
378         name => 'VOID_PK_Angsty-Whiny Girl',
379         cds => [
380           { artist => $first_aid, title => 'VOID_PK_My First CD', year => 2006 },
381           { artist => $first_aid, title => 'VOID_PK_Yet More Tweeny-Pop crap', year => 2007 },
382         ],
383       },
384       {
385         artistid => ++$aid,
386         name => 'VOID_PK_Manufactured Crap',
387       },
388       {
389         artistid => ++$aid,
390         name => 'VOID_PK_Like I Give a Damn',
391         cds => [
392           { title => 'VOID_PK_My parents sold me to a record company' ,year => 2005 },
393           { title => 'VOID_PK_Why Am I So Ugly?', year => 2006 },
394           { title => 'VOID_PK_I Got Surgery and am now Popular', year => 2007 }
395         ],
396       },
397       {
398         artistid => ++$aid,
399         name => 'VOID_PK_Formerly Named',
400         cds => [
401           { title => 'VOID_PK_One Hit Wonder', year => 2006 },
402         ],
403       },
404       {
405         artistid => ++$aid,
406         name => undef,
407         cds => [
408           { title => 'VOID_PK_Zundef test', year => 2006 },
409         ],
410       },
411     ];
412
413     ## Get the result row objects.
414
415     $art_rs->populate($artists);
416
417     my ($undef, $girl, $formerly, $damn, $crap) = $art_rs->search(
418
419       {name=>[ map { $_->{name} } @$artists]},
420       {order_by=>'name ASC'},
421     );
422
423     ## Do we have the right object?
424
425     isa_ok( $crap, 'DBICTest::Artist', "Got 'Artist'");
426     isa_ok( $girl, 'DBICTest::Artist', "Got 'Artist'");
427     isa_ok( $damn, 'DBICTest::Artist', "Got 'Artist'");
428     isa_ok( $formerly, 'DBICTest::Artist', "Got 'Artist'");
429     isa_ok( $undef, 'DBICTest::Artist', "Got 'Artist'");
430
431     ## Find the expected information?
432
433     ok( $crap->name eq 'VOID_PK_Manufactured Crap', "Got Correct name 'VOID_PK_Manufactured Crap' for result object");
434     ok( $girl->name eq 'VOID_PK_Angsty-Whiny Girl', "Got Correct name for result object");
435     ok( $damn->name eq 'VOID_PK_Like I Give a Damn', "Got Correct name for result object");
436     ok( $formerly->name eq 'VOID_PK_Formerly Named', "Got Correct name for result object");
437     ok( !defined $undef->name, "Got Correct name 'is undef' for result object");
438
439     ## Create the expected children sub objects?
440     ok( $crap->can('cds'), "Has cds relationship");
441     ok( $girl->can('cds'), "Has cds relationship");
442     ok( $damn->can('cds'), "Has cds relationship");
443     ok( $formerly->can('cds'), "Has cds relationship");
444     ok( $undef->can('cds'), "Has cds relationship");
445
446     ok( $crap->cds->count == 0, "got Expected Number of Cds");
447     ok( $girl->cds->count == 2, "got Expected Number of Cds");
448     ok( $damn->cds->count == 3, "got Expected Number of Cds");
449     ok( $formerly->cds->count == 1, "got Expected Number of Cds");
450     ok( $undef->cds->count == 1, "got Expected Number of Cds");
451
452     ## Did the cds get expected information?
453
454     my ($cd1, $cd2) = $girl->cds->search({},{order_by=>'year ASC'});
455
456     ok( $cd1->title eq "VOID_PK_My First CD", "Got Expected CD Title");
457     ok( $cd2->title eq "VOID_PK_Yet More Tweeny-Pop crap", "Got Expected CD Title");
458   }
459
460
461   BELONGS_TO_WITH_PKs: {
462
463     ## Test from a belongs_to perspective, should create artist first,
464     ## then CD with artistid.  This time we try setting the PK's
465
466     my $aid  = $art_rs->get_column('artistid')->max || 0;
467
468     my $cds = [
469       {
470         title => 'Some CD3B',
471         year => '1997',
472         artist => { artistid=> ++$aid, name => 'Fred BloggsCB'},
473       },
474       {
475         title => 'Some CD4B',
476         year => '1997',
477         artist => { artistid=> ++$aid, name => 'Fred BloggsDB'},
478       },
479     ];
480
481     warnings_exist {
482       $cd_rs->populate($cds)
483     } qr/\QFast-path populate() of belongs_to relationship data is not possible/;
484
485     my ($cdA, $cdB) = $cd_rs->search(
486       {title=>[sort map {$_->{title}} @$cds]},
487       {order_by=>'title ASC'},
488     );
489
490     isa_ok($cdA, 'DBICTest::CD', 'Created CD');
491     isa_ok($cdA->artist, 'DBICTest::Artist', 'Set Artist');
492     is($cdA->artist->name, 'Fred BloggsCB', 'Set Artist to FredCB');
493
494     isa_ok($cdB, 'DBICTest::CD', 'Created CD');
495     isa_ok($cdB->artist, 'DBICTest::Artist', 'Set Artist');
496     is($cdB->artist->name, 'Fred BloggsDB', 'Set Artist to FredDB');
497     ok($cdB->artist->artistid == $aid, "Got Expected Artist ID");
498   }
499
500   BELONGS_TO_NO_PKs: {
501
502     ## Test from a belongs_to perspective, should create artist first,
503     ## then CD with artistid.
504
505     my $cds = [
506       {
507         title => 'Some CD3BB',
508         year => '1997',
509         artist => { name => 'Fred BloggsCBB'},
510       },
511       {
512         title => 'Some CD4BB',
513         year => '1997',
514         artist => { name => 'Fred BloggsDBB'},
515       },
516       {
517         title => 'Some CD5BB',
518         year => '1997',
519         artist => { name => undef},
520       },
521     ];
522
523     warnings_exist {
524       $cd_rs->populate($cds);
525     } qr/\QFast-path populate() of belongs_to relationship data is not possible/;
526
527     my ($cdA, $cdB, $cdC) = $cd_rs->search(
528       {title=>[sort map {$_->{title}} @$cds]},
529       {order_by=>'title ASC'},
530     );
531
532     isa_ok($cdA, 'DBICTest::CD', 'Created CD');
533     isa_ok($cdA->artist, 'DBICTest::Artist', 'Set Artist');
534     is($cdA->title, 'Some CD3BB', 'Found Expected title');
535     is($cdA->artist->name, 'Fred BloggsCBB', 'Set Artist to FredCBB');
536
537     isa_ok($cdB, 'DBICTest::CD', 'Created CD');
538     isa_ok($cdB->artist, 'DBICTest::Artist', 'Set Artist');
539     is($cdB->title, 'Some CD4BB', 'Found Expected title');
540     is($cdB->artist->name, 'Fred BloggsDBB', 'Set Artist to FredDBB');
541
542     isa_ok($cdC, 'DBICTest::CD', 'Created CD');
543     isa_ok($cdC->artist, 'DBICTest::Artist', 'Set Artist');
544     is($cdC->title, 'Some CD5BB', 'Found Expected title');
545     is( $cdC->artist->name, undef, 'Set Artist to something undefined');
546   }
547
548
549   HAS_MANY_NO_PKS: {
550
551     ## This first group of tests checks to make sure we can call populate
552     ## with the parent having many children and let the keys be automatic
553
554     my $artists = [
555       {
556         name => 'VOID_Angsty-Whiny Girl',
557         cds => [
558           { title => 'VOID_My First CD', year => 2006 },
559           { title => 'VOID_Yet More Tweeny-Pop crap', year => 2007 },
560         ],
561       },
562       {
563         name => 'VOID_Manufactured Crap',
564       },
565       {
566         name => 'VOID_Like I Give a Damn',
567         cds => [
568           { title => 'VOID_My parents sold me to a record company' ,year => 2005 },
569           { title => 'VOID_Why Am I So Ugly?', year => 2006 },
570           { title => 'VOID_I Got Surgery and am now Popular', year => 2007 }
571         ],
572       },
573       {
574         name => 'VOID_Formerly Named',
575         cds => [
576           { title => 'VOID_One Hit Wonder', year => 2006 },
577         ],
578       },
579     ];
580
581     ## Get the result row objects.
582
583     $art_rs->populate($artists);
584
585     my ($girl, $formerly, $damn, $crap) = $art_rs->search(
586       {name=>[sort map {$_->{name}} @$artists]},
587       {order_by=>'name ASC'},
588     );
589
590     ## Do we have the right object?
591
592     isa_ok( $crap, 'DBICTest::Artist', "Got 'Artist'");
593     isa_ok( $girl, 'DBICTest::Artist', "Got 'Artist'");
594     isa_ok( $damn, 'DBICTest::Artist', "Got 'Artist'");
595     isa_ok( $formerly, 'DBICTest::Artist', "Got 'Artist'");
596
597     ## Find the expected information?
598
599     ok( $crap->name eq 'VOID_Manufactured Crap', "Got Correct name for result object");
600     ok( $girl->name eq 'VOID_Angsty-Whiny Girl', "Got Correct name for result object");
601     ok( $damn->name eq 'VOID_Like I Give a Damn', "Got Correct name for result object");
602     ok( $formerly->name eq 'VOID_Formerly Named', "Got Correct name for result object");
603
604     ## Create the expected children sub objects?
605     ok( $crap->can('cds'), "Has cds relationship");
606     ok( $girl->can('cds'), "Has cds relationship");
607     ok( $damn->can('cds'), "Has cds relationship");
608     ok( $formerly->can('cds'), "Has cds relationship");
609
610     ok( $crap->cds->count == 0, "got Expected Number of Cds");
611     ok( $girl->cds->count == 2, "got Expected Number of Cds");
612     ok( $damn->cds->count == 3, "got Expected Number of Cds");
613     ok( $formerly->cds->count == 1, "got Expected Number of Cds");
614
615     ## Did the cds get expected information?
616
617     my ($cd1, $cd2) = $girl->cds->search({},{order_by=>'year ASC'});
618
619     ok($cd1, "Got a got CD");
620     ok($cd2, "Got a got CD");
621     ok( $cd1->title eq "VOID_My First CD", "Got Expected CD Title");
622     ok( $cd2->title eq "VOID_Yet More Tweeny-Pop crap", "Got Expected CD Title");
623   }
624
625   WITH_COND_FROM_RS: {
626
627     $restricted_art_rs->populate([
628       {
629         name => 'VOID More Manufactured Crap',
630       },
631     ]);
632
633     my $more_crap = $art_rs->search({
634       name => 'VOID More Manufactured Crap'
635     })->first;
636
637     ## Did it use the condition in the resultset?
638     $more_crap->discard_changes;
639     cmp_ok( $more_crap->rank, '==', 42, "Got Correct rank for result object");
640     cmp_ok( $more_crap->charfield, '==', $more_crap->id + 5, "Got Correct charfield for result object");
641   }
642 }
643
644 ARRAYREF_OF_ARRAYREF_STYLE: {
645   $art_rs->populate([
646     [qw/artistid name/],
647     [1000, 'A Formally Unknown Singer'],
648     [1001, 'A singer that jumped the shark two albums ago'],
649     [1002, 'An actually cool singer.'],
650   ]);
651
652   ok my $unknown = $art_rs->find(1000), "got Unknown";
653   ok my $jumped = $art_rs->find(1001), "got Jumped";
654   ok my $cool = $art_rs->find(1002), "got Cool";
655
656   is $unknown->name, 'A Formally Unknown Singer', 'Correct Name';
657   is $jumped->name, 'A singer that jumped the shark two albums ago', 'Correct Name';
658   is $cool->name, 'An actually cool singer.', 'Correct Name';
659
660   my ($cooler, $lamer) = $restricted_art_rs->populate([
661     [qw/artistid name/],
662     [1003, 'Cooler'],
663     [1004, 'Lamer'],
664   ]);
665
666   is $cooler->name, 'Cooler', 'Correct Name';
667   is $lamer->name, 'Lamer', 'Correct Name';
668
669   for ($cooler, $lamer) {
670     $_->discard_changes;
671     cmp_ok( $_->rank, '==', 42, "Got Correct rank for result object");
672     cmp_ok( $_->charfield, '==', $_->id + 5, "Got Correct charfield for result object");
673   }
674
675   ARRAY_CONTEXT_WITH_COND_FROM_RS: {
676
677     my ($mega_lamer) = $restricted_art_rs->populate([
678       {
679         name => 'Mega Lamer',
680       },
681     ]);
682
683     ## Did it use the condition in the resultset?
684     $mega_lamer->discard_changes;
685     cmp_ok( $mega_lamer->rank, '==', 42, "Got Correct rank for result object");
686     cmp_ok( $mega_lamer->charfield, '==', $mega_lamer->id + 5, "Got Correct charfield for result object");
687   }
688
689   VOID_CONTEXT_WITH_COND_FROM_RS: {
690
691     $restricted_art_rs->populate([
692       {
693         name => 'VOID Mega Lamer',
694       },
695     ]);
696
697     my $mega_lamer = $art_rs->search({
698       name => 'VOID Mega Lamer'
699     })->first;
700
701     ## Did it use the condition in the resultset?
702     cmp_ok( $mega_lamer->rank, '==', 42, "Got Correct rank for result object");
703     cmp_ok( $mega_lamer->charfield, '==', $mega_lamer->id + 5, "Got Correct charfield for result object");
704   }
705 }
706
707 ok(eval { $art_rs->populate([]); 1 }, "Empty populate runs but does nothing");
708
709 done_testing;