fix Cursor SYNOPSIS
[dbsrgits/DBIx-Class-Historic.git] / t / 52leaks.t
CommitLineData
66917da3 1# work around brain damage in PPerl (yes, it has to be a global)
2$SIG{__WARN__} = sub {
3 warn @_ unless $_[0] =~ /\QUse of "goto" to jump into a construct is deprecated/
4} if ($ENV{DBICTEST_IN_PERSISTENT_ENV});
5
6# the persistent environments run with this flag first to see if
7# we will run at all (e.g. it will fail if $^X doesn't match)
8exit 0 if $ENV{DBICTEST_PERSISTENT_ENV_BAIL_EARLY};
9
f05edfd1 10# Do the override as early as possible so that CORE::bless doesn't get compiled away
11# We will replace $bless_override only if we are in author mode
12my $bless_override;
13BEGIN {
14 $bless_override = sub {
15 CORE::bless( $_[0], (@_ > 1) ? $_[1] : caller() );
16 };
17 *CORE::GLOBAL::bless = sub { goto $bless_override };
18}
19
50261284 20use strict;
21use warnings;
a917fb06 22use Test::More;
d5e5fb4b 23
66917da3 24my $TB = Test::More->builder;
25if ($ENV{DBICTEST_IN_PERSISTENT_ENV}) {
7be5717e 26 # without this explicit close older TBs warn in END after a ->reset
27 if ($TB->VERSION < 1.005) {
28 close ($TB->$_) for (qw/output failure_output todo_output/);
29 }
66917da3 30
7be5717e 31 # if I do not do this, I get happy sigpipes on new TB, no idea why
32 # (the above close-and-forget doesn't work - new TB does *not* reopen
33 # its handles automatically anymore)
34 else {
35 for (qw/failure_output todo_output/) {
36 close $TB->$_;
37 open ($TB->$_, '>&', *STDERR);
38 }
66917da3 39
7be5717e 40 close $TB->output;
41 open ($TB->output, '>&', *STDOUT);
42 }
43
44 # so done_testing can work on every persistent pass
45 $TB->reset;
66917da3 46}
47
d5e5fb4b 48use lib qw(t/lib);
49use DBICTest::RunMode;
65d35121 50use DBICTest::Util qw/populate_weakregistry assert_empty_weakregistry/;
e0b2dc74 51use DBIx::Class;
dee99c24 52use B 'svref_2object';
d12d8272 53BEGIN {
d5e5fb4b 54 plan skip_all => "Your perl version $] appears to leak like a sieve - skipping test"
dee99c24 55 if DBIx::Class::_ENV_::PEEPEENESS;
d12d8272 56}
57
a8c2c746 58# this is what holds all weakened refs to be checked for leakage
59my $weak_registry = {};
60
6a43bc0c 61# whether or to invoke IC::DT
62my $has_dt;
63
a8c2c746 64# Skip the heavy-duty leak tracing when just doing an install
65unless (DBICTest::RunMode->is_plain) {
f05edfd1 66
eb7aa960 67 # redefine the bless override so that we can catch each and every object created
a8c2c746 68 no warnings qw/redefine once/;
69 no strict qw/refs/;
70
f05edfd1 71 $bless_override = sub {
72
a8c2c746 73 my $obj = CORE::bless(
74 $_[0], (@_ > 1) ? $_[1] : do {
75 my ($class, $fn, $line) = caller();
76 fail ("bless() of $_[0] into $class without explicit class specification at $fn line $line")
77 if $class =~ /^ (?: DBIx\:\:Class | DBICTest ) /x;
78 $class;
79 }
80 );
81
8d6b1478 82 # unicode is tricky, and now we happen to invoke it early via a
83 # regex in connection()
84 return $obj if (ref $obj) =~ /^utf8/;
85
7be5717e 86 # Test Builder is now making a new object for every pass/fail (que bloat?)
87 # and as such we can't really store any of its objects (since it will
88 # re-populate the registry while checking it, ewwww!)
89 return $obj if (ref $obj) =~ /^TB2::/;
90
a8c2c746 91 # weaken immediately to avoid weird side effects
65d35121 92 return populate_weakregistry ($weak_registry, $obj );
a8c2c746 93 };
94
eb7aa960 95 require Try::Tiny;
a8c2c746 96 for my $func (qw/try catch finally/) {
97 my $orig = \&{"Try::Tiny::$func"};
98 *{"Try::Tiny::$func"} = sub (&;@) {
65d35121 99 populate_weakregistry( $weak_registry, $_[0] );
a8c2c746 100 goto $orig;
101 }
102 }
eb7aa960 103
104 # Some modules are known to install singletons on-load
105 # Load them and empty the registry
106
107 # this loads the DT armada
108 $has_dt = DBIx::Class::Optional::Dependencies->req_ok_for('test_dt_sqlite');
109
110 require Errno;
111 require DBI;
112 require DBD::SQLite;
113 require FileHandle;
e6ff3658 114 require Moo;
eb7aa960 115
116 %$weak_registry = ();
a8c2c746 117}
118
dee99c24 119my @compose_ns_classes;
a8c2c746 120{
66917da3 121 use_ok ('DBICTest');
a917fb06 122
a8c2c746 123 my $schema = DBICTest->init_schema;
124 my $rs = $schema->resultset ('Artist');
125 my $storage = $schema->storage;
a917fb06 126
dee99c24 127 @compose_ns_classes = map { "DBICTest::${_}" } keys %{$schema->source_registrations};
128
a8c2c746 129 ok ($storage->connected, 'we are connected');
a917fb06 130
052b8ce2 131 my $row_obj = $rs->search({}, { rows => 1})->next; # so that commits/rollbacks work
a8c2c746 132 ok ($row_obj, 'row from db');
133
052b8ce2 134 # txn_do to invoke more codepaths
a8c2c746 135 my ($mc_row_obj, $pager, $pager_explicit_count) = $schema->txn_do (sub {
136
9345b14c 137 my $artist = $schema->resultset('Artist')->create ({
a8c2c746 138 name => 'foo artist',
139 cds => [{
140 title => 'foo cd',
141 year => 1984,
187ec69a 142 tracks => [
143 { title => 't1' },
144 { title => 't2' },
145 ],
146 genre => { name => 'mauve' },
a8c2c746 147 }],
148 });
149
150 my $pg = $rs->search({}, { rows => 1})->page(2)->pager;
151
152 my $pg_wcount = $rs->page(4)->pager->total_entries (66);
153
154 return ($artist, $pg, $pg_wcount);
155 });
156
9345b14c 157 # more codepaths - error handling in txn_do
158 {
159 eval { $schema->txn_do ( sub {
160 $storage->_dbh->begin_work;
161 fail ('how did we get so far?!');
162 } ) };
163
164 eval { $schema->txn_do ( sub {
165 $schema->txn_do ( sub {
166 die "It's called EXCEPTION";
167 fail ('how did we get so far?!');
168 } );
169 fail ('how did we get so far?!');
170 } ) };
171 like( $@, qr/It\'s called EXCEPTION/, 'Exception correctly propagated in nested txn_do' );
172 }
173
174 # dbh_do codepath
187ec69a 175 my ($rs_bind_circref, $cond_rowobj) = $schema->storage->dbh_do ( sub {
176 my $row = $_[0]->schema->resultset('Artist')->new({});
177 my $rs = $_[0]->schema->resultset('Artist')->search({
178 name => $row, # this is deliberately bogus, see FIXME below!
179 });
180 return ($rs, $row);
181 });
182
a8c2c746 183 is ($pager->next_page, 3, 'There is one more page available');
184
185 # based on 66 per 10 pages
186 is ($pager_explicit_count->last_page, 7, 'Correct last page');
551e711a 187
052b8ce2 188 # do some population (invokes some extra codepaths)
189 # also exercise the guard code and the manual txn control
190 {
191 my $guard = $schema->txn_scope_guard;
192 # populate with bindvars
193 $rs->populate([{ name => 'James Bound' }]);
194 $guard->commit;
195
196 $schema->txn_begin;
197 # populate mixed
198 $rs->populate([{ name => 'James Rebound', rank => \ '11' }]);
199 $schema->txn_commit;
200
201 $schema->txn_begin;
202 # and without bindvars
203 $rs->populate([{ name => \ '"James Unbound"' }]);
204 $schema->txn_rollback;
205 }
206
0a03206a 207 # prefetching
208 my $cds_rs = $schema->resultset('CD');
209 my $cds_with_artist = $cds_rs->search({}, { prefetch => 'artist' });
210 my $cds_with_tracks = $cds_rs->search({}, { prefetch => 'tracks' });
211 my $cds_with_stuff = $cds_rs->search({}, { prefetch => [ 'genre', { artist => { cds => { tracks => 'cd_single' } } } ] });
212
213 # implicit pref
214 my $cds_with_impl_artist = $cds_rs->search({}, { columns => [qw/me.title artist.name/], join => 'artist' });
215
216 # get_column
217 my $getcol_rs = $cds_rs->get_column('me.cdid');
218 my $pref_getcol_rs = $cds_with_stuff->get_column('me.cdid');
219
220 # fire the column getters
221 my @throwaway = $pref_getcol_rs->all;
222
a8c2c746 223 my $base_collection = {
a8c2c746 224 resultset => $rs,
307ab4c5 225
0a03206a 226 pref_precursor => $cds_rs,
227
228 pref_rs_single => $cds_with_artist,
229 pref_rs_multi => $cds_with_tracks,
230 pref_rs_nested => $cds_with_stuff,
231
232 pref_rs_implicit => $cds_with_impl_artist,
233
234 pref_row_single => $cds_with_artist->next,
235 pref_row_multi => $cds_with_tracks->next,
236 pref_row_nested => $cds_with_stuff->next,
237
238 # even though this does not leak Storable croaks on it :(((
239 #pref_row_implicit => $cds_with_impl_artist->next,
240
241 get_column_rs_plain => $getcol_rs,
242 get_column_rs_pref => $pref_getcol_rs,
243
37aafa2e 244 # twice so that we make sure only one H::M object spawned
245 chained_resultset => $rs->search_rs ({}, { '+columns' => [ 'foo' ] } ),
246 chained_resultset2 => $rs->search_rs ({}, { '+columns' => [ 'bar' ] } ),
247
a8c2c746 248 row_object => $row_obj,
551e711a 249
187ec69a 250 mc_row_object => $mc_row_obj,
251
a8c2c746 252 result_source => $rs->result_source,
551e711a 253
4376a157 254 result_source_handle => $rs->result_source->handle,
255
a8c2c746 256 pager_explicit_count => $pager_explicit_count,
187ec69a 257
258 leaky_resultset => $rs_bind_circref,
259 leaky_resultset_cond => $cond_rowobj,
260 leaky_resultset_member => $rs_bind_circref->next,
a8c2c746 261 };
574d9b69 262
eb7aa960 263 require Storable;
4376a157 264 %$base_collection = (
265 %$base_collection,
266 refrozen => Storable::dclone( $base_collection ),
267 rerefrozen => Storable::dclone( Storable::dclone( $base_collection ) ),
0a03206a 268 pref_row_implicit => $cds_with_impl_artist->next,
4376a157 269 schema => $schema,
270 storage => $storage,
271 sql_maker => $storage->sql_maker,
272 dbh => $storage->_dbh,
cd122820 273 fresh_pager => $rs->page(5)->pager,
274 pager => $pager,
4376a157 275 );
276
6a43bc0c 277 if ($has_dt) {
278 my $rs = $base_collection->{icdt_rs} = $schema->resultset('Event');
279
280 my $now = DateTime->now;
281 for (1..5) {
282 $base_collection->{"icdt_row_$_"} = $rs->create({
283 created_on => DateTime->new(year => 2011, month => 1, day => $_, time_zone => "-0${_}00" ),
284 starts_at => $now->clone->add(days => $_),
285 });
286 }
287
288 # re-search
289 my @dummy = $rs->all;
290 }
291
eb7aa960 292 # dbh's are created in XS space, so pull them separately
293 for ( grep { defined } map { @{$_->{ChildHandles}} } values %{ {DBI->installed_drivers()} } ) {
294 $base_collection->{"DBI handle $_"} = $_;
295 }
296
187ec69a 297 SKIP: {
298 if ( DBIx::Class::Optional::Dependencies->req_ok_for ('test_leaks') ) {
299 Test::Memory::Cycle::memory_cycle_ok ($base_collection, 'No cycles in the object collection')
300 }
301 else {
302 skip 'Circular ref test needs ' . DBIx::Class::Optional::Dependencies->req_missing_for ('test_leaks'), 1;
303 }
eb7aa960 304 }
574d9b69 305
65d35121 306 populate_weakregistry ($weak_registry, $base_collection->{$_}, "basic $_")
307 for keys %$base_collection;
551e711a 308}
309
50261284 310# check that "phantom-chaining" works - we never lose track of the original $schema
311# and have access to the entire tree without leaking anything
312{
313 my $phantom;
314 for (
39b80a73 315 sub { DBICTest->init_schema( sqlite_use_file => 0 ) },
50261284 316 sub { shift->source('Artist') },
317 sub { shift->resultset },
318 sub { shift->result_source },
319 sub { shift->schema },
320 sub { shift->resultset('Artist') },
321 sub { shift->find_or_create({ name => 'detachable' }) },
322 sub { shift->result_source },
323 sub { shift->schema },
324 sub { shift->clone },
187ec69a 325 sub { shift->resultset('CD') },
326 sub { shift->next },
327 sub { shift->artist },
328 sub { shift->search_related('cds') },
50261284 329 sub { shift->next },
187ec69a 330 sub { shift->search_related('artist') },
50261284 331 sub { shift->result_source },
332 sub { shift->resultset },
333 sub { shift->create({ name => 'detached' }) },
334 sub { shift->update({ name => 'reattached' }) },
335 sub { shift->discard_changes },
336 sub { shift->delete },
337 sub { shift->insert },
338 ) {
65d35121 339 $phantom = populate_weakregistry ( $weak_registry, scalar $_->($phantom) );
50261284 340 }
341
342 ok( $phantom->in_storage, 'Properly deleted/reinserted' );
343 is( $phantom->name, 'reattached', 'Still correct name' );
344}
a8c2c746 345
307ab4c5 346# Naturally we have some exceptions
347my $cleared;
348for my $slot (keys %$weak_registry) {
6a43bc0c 349 if ($slot =~ /^Test::Builder/) {
c8194884 350 # T::B 2.0 has result objects and other fancyness
351 delete $weak_registry->{$slot};
352 }
9345b14c 353 elsif ($slot =~ /^Method::Generate::(?:Accessor|Constructor)/) {
354 # Moo keeps globals around, this is normal
355 delete $weak_registry->{$slot};
356 }
6a43bc0c 357 elsif ($slot =~ /^SQL::Translator/) {
307ab4c5 358 # SQLT is a piece of shit, leaks all over
359 delete $weak_registry->{$slot};
360 }
6a43bc0c 361 elsif ($slot =~ /^Hash::Merge/) {
37aafa2e 362 # only clear one object of a specific behavior - more would indicate trouble
307ab4c5 363 delete $weak_registry->{$slot}
364 unless $cleared->{hash_merge_singleton}{$weak_registry->{$slot}{weakref}{behavior}}++;
365 }
b4ad8a74 366 elsif (DBIx::Class::_ENV_::INVISIBLE_DOLLAR_AT and $slot =~ /^__TxnScopeGuard__FIXUP__/) {
48e4eac6 367 delete $weak_registry->{$slot}
1f870d5a 368 }
eb7aa960 369 elsif ($slot =~ /^DateTime::TimeZone/) {
370 # DT is going through a refactor it seems - let it leak zones for now
371 delete $weak_registry->{$slot};
372 }
307ab4c5 373}
374
dee99c24 375# every result class has a result source instance as classdata
376# make sure these are all present and distinct before ignoring
377# (distinct means only 1 reference)
378for my $rs_class (
a8c2c746 379 'DBICTest::BaseResult',
dee99c24 380 @compose_ns_classes,
a8c2c746 381 map { DBICTest::Schema->class ($_) } DBICTest::Schema->sources
dee99c24 382) {
383 # need to store the SVref and examine it separately, to push the rsrc instance off the pad
384 my $SV = svref_2object($rs_class->result_source_instance);
385 is( $SV->REFCNT, 1, "Source instance of $rs_class referenced exactly once" );
386
387 # ignore it
388 delete $weak_registry->{$rs_class->result_source_instance};
fa442fd5 389}
a8c2c746 390
dee99c24 391# Schema classes also hold sources, but these are clones, since
392# each source contains the schema (or schema class name in this case)
393# Hence the clone so that the same source can be registered with
394# multiple schemas
395for my $moniker ( keys %{DBICTest::Schema->source_registrations || {}} ) {
396
397 my $SV = svref_2object(DBICTest::Schema->source($moniker));
398 is( $SV->REFCNT, 1, "Source instance registered under DBICTest::Schema as $moniker referenced exactly once" );
399
400 delete $weak_registry->{DBICTest::Schema->source($moniker)};
fa442fd5 401}
a8c2c746 402
187ec69a 403# FIXME !!!
404# There is an actual strong circular reference taking place here, but because
405# half of it is in XS no leaktracer sees it, and Devel::FindRef is equally
406# stumped when trying to trace the origin. The problem is:
407#
408# $cond_object --> result_source --> schema --> storage --> $dbh --> {cached_kids}
409# ^ /
410# \-------- bound value on prepared/cached STH <-----------/
411#
412TODO: {
413 local $TODO = 'Not sure how to fix this yet, an entanglment could be an option';
414 my $r = $weak_registry->{'basic leaky_resultset_cond'}{weakref};
415 ok(! defined $r, 'We no longer leak!')
416 or $r->result_source(undef);
417}
418
65d35121 419assert_empty_weakregistry ($weak_registry);
551e711a 420
66917da3 421# we got so far without a failure - this is a good thing
422# now let's try to rerun this script under a "persistent" environment
423# this is ugly and dirty but we do not yet have a Test::Embedded or
424# similar
425
f3ec358e 426# set up -I
427require Config;
428$ENV{PERL5LIB} = join ($Config::Config{path_sep}, @INC);
429($ENV{PATH}) = $ENV{PATH} =~ /(.+)/;
430
431
7be5717e 432my $persistence_tests = {
433 PPerl => {
434 cmd => [qw/pperl --prefork=1/, __FILE__],
435 },
436 'CGI::SpeedyCGI' => {
437 cmd => [qw/speedy -- -t5/, __FILE__],
438 },
439};
66917da3 440
441# scgi is smart and will auto-reap after -t amount of seconds
7be5717e 442# pperl needs an actual killer :(
443$persistence_tests->{PPerl}{termcmd} = [
444 $persistence_tests->{PPerl}{cmd}[0],
445 '--kill',
446 @{$persistence_tests->{PPerl}{cmd}}[ 1 .. $#{$persistence_tests->{PPerl}{cmd}} ],
447];
66917da3 448
449SKIP: {
450 skip 'Test already in a persistent loop', 1
451 if $ENV{DBICTEST_IN_PERSISTENT_ENV};
452
66917da3 453 skip 'Main test failed - skipping persistent env tests', 1
454 unless $TB->is_passing;
455
66917da3 456 local $ENV{DBICTEST_IN_PERSISTENT_ENV} = 1;
457
7be5717e 458 require IPC::Open2;
459
460 for my $type (keys %$persistence_tests) { SKIP: {
461 skip "$type module not found", 1
462 unless eval "require $type";
463
464 my @cmd = @{$persistence_tests->{$type}{cmd}};
66917da3 465
466 # since PPerl is racy and sucks - just prime the "server"
467 {
468 local $ENV{DBICTEST_PERSISTENT_ENV_BAIL_EARLY} = 1;
7be5717e 469 system(@cmd);
66917da3 470 sleep 1;
471
7be5717e 472 # see if the thing actually runs, if not - might as well bail now
473 skip "Something is wrong with $type ($!)", 1
474 if system(@cmd);
66917da3 475 }
476
477 for (1,2,3) {
7be5717e 478 note ("Starting run in persistent env ($type pass $_)");
479 IPC::Open2::open2(my $out, undef, @cmd);
480 my @out_lines;
481 while (my $ln = <$out>) {
482 next if $ln =~ /^\s*$/;
483 push @out_lines, " $ln";
484 last if $ln =~ /^\d+\.\.\d+$/; # this is persistence, we need to terminate reading on our end
485 }
486 print $_ for @out_lines;
487 close $out;
488 wait;
489 ok (!$?, "Run in persistent env ($type pass $_): exit $?");
490 ok (scalar @out_lines, "Run in persistent env ($type pass $_): got output");
66917da3 491 }
492
7be5717e 493 ok (! system (@{$persistence_tests->{$type}{termcmd}}), "killed $type server instance")
494 if $persistence_tests->{$type}{termcmd};
495 }}
66917da3 496}
497
551e711a 498done_testing;
66917da3 499
500# just an extra precaution in case we blew away from the SKIP - since there are no
501# PID files to go by (man does pperl really suck :(
502END {
503 unless ($ENV{DBICTEST_IN_PERSISTENT_ENV}) {
7be5717e 504 close $_ for (*STDIN, *STDOUT, *STDERR);
66917da3 505 local $?; # otherwise test will inherit $? of the system()
7be5717e 506 system (@{$persistence_tests->{PPerl}{termcmd}});
66917da3 507 }
508}