t/storage/replicated.t

   1 use strict;
   2 use warnings;
   3
   4 use Test::More;
   5
   6 use lib qw(t/lib);
   7 use DBICTest;
   8
   9 BEGIN {
  10     require DBIx::Class;
  11     plan skip_all => 'Test needs ' . DBIx::Class::Optional::Dependencies->req_missing_for ('test_replicated')
  12       unless DBIx::Class::Optional::Dependencies->req_ok_for ('test_replicated');
  13
  14     if (DBICTest::RunMode->is_smoker) {
  15       my $mver = Moose->VERSION;
  16       plan skip_all => "A trial version $mver of Moose detected known to break replication - skipping test known to fail"
  17         if ($mver >= 1.99 and $mver <= 1.9902);
  18     }
  19
  20 }
  21
  22 use Test::Moose;
  23 use Test::Exception;
  24 use List::Util 'first';
  25 use Scalar::Util 'reftype';
  26 use File::Spec;
  27 use Moose();
  28 use MooseX::Types();
  29 note "Using Moose version $Moose::VERSION and MooseX::Types version $MooseX::Types::VERSION";
  30
  31 my $var_dir = quotemeta ( File::Spec->catdir(qw/t var/) );
  32
  33 ## Add a connect_info option to test option merging.
  34 use DBIx::Class::Storage::DBI::Replicated;
  35 {
  36     package DBIx::Class::Storage::DBI::Replicated;
  37
  38     use Moose;
  39
  40     __PACKAGE__->meta->make_mutable;
  41
  42     around connect_info => sub {
  43       my ($next, $self, $info) = @_;
  44       $info->[3]{master_option} = 1;
  45       $self->$next($info);
  46     };
  47
  48     __PACKAGE__->meta->make_immutable;
  49
  50     no Moose;
  51 }
  52
  53
  54
  55 =head1 HOW TO USE
  56
  57     This is a test of the replicated storage system.  This will work in one of
  58     two ways, either it was try to fake replication with a couple of SQLite DBs
  59     and creative use of copy, or if you define a couple of %ENV vars correctly
  60     will try to test those.  If you do that, it will assume the setup is properly
  61     replicating.  Your results may vary, but I have demonstrated this to work with
  62     mysql native replication.
  63
  64 =cut
  65
  66
  67 ## ----------------------------------------------------------------------------
  68 ## Build a class to hold all our required testing data and methods.
  69 ## ----------------------------------------------------------------------------
  70
  71 TESTSCHEMACLASSES: {
  72
  73     ## --------------------------------------------------------------------- ##
  74     ## Create an object to contain your replicated stuff.
  75     ## --------------------------------------------------------------------- ##
  76
  77     package DBIx::Class::DBI::Replicated::TestReplication;
  78
  79     use DBICTest;
  80     use base qw/Class::Accessor::Fast/;
  81
  82     __PACKAGE__->mk_accessors( qw/schema/ );
  83
  84     ## Initialize the object
  85
  86     sub new {
  87         my ($class, $schema_method) = (shift, shift);
  88         my $self = $class->SUPER::new(@_);
  89
  90         $self->schema( $self->init_schema($schema_method) );
  91         return $self;
  92     }
  93
  94     ## Get the Schema and set the replication storage type
  95
  96     sub init_schema {
  97         #my ($class, $schema_getter) = @_;
  98         shift->${\ ( 'get_schema_' . shift ) };
  99     }
 100
 101     sub get_schema_by_storage_type {
 102       DBICTest->init_schema(
 103         sqlite_use_file => 1,
 104         storage_type=>{
 105           '::DBI::Replicated' => {
 106             balancer_type=>'::Random',
 107             balancer_args=>{
 108               auto_validate_every=>100,
 109               master_read_weight => 1
 110             },
 111           }
 112         },
 113         deploy_args=>{
 114           add_drop_table => 1,
 115         },
 116       );
 117     }
 118
 119     sub get_schema_by_connect_info {
 120       DBICTest->init_schema(
 121         sqlite_use_file => 1,
 122         storage_type=> '::DBI::Replicated',
 123         balancer_type=>'::Random',
 124         balancer_args=> {
 125             auto_validate_every=>100,
 126             master_read_weight => 1
 127         },
 128         pool_args=>{
 129             maximum_lag=>1,
 130         },
 131         deploy_args=>{
 132           add_drop_table => 1,
 133         },
 134       );
 135     }
 136
 137     sub generate_replicant_connect_info {}
 138     sub replicate {}
 139     sub cleanup {}
 140
 141     ## --------------------------------------------------------------------- ##
 142     ## Subclass for when you are using SQLite for testing, this provides a fake
 143     ## replication support.
 144     ## --------------------------------------------------------------------- ##
 145
 146     package DBIx::Class::DBI::Replicated::TestReplication::SQLite;
 147
 148     use DBICTest;
 149     use File::Copy;
 150     use base 'DBIx::Class::DBI::Replicated::TestReplication';
 151
 152     __PACKAGE__->mk_accessors(qw/master_path slave_paths/);
 153
 154     ## Set the master path from DBICTest
 155
 156     sub new {
 157         my $class = shift @_;
 158         my $self = $class->SUPER::new(@_);
 159
 160         $self->master_path( DBICTest->_sqlite_dbfilename );
 161         $self->slave_paths([
 162             File::Spec->catfile(qw/t var DBIxClass_slave1.db/),
 163             File::Spec->catfile(qw/t var DBIxClass_slave2.db/),
 164         ]);
 165
 166         return $self;
 167     }
 168
 169     ## Return an Array of ArrayRefs where each ArrayRef is suitable to use for
 170     ## $storage->connect_info to be used for connecting replicants.
 171
 172     sub generate_replicant_connect_info {
 173         my $self = shift @_;
 174         my @dsn = map {
 175             "dbi:SQLite:${_}";
 176         } @{$self->slave_paths};
 177
 178         my @connect_infos = map { [$_,'','',{AutoCommit=>1}] } @dsn;
 179
 180         ## Make sure nothing is left over from a failed test
 181         $self->cleanup;
 182
 183         ## try a hashref too
 184         my $c = $connect_infos[0];
 185         $connect_infos[0] = {
 186           dsn => $c->[0],
 187           user => $c->[1],
 188           password => $c->[2],
 189           %{ $c->[3] }
 190         };
 191
 192         @connect_infos
 193     }
 194
 195     ## Do a 'good enough' replication by copying the master dbfile over each of
 196     ## the slave dbfiles.  If the master is SQLite we do this, otherwise we
 197     ## just do a one second pause to let the slaves catch up.
 198
 199     sub replicate {
 200         my $self = shift @_;
 201         foreach my $slave (@{$self->slave_paths}) {
 202             copy($self->master_path, $slave);
 203         }
 204     }
 205
 206     ## Cleanup after ourselves. Unlink all the slave paths.
 207
 208     sub cleanup {
 209         my $self = shift @_;
 210         $_->disconnect for values %{ $self->schema->storage->replicants };
 211         foreach my $slave (@{$self->slave_paths}) {
 212             if(-e $slave) {
 213                 unlink $slave;
 214             }
 215         }
 216     }
 217
 218     ## --------------------------------------------------------------------- ##
 219     ## Subclass for when you are setting the databases via custom export vars
 220     ## This is for when you have a replicating database setup that you are
 221     ## going to test against.  You'll need to define the correct $ENV and have
 222     ## two slave databases to test against, as well as a replication system
 223     ## that will replicate in less than 1 second.
 224     ## --------------------------------------------------------------------- ##
 225
 226     package DBIx::Class::DBI::Replicated::TestReplication::Custom;
 227     use base 'DBIx::Class::DBI::Replicated::TestReplication';
 228
 229     ## Return an Array of ArrayRefs where each ArrayRef is suitable to use for
 230     ## $storage->connect_info to be used for connecting replicants.
 231
 232     sub generate_replicant_connect_info {
 233         return (
 234             [$ENV{"DBICTEST_SLAVE0_DSN"}, $ENV{"DBICTEST_SLAVE0_DBUSER"}, $ENV{"DBICTEST_SLAVE0_DBPASS"}, {AutoCommit => 1}],
 235             [$ENV{"DBICTEST_SLAVE1_DSN"}, $ENV{"DBICTEST_SLAVE1_DBUSER"}, $ENV{"DBICTEST_SLAVE1_DBPASS"}, {AutoCommit => 1}],
 236         );
 237     }
 238
 239     ## pause a bit to let the replication catch up
 240
 241     sub replicate {
 242         sleep 1;
 243     }
 244 }
 245
 246 ## ----------------------------------------------------------------------------
 247 ## Create an object and run some tests
 248 ## ----------------------------------------------------------------------------
 249
 250 ## Thi first bunch of tests are basic, just make sure all the bits are behaving
 251
 252 my $replicated_class = DBICTest->has_custom_dsn ?
 253     'DBIx::Class::DBI::Replicated::TestReplication::Custom' :
 254     'DBIx::Class::DBI::Replicated::TestReplication::SQLite';
 255
 256 my $replicated;
 257
 258 for my $method (qw/by_connect_info by_storage_type/) {
 259   undef $replicated;
 260   ok $replicated = $replicated_class->new($method)
 261       => "Created a replication object $method";
 262
 263   isa_ok $replicated->schema
 264       => 'DBIx::Class::Schema';
 265
 266   isa_ok $replicated->schema->storage
 267       => 'DBIx::Class::Storage::DBI::Replicated';
 268
 269   isa_ok $replicated->schema->storage->balancer
 270       => 'DBIx::Class::Storage::DBI::Replicated::Balancer::Random'
 271       => 'configured balancer_type';
 272 }
 273
 274 ### check that all Storage::DBI methods are handled by ::Replicated
 275 {
 276   my @storage_dbi_methods = Class::MOP::Class
 277     ->initialize('DBIx::Class::Storage::DBI')->get_all_method_names;
 278
 279   my @replicated_methods  = DBIx::Class::Storage::DBI::Replicated->meta
 280     ->get_all_method_names;
 281
 282 # remove constants and OTHER_CRAP
 283   @storage_dbi_methods = grep !/^[A-Z_]+\z/, @storage_dbi_methods;
 284
 285 # remove CAG accessors
 286   @storage_dbi_methods = grep !/_accessor\z/, @storage_dbi_methods;
 287
 288 # remove DBIx::Class (the root parent, with CAG and stuff) methods
 289   my @root_methods = Class::MOP::Class->initialize('DBIx::Class')
 290     ->get_all_method_names;
 291   my %count;
 292   $count{$_}++ for (@storage_dbi_methods, @root_methods);
 293
 294   @storage_dbi_methods = grep $count{$_} != 2, @storage_dbi_methods;
 295
 296 # make hashes
 297   my %storage_dbi_methods;
 298   @storage_dbi_methods{@storage_dbi_methods} = ();
 299   my %replicated_methods;
 300   @replicated_methods{@replicated_methods} = ();
 301
 302 # remove ::Replicated-specific methods
 303   for my $method (@replicated_methods) {
 304     delete $replicated_methods{$method}
 305       unless exists $storage_dbi_methods{$method};
 306   }
 307   @replicated_methods = keys %replicated_methods;
 308
 309 # check that what's left is implemented
 310   %count = ();
 311   $count{$_}++ for (@storage_dbi_methods, @replicated_methods);
 312
 313   if ((grep $count{$_} == 2, @storage_dbi_methods) == @storage_dbi_methods) {
 314     pass 'all DBIx::Class::Storage::DBI methods implemented';
 315   }
 316   else {
 317     my @unimplemented = grep $count{$_} == 1, @storage_dbi_methods;
 318
 319     fail 'the following DBIx::Class::Storage::DBI methods are unimplemented: '
 320       . "@unimplemented";
 321   }
 322 }
 323
 324 ok $replicated->schema->storage->meta
 325     => 'has a meta object';
 326
 327 isa_ok $replicated->schema->storage->master
 328     => 'DBIx::Class::Storage::DBI';
 329
 330 isa_ok $replicated->schema->storage->pool
 331     => 'DBIx::Class::Storage::DBI::Replicated::Pool';
 332
 333 does_ok $replicated->schema->storage->balancer
 334     => 'DBIx::Class::Storage::DBI::Replicated::Balancer';
 335
 336 ok my @replicant_connects = $replicated->generate_replicant_connect_info
 337     => 'got replication connect information';
 338
 339 ok my @replicated_storages = $replicated->schema->storage->connect_replicants(@replicant_connects)
 340     => 'Created some storages suitable for replicants';
 341
 342 our %debug;
 343 $replicated->schema->storage->debug(1);
 344 $replicated->schema->storage->debugcb(sub {
 345     my ($op, $info) = @_;
 346     ##warn "\n$op, $info\n";
 347     %debug = (
 348         op => $op,
 349         info => $info,
 350         dsn => ($info=~m/\[(.+)\]/)[0],
 351         storage_type => $info=~m/REPLICANT/ ? 'REPLICANT' : 'MASTER',
 352     );
 353 });
 354
 355 ok my @all_storages = $replicated->schema->storage->all_storages
 356     => '->all_storages';
 357
 358 is scalar @all_storages,
 359     3
 360     => 'correct number of ->all_storages';
 361
 362 is ((grep $_->isa('DBIx::Class::Storage::DBI'), @all_storages),
 363     3
 364     => '->all_storages are correct type');
 365
 366 my @all_storage_opts =
 367   grep { (reftype($_)||'') eq 'HASH' }
 368     map @{ $_->_connect_info }, @all_storages;
 369
 370 is ((grep $_->{master_option}, @all_storage_opts),
 371     3
 372     => 'connect_info was merged from master to replicants');
 373
 374 my @replicant_names = keys %{ $replicated->schema->storage->replicants };
 375
 376 ok @replicant_names, "found replicant names @replicant_names";
 377
 378 ## Silence warning about not supporting the is_replicating method if using the
 379 ## sqlite dbs.
 380 $replicated->schema->storage->debugobj->silence(1)
 381   if first { $_ =~ /$var_dir/ } @replicant_names;
 382
 383 isa_ok $replicated->schema->storage->balancer->current_replicant
 384     => 'DBIx::Class::Storage::DBI';
 385
 386 $replicated->schema->storage->debugobj->silence(0);
 387
 388 ok $replicated->schema->storage->pool->has_replicants
 389     => 'does have replicants';
 390
 391 is $replicated->schema->storage->pool->num_replicants => 2
 392     => 'has two replicants';
 393
 394 does_ok $replicated_storages[0]
 395     => 'DBIx::Class::Storage::DBI::Replicated::Replicant';
 396
 397 does_ok $replicated_storages[1]
 398     => 'DBIx::Class::Storage::DBI::Replicated::Replicant';
 399
 400 does_ok $replicated->schema->storage->replicants->{$replicant_names[0]}
 401     => 'DBIx::Class::Storage::DBI::Replicated::Replicant';
 402
 403 does_ok $replicated->schema->storage->replicants->{$replicant_names[1]}
 404     => 'DBIx::Class::Storage::DBI::Replicated::Replicant';
 405
 406 ## Add some info to the database
 407
 408 $replicated
 409     ->schema
 410     ->populate('Artist', [
 411         [ qw/artistid name/ ],
 412         [ 4, "Ozric Tentacles"],
 413     ]);
 414
 415     is $debug{storage_type}, 'MASTER',
 416         "got last query from a master: $debug{dsn}";
 417
 418     like $debug{info}, qr/INSERT/, 'Last was an insert';
 419
 420 ## Make sure all the slaves have the table definitions
 421
 422 $replicated->replicate;
 423 $replicated->schema->storage->replicants->{$replicant_names[0]}->active(1);
 424 $replicated->schema->storage->replicants->{$replicant_names[1]}->active(1);
 425
 426 ## Silence warning about not supporting the is_replicating method if using the
 427 ## sqlite dbs.
 428 $replicated->schema->storage->debugobj->silence(1)
 429   if first { $_ =~ /$var_dir/ } @replicant_names;
 430
 431 $replicated->schema->storage->pool->validate_replicants;
 432
 433 $replicated->schema->storage->debugobj->silence(0);
 434
 435 ## Make sure we can read the data.
 436
 437 ok my $artist1 = $replicated->schema->resultset('Artist')->find(4)
 438     => 'Created Result';
 439
 440 ## We removed testing here since master read weight is on, so we can't tell in
 441 ## advance what storage to expect.  We turn master read weight off a bit lower
 442 ## is $debug{storage_type}, 'REPLICANT'
 443 ##     => "got last query from a replicant: $debug{dsn}, $debug{info}";
 444
 445 isa_ok $artist1
 446     => 'DBICTest::Artist';
 447
 448 is $artist1->name, 'Ozric Tentacles'
 449     => 'Found expected name for first result';
 450
 451 ## Check that master_read_weight is honored
 452 {
 453     no warnings qw/once redefine/;
 454
 455     local
 456     *DBIx::Class::Storage::DBI::Replicated::Balancer::Random::_random_number =
 457     sub { 999 };
 458
 459     $replicated->schema->storage->balancer->increment_storage;
 460
 461     is $replicated->schema->storage->balancer->current_replicant,
 462        $replicated->schema->storage->master
 463        => 'master_read_weight is honored';
 464
 465     ## turn it off for the duration of the test
 466     $replicated->schema->storage->balancer->master_read_weight(0);
 467     $replicated->schema->storage->balancer->increment_storage;
 468 }
 469
 470 ## Add some new rows that only the master will have  This is because
 471 ## we overload any type of write operation so that is must hit the master
 472 ## database.
 473
 474 $replicated
 475     ->schema
 476     ->populate('Artist', [
 477         [ qw/artistid name/ ],
 478         [ 5, "Doom's Children"],
 479         [ 6, "Dead On Arrival"],
 480         [ 7, "Watergate"],
 481     ]);
 482
 483     is $debug{storage_type}, 'MASTER',
 484         "got last query from a master: $debug{dsn}";
 485
 486     like $debug{info}, qr/INSERT/, 'Last was an insert';
 487
 488 ## Make sure all the slaves have the table definitions
 489 $replicated->replicate;
 490
 491 ## Should find some data now
 492
 493 ok my $artist2 = $replicated->schema->resultset('Artist')->find(5)
 494     => 'Sync succeed';
 495
 496 is $debug{storage_type}, 'REPLICANT'
 497     => "got last query from a replicant: $debug{dsn}";
 498
 499 isa_ok $artist2
 500     => 'DBICTest::Artist';
 501
 502 is $artist2->name, "Doom's Children"
 503     => 'Found expected name for first result';
 504
 505 ## What happens when we disconnect all the replicants?
 506
 507 is $replicated->schema->storage->pool->connected_replicants => 2
 508     => "both replicants are connected";
 509
 510 $replicated->schema->storage->replicants->{$replicant_names[0]}->disconnect;
 511 $replicated->schema->storage->replicants->{$replicant_names[1]}->disconnect;
 512
 513 is $replicated->schema->storage->pool->connected_replicants => 0
 514     => "both replicants are now disconnected";
 515
 516 ## All these should pass, since the database should automatically reconnect
 517
 518 ok my $artist3 = $replicated->schema->resultset('Artist')->find(6)
 519     => 'Still finding stuff.';
 520
 521 is $debug{storage_type}, 'REPLICANT'
 522     => "got last query from a replicant: $debug{dsn}";
 523
 524 isa_ok $artist3
 525     => 'DBICTest::Artist';
 526
 527 is $artist3->name, "Dead On Arrival"
 528     => 'Found expected name for first result';
 529
 530 is $replicated->schema->storage->pool->connected_replicants => 1
 531     => "At Least One replicant reconnected to handle the job";
 532
 533 ## What happens when we try to select something that doesn't exist?
 534
 535 ok ! $replicated->schema->resultset('Artist')->find(666)
 536     => 'Correctly failed to find something.';
 537
 538 is $debug{storage_type}, 'REPLICANT'
 539     => "got last query from a replicant: $debug{dsn}";
 540
 541 ## test the reliable option
 542
 543 TESTRELIABLE: {
 544
 545     $replicated->schema->storage->set_reliable_storage;
 546
 547     ok $replicated->schema->resultset('Artist')->find(2)
 548         => 'Read from master 1';
 549
 550     is $debug{storage_type}, 'MASTER',
 551         "got last query from a master: $debug{dsn}";
 552
 553     ok $replicated->schema->resultset('Artist')->find(5)
 554         => 'Read from master 2';
 555
 556     is $debug{storage_type}, 'MASTER',
 557         "got last query from a master: $debug{dsn}";
 558
 559     $replicated->schema->storage->set_balanced_storage;
 560
 561     ok $replicated->schema->resultset('Artist')->find(3)
 562         => 'Read from replicant';
 563
 564     is $debug{storage_type}, 'REPLICANT',
 565         "got last query from a replicant: $debug{dsn}";
 566 }
 567
 568 ## Make sure when reliable goes out of scope, we are using replicants again
 569
 570 ok $replicated->schema->resultset('Artist')->find(1)
 571     => 'back to replicant 1.';
 572
 573     is $debug{storage_type}, 'REPLICANT',
 574         "got last query from a replicant: $debug{dsn}";
 575
 576 ok $replicated->schema->resultset('Artist')->find(2)
 577     => 'back to replicant 2.';
 578
 579     is $debug{storage_type}, 'REPLICANT',
 580         "got last query from a replicant: $debug{dsn}";
 581
 582 ## set all the replicants to inactive, and make sure the balancer falls back to
 583 ## the master.
 584
 585 $replicated->schema->storage->replicants->{$replicant_names[0]}->active(0);
 586 $replicated->schema->storage->replicants->{$replicant_names[1]}->active(0);
 587
 588 {
 589     ## catch the fallback to master warning
 590     open my $debugfh, '>', \my $fallback_warning;
 591     my $oldfh = $replicated->schema->storage->debugfh;
 592     $replicated->schema->storage->debugfh($debugfh);
 593
 594     ok $replicated->schema->resultset('Artist')->find(2)
 595         => 'Fallback to master';
 596
 597     is $debug{storage_type}, 'MASTER',
 598         "got last query from a master: $debug{dsn}";
 599
 600     like $fallback_warning, qr/falling back to master/
 601         => 'emits falling back to master debug';
 602
 603     $replicated->schema->storage->debugfh($oldfh);
 604 }
 605
 606 $replicated->schema->storage->replicants->{$replicant_names[0]}->active(1);
 607 $replicated->schema->storage->replicants->{$replicant_names[1]}->active(1);
 608
 609 ## Silence warning about not supporting the is_replicating method if using the
 610 ## sqlite dbs.
 611 $replicated->schema->storage->debugobj->silence(1)
 612   if first { $_ =~ /$var_dir/ } @replicant_names;
 613
 614 $replicated->schema->storage->pool->validate_replicants;
 615
 616 $replicated->schema->storage->debugobj->silence(0);
 617
 618 {
 619     ## catch the fallback to master warning
 620     open my $debugfh, '>', \my $return_warning;
 621     my $oldfh = $replicated->schema->storage->debugfh;
 622     $replicated->schema->storage->debugfh($debugfh);
 623
 624     ok $replicated->schema->resultset('Artist')->find(2)
 625         => 'Return to replicants';
 626
 627     is $debug{storage_type}, 'REPLICANT',
 628       "got last query from a replicant: $debug{dsn}";
 629
 630     like $return_warning, qr/Moved back to slave/
 631         => 'emits returning to slave debug';
 632
 633     $replicated->schema->storage->debugfh($oldfh);
 634 }
 635
 636 ## Getting slave status tests
 637
 638 SKIP: {
 639     ## We skip this tests unless you have a custom replicants, since the default
 640     ## sqlite based replication tests don't support these functions.
 641
 642     skip 'Cannot Test Replicant Status on Non Replicating Database', 10
 643      unless DBICTest->has_custom_dsn && $ENV{"DBICTEST_SLAVE0_DSN"};
 644
 645     $replicated->replicate; ## Give the slaves a chance to catchup.
 646
 647     ok $replicated->schema->storage->replicants->{$replicant_names[0]}->is_replicating
 648         => 'Replicants are replicating';
 649
 650     is $replicated->schema->storage->replicants->{$replicant_names[0]}->lag_behind_master, 0
 651         => 'Replicant is zero seconds behind master';
 652
 653     ## Test the validate replicants
 654
 655     $replicated->schema->storage->pool->validate_replicants;
 656
 657     is $replicated->schema->storage->pool->active_replicants, 2
 658         => 'Still have 2 replicants after validation';
 659
 660     ## Force the replicants to fail the validate test by required their lag to
 661     ## be negative (ie ahead of the master!)
 662
 663     $replicated->schema->storage->pool->maximum_lag(-10);
 664     $replicated->schema->storage->pool->validate_replicants;
 665
 666     is $replicated->schema->storage->pool->active_replicants, 0
 667         => 'No way a replicant be be ahead of the master';
 668
 669     ## Let's be fair to the replicants again.  Let them lag up to 5
 670
 671     $replicated->schema->storage->pool->maximum_lag(5);
 672     $replicated->schema->storage->pool->validate_replicants;
 673
 674     is $replicated->schema->storage->pool->active_replicants, 2
 675         => 'Both replicants in good standing again';
 676
 677     ## Check auto validate
 678
 679     is $replicated->schema->storage->balancer->auto_validate_every, 100
 680         => "Got the expected value for auto validate";
 681
 682         ## This will make sure we auto validatge everytime
 683         $replicated->schema->storage->balancer->auto_validate_every(0);
 684
 685         ## set all the replicants to inactive, and make sure the balancer falls back to
 686         ## the master.
 687
 688         $replicated->schema->storage->replicants->{$replicant_names[0]}->active(0);
 689         $replicated->schema->storage->replicants->{$replicant_names[1]}->active(0);
 690
 691         ## Ok, now when we go to run a query, autovalidate SHOULD reconnect
 692
 693     is $replicated->schema->storage->pool->active_replicants => 0
 694         => "both replicants turned off";
 695
 696     ok $replicated->schema->resultset('Artist')->find(5)
 697         => 'replicant reactivated';
 698
 699     is $debug{storage_type}, 'REPLICANT',
 700         "got last query from a replicant: $debug{dsn}";
 701
 702     is $replicated->schema->storage->pool->active_replicants => 2
 703         => "both replicants reactivated";
 704 }
 705
 706 ## Test the reliably callback
 707
 708 ok my $reliably = sub {
 709
 710     ok $replicated->schema->resultset('Artist')->find(5)
 711         => 'replicant reactivated';
 712
 713     is $debug{storage_type}, 'MASTER',
 714         "got last query from a master: $debug{dsn}";
 715
 716 } => 'created coderef properly';
 717
 718 $replicated->schema->storage->execute_reliably($reliably);
 719
 720 ## Try something with an error
 721
 722 ok my $unreliably = sub {
 723
 724     ok $replicated->schema->resultset('ArtistXX')->find(5)
 725         => 'replicant reactivated';
 726
 727 } => 'created coderef properly';
 728
 729 throws_ok {$replicated->schema->storage->execute_reliably($unreliably)}
 730     qr/Can't find source for ArtistXX/
 731     => 'Bad coderef throws proper error';
 732
 733 ## Make sure replication came back
 734
 735 ok $replicated->schema->resultset('Artist')->find(3)
 736     => 'replicant reactivated';
 737
 738 is $debug{storage_type}, 'REPLICANT', "got last query from a replicant: $debug{dsn}";
 739
 740 ## make sure transactions are set to execute_reliably
 741
 742 ok my $transaction = sub {
 743
 744     my $id = shift @_;
 745
 746     $replicated
 747         ->schema
 748         ->populate('Artist', [
 749             [ qw/artistid name/ ],
 750             [ $id, "Children of the Grave $id"],
 751         ]);
 752
 753     ok my $result = $replicated->schema->resultset('Artist')->find($id)
 754         => "Found expected artist for $id";
 755
 756     is $debug{storage_type}, 'MASTER',
 757         "got last query from a master: $debug{dsn}";
 758
 759     ok my $more = $replicated->schema->resultset('Artist')->find(1)
 760         => 'Found expected artist again for 1';
 761
 762     is $debug{storage_type}, 'MASTER',
 763         "got last query from a master: $debug{dsn}";
 764
 765    return ($result, $more);
 766
 767 } => 'Created a coderef properly';
 768
 769 ## Test the transaction with multi return
 770 {
 771     ok my @return = $replicated->schema->txn_do($transaction, 666)
 772         => 'did transaction';
 773
 774         is $return[0]->id, 666
 775             => 'first returned value is correct';
 776
 777         is $debug{storage_type}, 'MASTER',
 778             "got last query from a master: $debug{dsn}";
 779
 780         is $return[1]->id, 1
 781             => 'second returned value is correct';
 782
 783         is $debug{storage_type}, 'MASTER',
 784              "got last query from a master: $debug{dsn}";
 785
 786 }
 787
 788 ## Test that asking for single return works
 789 {
 790     ok my @return = $replicated->schema->txn_do($transaction, 777)
 791         => 'did transaction';
 792
 793         is $return[0]->id, 777
 794             => 'first returned value is correct';
 795
 796         is $return[1]->id, 1
 797             => 'second returned value is correct';
 798 }
 799
 800 ## Test transaction returning a single value
 801
 802 {
 803     ok my $result = $replicated->schema->txn_do(sub {
 804         ok my $more = $replicated->schema->resultset('Artist')->find(1)
 805         => 'found inside a transaction';
 806         is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}";
 807         return $more;
 808     }) => 'successfully processed transaction';
 809
 810     is $result->id, 1
 811        => 'Got expected single result from transaction';
 812 }
 813
 814 ## Make sure replication came back
 815
 816 ok $replicated->schema->resultset('Artist')->find(1)
 817     => 'replicant reactivated';
 818
 819 is $debug{storage_type}, 'REPLICANT', "got last query from a replicant: $debug{dsn}";
 820
 821 ## Test Discard changes
 822
 823 {
 824     ok my $artist = $replicated->schema->resultset('Artist')->find(2)
 825         => 'got an artist to test discard changes';
 826
 827     is $debug{storage_type}, 'REPLICANT', "got last query from a replicant: $debug{dsn}";
 828
 829     ok $artist->get_from_storage({force_pool=>'master'})
 830        => 'properly discard changes';
 831
 832     is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}";
 833
 834     ok $artist->discard_changes({force_pool=>'master'})
 835        => 'properly called discard_changes against master (manual attrs)';
 836
 837     is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}";
 838
 839     ok $artist->discard_changes()
 840        => 'properly called discard_changes against master (default attrs)';
 841
 842     is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}";
 843
 844     ok $artist->discard_changes({force_pool=>$replicant_names[0]})
 845        => 'properly able to override the default attributes';
 846
 847     is $debug{storage_type}, 'REPLICANT', "got last query from a replicant: $debug{dsn}"
 848 }
 849
 850 ## Test some edge cases, like trying to do a transaction inside a transaction, etc
 851
 852 {
 853     ok my $result = $replicated->schema->txn_do(sub {
 854         return $replicated->schema->txn_do(sub {
 855             ok my $more = $replicated->schema->resultset('Artist')->find(1)
 856             => 'found inside a transaction inside a transaction';
 857             is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}";
 858             return $more;
 859         });
 860     }) => 'successfully processed transaction';
 861
 862     is $result->id, 1
 863        => 'Got expected single result from transaction';
 864 }
 865
 866 {
 867     ok my $result = $replicated->schema->txn_do(sub {
 868         return $replicated->schema->storage->execute_reliably(sub {
 869             return $replicated->schema->txn_do(sub {
 870                 return $replicated->schema->storage->execute_reliably(sub {
 871                     ok my $more = $replicated->schema->resultset('Artist')->find(1)
 872                       => 'found inside crazy deep transactions and execute_reliably';
 873                     is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}";
 874                     return $more;
 875                 });
 876             });
 877         });
 878     }) => 'successfully processed transaction';
 879
 880     is $result->id, 1
 881        => 'Got expected single result from transaction';
 882 }
 883
 884 ## Test the force_pool resultset attribute.
 885
 886 {
 887     ok my $artist_rs = $replicated->schema->resultset('Artist')
 888         => 'got artist resultset';
 889
 890     ## Turn on Forced Pool Storage
 891     ok my $reliable_artist_rs = $artist_rs->search(undef, {force_pool=>'master'})
 892         => 'Created a resultset using force_pool storage';
 893
 894     ok my $artist = $reliable_artist_rs->find(2)
 895         => 'got an artist result via force_pool storage';
 896
 897     is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}";
 898 }
 899
 900 ## Test the force_pool resultset attribute part two.
 901
 902 {
 903     ok my $artist_rs = $replicated->schema->resultset('Artist')
 904         => 'got artist resultset';
 905
 906     ## Turn on Forced Pool Storage
 907     ok my $reliable_artist_rs = $artist_rs->search(undef, {force_pool=>$replicant_names[0]})
 908         => 'Created a resultset using force_pool storage';
 909
 910     ok my $artist = $reliable_artist_rs->find(2)
 911         => 'got an artist result via force_pool storage';
 912
 913     is $debug{storage_type}, 'REPLICANT', "got last query from a replicant: $debug{dsn}";
 914 }
 915
 916 ## Delete the old database files
 917 $replicated->cleanup;
 918
 919 done_testing;
 920
 921 # vim: sw=4 sts=4 :