X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=t%2F52leaks.t;h=b427175a5d39528f129582f27ffc49515d0f84bc;hb=65ea9cada6f22fa3159cdf3516bc9bcd5ba7e1a5;hp=60392059debb23b8140ec488da1650966a5be1d8;hpb=30c81ba900b124d3eac52ed53b800f4192346d4c;p=dbsrgits%2FDBIx-Class.git

diff --git a/t/52leaks.t b/t/52leaks.t
index 6039205..b427175 100644
--- a/t/52leaks.t
+++ b/t/52leaks.t
@@ -23,34 +23,24 @@ use Test::More;
 
 use lib qw(t/lib);
 use DBICTest::RunMode;
+use DBICTest::Util::LeakTracer qw(populate_weakregistry assert_empty_weakregistry visit_refs);
+use Scalar::Util qw(weaken blessed reftype);
+use DBIx::Class::_Util qw(hrefaddr sigwarn_silencer modver_gt_or_eq modver_gt_or_eq_and_lt);
+BEGIN {
+  plan skip_all => "Your perl version $] appears to leak like a sieve - skipping test"
+    if DBIx::Class::_ENV_::PEEPEENESS;
+}
 
-plan skip_all => "Temporarily no smoke testing of Test::More 1.3xx alphas" if (
-  DBICTest::RunMode->is_smoker
-    and
-  eval { Test::More->VERSION("1.300") }
-    and
-  require ExtUtils::MakeMaker
-    and
-  MM->parse_version($INC{"Test/Builder.pm"}) =~ / ^ 1 \. 3.. ... \_ /x
-);
 
 my $TB = Test::More->builder;
 if ($ENV{DBICTEST_IN_PERSISTENT_ENV}) {
-  # without this explicit close older TBs warn in END after a ->reset
-  if ($TB->VERSION < 1.005) {
-    close ($TB->$_) for (qw/output failure_output todo_output/);
-  }
+  # without this explicit close TB warns in END after a ->reset
+  close ($TB->$_) for qw(output failure_output todo_output);
 
-  # if I do not do this, I get happy sigpipes on new TB, no idea why
-  # (the above close-and-forget doesn't work - new TB does *not* reopen
-  # its handles automatically anymore)
-  else {
-    for (qw/failure_output todo_output/) {
-      close $TB->$_;
-      open ($TB->$_, '>&', *STDERR);
-    }
-
-    close $TB->output;
+  # newer TB does not auto-reopen handles
+  if ( modver_gt_or_eq( 'Test::More', '1.200' ) ) {
+    open ($TB->$_, '>&', *STDERR)
+      for qw( failure_output todo_output );
     open ($TB->output, '>&', *STDOUT);
   }
 
@@ -58,15 +48,6 @@ if ($ENV{DBICTEST_IN_PERSISTENT_ENV}) {
   $TB->reset;
 }
 
-use DBICTest::Util::LeakTracer qw(populate_weakregistry assert_empty_weakregistry visit_refs);
-use Scalar::Util qw(weaken blessed reftype);
-use DBIx::Class;
-use DBIx::Class::_Util qw(hrefaddr sigwarn_silencer);
-BEGIN {
-  plan skip_all => "Your perl version $] appears to leak like a sieve - skipping test"
-    if DBIx::Class::_ENV_::PEEPEENESS;
-}
-
 # this is what holds all weakened refs to be checked for leakage
 my $weak_registry = {};
 
@@ -74,7 +55,8 @@ my $weak_registry = {};
 my $has_dt;
 
 # Skip the heavy-duty leak tracing when just doing an install
-unless (DBICTest::RunMode->is_plain) {
+# or when having Moose crap all over everything
+if ( !$ENV{DBICTEST_VIA_REPLICATED} and !DBICTest::RunMode->is_plain ) {
 
   # redefine the bless override so that we can catch each and every object created
   no warnings qw/redefine once/;
@@ -98,7 +80,7 @@ unless (DBICTest::RunMode->is_plain) {
     # Test Builder is now making a new object for every pass/fail (que bloat?)
     # and as such we can't really store any of its objects (since it will
     # re-populate the registry while checking it, ewwww!)
-    return $obj if (ref $obj) =~ /^TB2::/;
+    return $obj if (ref $obj) =~ /^TB2::|^Test::Stream/;
 
     # populate immediately to avoid weird side effects
     return populate_weakregistry ($weak_registry, $obj );
@@ -117,7 +99,7 @@ unless (DBICTest::RunMode->is_plain) {
   # Load them and empty the registry
 
   # this loads the DT armada
-  $has_dt = DBIx::Class::Optional::Dependencies->req_ok_for('test_dt_sqlite');
+  $has_dt = DBIx::Class::Optional::Dependencies->req_ok_for([qw( test_rdbms_sqlite ic_dt )]);
 
   require Errno;
   require DBI;
@@ -135,8 +117,6 @@ unless (DBICTest::RunMode->is_plain) {
   my $rs = $schema->resultset ('Artist');
   my $storage = $schema->storage;
 
-  ok ($storage->connected, 'we are connected');
-
   my $row_obj = $rs->search({}, { rows => 1})->next;  # so that commits/rollbacks work
   ok ($row_obj, 'row from db');
 
@@ -339,9 +319,6 @@ unless (DBICTest::RunMode->is_plain) {
       ! DBICTest::RunMode->is_plain
         and
       ! $ENV{DBICTEST_IN_PERSISTENT_ENV}
-        and
-      # FIXME - investigate wtf is going on with 5.18
-      ! ( $] > 5.017 and $ENV{DBIC_TRACE_PROFILE} )
     ) {
 
       # FIXME - ideally we should be able to just populate an alternative
@@ -469,6 +446,18 @@ for my $addr (keys %$weak_registry) {
     delete $weak_registry->{$addr}
       unless $cleared->{hash_merge_singleton}{$weak_registry->{$addr}{weakref}{behavior}}++;
   }
+  elsif ($names =~ /^B::Hooks::EndOfScope::PP::_TieHintHashFieldHash/m) {
+    # there is one tied lexical which stays alive until GC time
+    # https://metacpan.org/source/ETHER/B-Hooks-EndOfScope-0.15/lib/B/Hooks/EndOfScope/PP/FieldHash.pm#L24
+    # simply ignore it here, instead of teaching the leaktracer to examine ties
+    # the latter is possible yet terrible: https://github.com/dbsrgits/dbix-class/blob/v0.082820/t/lib/DBICTest/Util/LeakTracer.pm#L113-L117
+    delete $weak_registry->{$addr}
+      unless $cleared->{bheos_pptiehinthashfieldhash}++;
+  }
+  elsif ($names =~ /^DateTime::TimeZone::UTC/m) {
+    # DT is going through a refactor it seems - let it leak zones for now
+    delete $weak_registry->{$addr};
+  }
   elsif (
 #    # if we can look at closed over pieces - we will register it as a global
 #    !DBICTest::Util::LeakTracer::CV_TRACING
@@ -536,23 +525,7 @@ $ENV{PERL5LIB} = join ($Config::Config{path_sep}, @INC);
 ($ENV{PATH}) = $ENV{PATH} =~ /(.+)/;
 
 
-my $persistence_tests = {
-  PPerl => {
-    cmd => [qw/pperl --prefork=1/, __FILE__],
-  },
-  'CGI::SpeedyCGI' => {
-    cmd => [qw/speedy -- -t5/, __FILE__],
-  },
-};
-
-# scgi is smart and will auto-reap after -t amount of seconds
-# pperl needs an actual killer :(
-$persistence_tests->{PPerl}{termcmd} = [
-  $persistence_tests->{PPerl}{cmd}[0],
-  '--kill',
-  @{$persistence_tests->{PPerl}{cmd}}[ 1 .. $#{$persistence_tests->{PPerl}{cmd}} ],
-];
-
+my $persistence_tests;
 SKIP: {
   skip 'Test already in a persistent loop', 1
     if $ENV{DBICTEST_IN_PERSISTENT_ENV};
@@ -560,8 +533,28 @@ SKIP: {
   skip 'Main test failed - skipping persistent env tests', 1
     unless $TB->is_passing;
 
+  skip "Test::Builder\@@{[ Test::Builder->VERSION ]} known to break persistence tests", 1
+    if modver_gt_or_eq_and_lt( 'Test::More', '1.200', '1.301001_099' );
+
   local $ENV{DBICTEST_IN_PERSISTENT_ENV} = 1;
 
+  $persistence_tests = {
+    PPerl => {
+      cmd => [qw/pperl --prefork=1/, __FILE__],
+    },
+    'CGI::SpeedyCGI' => {
+      cmd => [qw/speedy -- -t5/, __FILE__],
+    },
+  };
+
+  # scgi is smart and will auto-reap after -t amount of seconds
+  # pperl needs an actual killer :(
+  $persistence_tests->{PPerl}{termcmd} = [
+    $persistence_tests->{PPerl}{cmd}[0],
+    '--kill',
+    @{$persistence_tests->{PPerl}{cmd}}[ 1 .. $#{$persistence_tests->{PPerl}{cmd}} ],
+  ];
+
   require IPC::Open2;
 
   for my $type (keys %$persistence_tests) { SKIP: {
@@ -610,10 +603,13 @@ done_testing;
 # just an extra precaution in case we blew away from the SKIP - since there are no
 # PID files to go by (man does pperl really suck :(
 END {
-  unless ($ENV{DBICTEST_IN_PERSISTENT_ENV}) {
-    close $_ for (*STDIN, *STDOUT, *STDERR);
+  if ($persistence_tests->{PPerl}{termcmd}) {
     local $?; # otherwise test will inherit $? of the system()
-    system (@{$persistence_tests->{PPerl}{termcmd}})
-      if $persistence_tests->{PPerl}{termcmd};
+    require IPC::Open3;
+    open my $null, ">", File::Spec->devnull;
+    waitpid(
+      IPC::Open3::open3(undef, $null, $null, @{$persistence_tests->{PPerl}{termcmd}}),
+      0,
+    );
   }
 }