t/84serialize.t

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