t/030_with_checksum.t

   1 #!/usr/bin/perl
   2
   3 use strict;
   4 use warnings;
   5
   6 use Test::More;
   7 use Test::Exception;
   8 use Test::Deep;
   9
  10 BEGIN {
  11     eval "use Digest; use Digest::SHA1";
  12     plan skip_all => "Digest and Digest::SHA1 is required for this test" if $@;
  13     eval "use JSON::Any";
  14     plan skip_all => "JSON::Any is required for this test" if $@;
  15     plan tests => 26;
  16     use_ok('MooseX::Storage');
  17 }
  18
  19 {
  20
  21     package Foo;
  22     use Moose;
  23     use MooseX::Storage;
  24
  25     with Storage(base => 'WithChecksum', format => "JSON");
  26
  27     has 'number' => ( is => 'ro', isa => 'Int' );
  28     has 'string' => ( is => 'ro', isa => 'Str' );
  29     has 'float'  => ( is => 'ro', isa => 'Num' );
  30     has 'array'  => ( is => 'ro', isa => 'ArrayRef' );
  31     has 'hash'   => ( is => 'ro', isa => 'HashRef' );
  32     has 'object' => ( is => 'ro', isa => 'Foo' );
  33 }
  34
  35 {
  36     my $foo = Foo->new(
  37         number => 10,
  38         string => 'foo',
  39         float  => 10.5,
  40         array  => [ 1 .. 10 ],
  41         hash   => { map { $_ => undef } ( 1 .. 10 ) },
  42         object => Foo->new( number => 2 ),
  43     );
  44     isa_ok( $foo, 'Foo' );
  45
  46     my $packed = $foo->pack;
  47
  48     cmp_deeply(
  49         $packed,
  50         {
  51             __CLASS__ => 'Foo',
  52             __DIGEST__  => re('[0-9a-f]+'),
  53             number    => 10,
  54             string    => 'foo',
  55             float     => 10.5,
  56             array     => [ 1 .. 10 ],
  57             hash      => { map { $_ => undef } ( 1 .. 10 ) },
  58             object    => {
  59                             __CLASS__ => 'Foo',
  60                             __DIGEST__  => re('[0-9a-f]+'),
  61                             number    => 2
  62                          },
  63         },
  64         '... got the right frozen class'
  65     );
  66
  67     my $foo2;
  68     lives_ok {
  69         $foo2 = Foo->unpack($packed);
  70     } '... unpacked okay';
  71     isa_ok($foo2, 'Foo');
  72
  73     cmp_deeply(
  74         $foo2->pack,
  75         {
  76             __CLASS__ => 'Foo',
  77             __DIGEST__  => re('[0-9a-f]+'),
  78             number    => 10,
  79             string    => 'foo',
  80             float     => 10.5,
  81             array     => [ 1 .. 10 ],
  82             hash      => { map { $_ => undef } ( 1 .. 10 ) },
  83             object    => {
  84                             __CLASS__ => 'Foo',
  85                             __DIGEST__  => re('[0-9a-f]+'),
  86                             number    => 2
  87                          },
  88         },
  89         '... got the right frozen class'
  90     );
  91 }
  92
  93 {
  94     my $foo = Foo->new(
  95         number => 10,
  96         string => 'foo',
  97         float  => 10.5,
  98         array  => [ 1 .. 10 ],
  99         hash   => { map { $_ => undef } ( 1 .. 10 ) },
 100         object => Foo->new( number => 2 ),
 101     );
 102     isa_ok( $foo, 'Foo' );
 103
 104     my $frozen = $foo->freeze;
 105
 106     ok( length($frozen), "got frozen data" );
 107
 108     $frozen =~ s/foo/bar/;
 109
 110     my $foo2 = eval { Foo->thaw( $frozen ) };
 111     my $e = $@;
 112
 113     ok( !$foo2, "not thawed" );
 114     ok( $e, "has error" );
 115     like( $e, qr/bad checksum/i, "bad checksum error" );
 116 }
 117
 118 SKIP: {
 119     eval { require Digest::HMAC_SHA1 };
 120     skip join( " ", "no Digest::HMAC", ( $@ =~ /\@INC/ ? () : do { chomp(my $e = $@); "($e)" } ) ), 15 if $@;
 121
 122     local $::DEBUG = 1;
 123
 124     my $foo = Foo->new(
 125         number => 10,
 126         string => 'foo',
 127         float  => 10.5,
 128         array  => [ 1 .. 10 ],
 129         hash   => { map { $_ => undef } ( 1 .. 10 ) },
 130         object => Foo->new( number => 2 ),
 131     );
 132     isa_ok( $foo, 'Foo' );
 133
 134     my $frozen1 = $foo->freeze( digest => [ "HMAC_SHA1", "secret" ] );
 135     ok( length($frozen1), "got frozen data" );
 136
 137     $::DEBUG = 0;
 138
 139     my $d2 = Digest::HMAC_SHA1->new("s3cr3t");
 140
 141     my $frozen2 = $foo->freeze( digest => $d2 );
 142     ok( length($frozen2), "got frozen data" );
 143
 144     cmp_ok( $frozen1, "ne", $frozen2, "versions are different" );
 145
 146     is( $frozen1, $foo->freeze( digest => [ HMAC_SHA1 => "secret" ] ), "refreeze" );
 147
 148 $::DEBUG = 1;
 149
 150     my $foo1 = eval { Foo->thaw( $frozen1, digest => [ "HMAC_SHA1", "secret" ] ) };
 151     my $e = $@;
 152
 153     ok( $foo1, "thawed" );
 154     ok( !$e, "no error" ) || diag $e;
 155
 156     my $foo2 = eval { Foo->thaw( $frozen2, digest => $d2 ) };
 157     $e = $@;
 158
 159     ok( $foo2, "thawed" );
 160     ok( !$e, "no error" ) || diag $e;
 161
 162     $foo1 = eval { Foo->thaw( $frozen1, digest => $d2 ) };
 163     $e = $@;
 164
 165     ok( !$foo1, "not thawed" );
 166     ok( $e, "has error" );
 167     like( $e, qr/bad checksum/i, "bad checksum error" );
 168
 169     $frozen1 =~ s/foo/bar/;
 170
 171     $foo1 = eval { Foo->thaw( $frozen1, digest => [ "HMAC_SHA1", "secret" ] ) };
 172     $e = $@;
 173
 174     ok( !$foo1, "not thawed" );
 175     ok( $e, "has error" );
 176     like( $e, qr/bad checksum/i, "bad checksum error" );
 177 }