t/84serialize.t

   1 use strict;
   2 use warnings;
   3
   4 use Test::More;
   5 use Test::Exception;
   6 use lib qw(t/lib);
   7 use DBICTest;
   8 use Storable qw(dclone freeze nfreeze thaw);
   9 use Scalar::Util qw/refaddr/;
  10 use Carp;
  11
  12 plan skip_all => 'Something causes this to fail on TravisCI'
  13   if $ENV{TRAVIS};
  14
  15 sub ref_ne {
  16   my ($refa, $refb) = map { refaddr $_ or croak "$_ is not a reference!" } @_[0,1];
  17   cmp_ok (
  18     $refa,
  19       '!=',
  20     $refb,
  21     sprintf ('%s (0x%07x != 0x%07x)',
  22       $_[2],
  23       $refa,
  24       $refb,
  25     ),
  26   );
  27 }
  28
  29 my $schema = DBICTest->init_schema;
  30
  31 my %stores = (
  32     dclone_method           => sub { return $schema->dclone($_[0]) },
  33     dclone_func             => sub {
  34       local $DBIx::Class::ResultSourceHandle::thaw_schema = $schema;
  35       return dclone($_[0])
  36     },
  37     "freeze/thaw_method"    => sub {
  38       my $ice = $schema->freeze($_[0]);
  39       return $schema->thaw($ice);
  40     },
  41     "nfreeze/thaw_func"      => sub {
  42       my $ice = freeze($_[0]);
  43       local $DBIx::Class::ResultSourceHandle::thaw_schema = $schema;
  44       return thaw($ice);
  45     },
  46
  47     "freeze/thaw_func (cdbi legacy)" => sub {
  48       # this one is special-cased to leak the $schema all over
  49       # the same way as cdbi-compat does
  50       DBICTest::Artist->result_source_instance->schema($schema);
  51       DBICTest::CD->result_source_instance->schema($schema);
  52
  53       my $fire = thaw(freeze($_[0]));
  54
  55       # clean up the mess
  56       $_->result_source_instance->schema(undef)
  57         for map { $schema->class ($_) } $schema->sources;
  58
  59       return $fire;
  60     },
  61
  62 );
  63
  64 if ($ENV{DBICTEST_MEMCACHED}) {
  65   if (DBIx::Class::Optional::Dependencies->req_ok_for ('test_memcached')) {
  66     my $memcached = Cache::Memcached->new(
  67       { servers => [ $ENV{DBICTEST_MEMCACHED} ] }
  68     );
  69
  70     my $key = 'tmp_dbic_84serialize_memcached_test';
  71
  72     $stores{memcached} = sub {
  73       $memcached->set( $key, $_[0], 60 );
  74       local $DBIx::Class::ResultSourceHandle::thaw_schema = $schema;
  75       return $memcached->get($key);
  76     };
  77   }
  78   else {
  79     SKIP: {
  80       skip 'Memcached tests need ' . DBIx::Class::Optional::Dependencies->req_missing_for ('test_memcached'), 1;
  81     }
  82   }
  83 }
  84 else {
  85   SKIP: {
  86     skip 'Set $ENV{DBICTEST_MEMCACHED} to run the memcached serialization tests', 1;
  87   }
  88 }
  89
  90
  91
  92 for my $name (keys %stores) {
  93
  94     my $store = $stores{$name};
  95     my $copy;
  96
  97     my $artist = $schema->resultset('Artist')->find(1);
  98
  99     lives_ok { $copy = $store->($artist) } "serialize row object lives: $name";
 100     ref_ne($copy, $artist, 'Simple row cloned');
 101     is_deeply($copy, $artist, "serialize row object works: $name");
 102
 103     my $cd_rs = $artist->search_related("cds");
 104
 105     # test that a live result source can be serialized as well
 106     is( $cd_rs->count, 3, '3 CDs in database');
 107     ok( $cd_rs->next, 'Advance cursor' );
 108
 109     lives_ok {
 110       $copy = $store->($cd_rs);
 111
 112       ref_ne($copy, $artist, 'Simple row cloned');
 113
 114       is_deeply (
 115         [ $copy->all ],
 116         [ $cd_rs->all ],
 117         "serialize resultset works: $name",
 118       );
 119     } "serialize resultset lives: $name";
 120
 121     # Test that an object with a related_resultset can be serialized.
 122     ok $artist->{related_resultsets}, 'has key: related_resultsets';
 123
 124     lives_ok { $copy = $store->($artist) } "serialize row object with related_resultset lives: $name";
 125     for my $key (keys %$artist) {
 126         next if $key eq 'related_resultsets';
 127         next if $key eq '_inflated_column';
 128
 129         ref_ne($copy->{$key}, $artist->{$key}, "Simple row internals cloned '$key'")
 130           if ref $artist->{$key};
 131
 132         is_deeply($copy->{$key}, $artist->{$key},
 133                   qq[serialize with related_resultset '$key']);
 134     }
 135
 136     lives_ok(
 137       sub { $copy->discard_changes }, "Discard changes works: $name"
 138     ) or diag $@;
 139     is($copy->id, $artist->id, "IDs still match ");
 140
 141
 142     # Test resultsource with cached rows
 143     my $query_count;
 144     $cd_rs = $cd_rs->search ({}, { cache => 1 });
 145
 146     my $orig_debug = $schema->storage->debug;
 147     $schema->storage->debug(1);
 148     $schema->storage->debugcb(sub { $query_count++ } );
 149
 150     # this will hit the database once and prime the cache
 151     my @cds = $cd_rs->all;
 152
 153     lives_ok {
 154       $copy = $store->($cd_rs);
 155       ref_ne($copy, $cd_rs, 'Cached resultset cloned');
 156       is_deeply (
 157         [ $copy->all ],
 158         [ $cd_rs->all ],
 159         "serialize cached resultset works: $name",
 160       );
 161
 162       is ($copy->count, $cd_rs->count, 'Cached count identical');
 163     } "serialize cached resultset lives: $name";
 164
 165     is ($query_count, 1, 'Only one db query fired');
 166
 167     $schema->storage->debug($orig_debug);
 168     $schema->storage->debugcb(undef);
 169 }
 170
 171 # test schema-less detached thaw
 172 {
 173   my $artist = $schema->resultset('Artist')->find(1);
 174
 175   $artist = dclone $artist;
 176
 177   is( $artist->name, 'Caterwauler McCrae', 'getting column works' );
 178
 179   ok( $artist->update, 'Non-dirty update noop' );
 180
 181   ok( $artist->name( 'Beeeeeeees' ), 'setting works' );
 182
 183   ok( $artist->is_column_changed( 'name' ), 'Column dirtyness works' );
 184   ok( $artist->is_changed, 'object dirtyness works' );
 185
 186   my $rs = $artist->result_source->resultset;
 187   $rs->set_cache([ $artist ]);
 188
 189   is( $rs->count, 1, 'Synthetic resultset count works' );
 190
 191   my $exc = qr/Unable to perform storage-dependent operations with a detached result source.+use \$schema->thaw/;
 192
 193   throws_ok { $artist->update }
 194     $exc,
 195     'Correct exception on row op'
 196   ;
 197
 198   throws_ok { $artist->discard_changes }
 199     $exc,
 200     'Correct exception on row op'
 201   ;
 202
 203   throws_ok { $rs->find(1) }
 204     $exc,
 205     'Correct exception on rs op'
 206   ;
 207 }
 208
 209 done_testing;