X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=t%2F93storage_replication.t;h=1c0c7df122194fde551561515b2445cb9c9cf071;hb=071bbccba2ec162da1a78069dc6f8fa371788895;hp=422a44517421ed1e6ea85e8b7f568a84fa656454;hpb=9901aad73ff9dc45b426534fe406c102fb9fb77c;p=dbsrgits%2FDBIx-Class.git diff --git a/t/93storage_replication.t b/t/93storage_replication.t index 422a445..1c0c7df 100644 --- a/t/93storage_replication.t +++ b/t/93storage_replication.t @@ -5,12 +5,14 @@ use Test::More; use Test::Exception; use DBICTest; use List::Util 'first'; +use Scalar::Util 'reftype'; +use IO::Handle; BEGIN { eval "use DBIx::Class::Storage::DBI::Replicated; use Test::Moose"; plan $@ ? ( skip_all => "Deps not installed: $@" ) - : ( tests => 79 ); + : ( tests => 125 ); } use_ok 'DBIx::Class::Storage::DBI::Replicated::Pool'; @@ -50,10 +52,10 @@ TESTSCHEMACLASSES: { ## Initialize the object sub new { - my $class = shift @_; + my ($class, $schema_method) = (shift, shift); my $self = $class->SUPER::new(@_); - $self->schema( $self->init_schema ); + $self->schema( $self->init_schema($schema_method) ); return $self; } @@ -63,30 +65,71 @@ TESTSCHEMACLASSES: { # current SQLT SQLite producer does not handle DROP TABLE IF EXISTS, trap warnings here local $SIG{__WARN__} = sub { warn @_ unless $_[0] =~ /no such table.+DROP TABLE/ }; - my $class = shift @_; - - my $schema = DBICTest->init_schema( - sqlite_use_file => 1, - storage_type=>{ - '::DBI::Replicated' => { - balancer_type=>'::Random', - balancer_args=>{ - auto_validate_every=>100, - }, - } - }, - deploy_args=>{ - add_drop_table => 1, - }, - ); + my ($class, $schema_method) = @_; + + my $method = "get_schema_$schema_method"; + my $schema = $class->$method; return $schema; } - + + sub get_schema_by_storage_type { + DBICTest->init_schema( + sqlite_use_file => 1, + storage_type=>{ + '::DBI::Replicated' => { + balancer_type=>'::Random', + balancer_args=>{ + auto_validate_every=>100, + master_read_weight => 1 + }, + } + }, + deploy_args=>{ + add_drop_table => 1, + }, + ); + } + + sub get_schema_by_connect_info { + DBICTest->init_schema( + sqlite_use_file => 1, + storage_type=> '::DBI::Replicated', + balancer_type=>'::Random', + balancer_args=> { + auto_validate_every=>100, + master_read_weight => 1 + }, + deploy_args=>{ + add_drop_table => 1, + }, + ); + } + sub generate_replicant_connect_info {} sub replicate {} sub cleanup {} + ## --------------------------------------------------------------------- ## + ## Add a connect_info option to test option merging. + ## --------------------------------------------------------------------- ## + { + package DBIx::Class::Storage::DBI::Replicated; + + use Moose; + + __PACKAGE__->meta->make_mutable; + + around connect_info => sub { + my ($next, $self, $info) = @_; + $info->[3]{master_option} = 1; + $self->$next($info); + }; + + __PACKAGE__->meta->make_immutable; + + no Moose; + } ## --------------------------------------------------------------------- ## ## Subclass for when you are using SQLite for testing, this provides a fake @@ -197,14 +240,22 @@ my $replicated_class = DBICTest->has_custom_dsn ? 'DBIx::Class::DBI::Replicated::TestReplication::Custom' : 'DBIx::Class::DBI::Replicated::TestReplication::SQLite'; -ok my $replicated = $replicated_class->new - => 'Created a replication object'; - -isa_ok $replicated->schema - => 'DBIx::Class::Schema'; - -isa_ok $replicated->schema->storage - => 'DBIx::Class::Storage::DBI::Replicated'; +my $replicated; + +for my $method (qw/by_connect_info by_storage_type/) { + ok $replicated = $replicated_class->new($method) + => "Created a replication object $method"; + + isa_ok $replicated->schema + => 'DBIx::Class::Schema'; + + isa_ok $replicated->schema->storage + => 'DBIx::Class::Storage::DBI::Replicated'; + + isa_ok $replicated->schema->storage->balancer + => 'DBIx::Class::Storage::DBI::Replicated::Balancer::Random' + => 'configured balancer_type'; +} ok $replicated->schema->storage->meta => 'has a meta object'; @@ -223,9 +274,43 @@ ok my @replicant_connects = $replicated->generate_replicant_connect_info ok my @replicated_storages = $replicated->schema->storage->connect_replicants(@replicant_connects) => 'Created some storages suitable for replicants'; + +our %debug; +$replicated->schema->storage->debug(1); +$replicated->schema->storage->debugcb(sub { + my ($op, $info) = @_; + ##warn "\n$op, $info\n"; + %debug = ( + op => $op, + info => $info, + dsn => ($info=~m/\[(.+)\]/)[0], + storage_type => $info=~m/REPLICANT/ ? 'REPLICANT' : 'MASTER', + ); +}); + +ok my @all_storages = $replicated->schema->storage->all_storages + => '->all_storages'; + +is scalar @all_storages, + 3 + => 'correct number of ->all_storages'; + +is ((grep $_->isa('DBIx::Class::Storage::DBI'), @all_storages), + 3 + => '->all_storages are correct type'); + +my @all_storage_opts = + grep { (reftype($_)||'') eq 'HASH' } + map @{ $_->_connect_info }, @all_storages; + +is ((grep $_->{master_option}, @all_storage_opts), + 3 + => 'connect_info was merged from master to replicants'); my @replicant_names = keys %{ $replicated->schema->storage->replicants }; +ok @replicant_names, "found replicant names @replicant_names"; + ## Silence warning about not supporting the is_replicating method if using the ## sqlite dbs. $replicated->schema->storage->debugobj->silence(1) @@ -262,6 +347,11 @@ $replicated [ qw/artistid name/ ], [ 4, "Ozric Tentacles"], ]); + + is $debug{storage_type}, 'MASTER', + "got last query from a master: $debug{dsn}"; + + like $debug{info}, qr/INSERT/, 'Last was an insert'; ## Make sure all the slaves have the table definitions @@ -283,12 +373,36 @@ $replicated->schema->storage->debugobj->silence(0); ok my $artist1 = $replicated->schema->resultset('Artist')->find(4) => 'Created Result'; +## We removed testing here since master read weight is on, so we can't tell in +## advance what storage to expect. We turn master read weight off a bit lower +## is $debug{storage_type}, 'REPLICANT' +## => "got last query from a replicant: $debug{dsn}, $debug{info}"; + isa_ok $artist1 => 'DBICTest::Artist'; is $artist1->name, 'Ozric Tentacles' => 'Found expected name for first result'; +## Check that master_read_weight is honored +{ + no warnings qw/once redefine/; + + local + *DBIx::Class::Storage::DBI::Replicated::Balancer::Random::_random_number = + sub { 999 }; + + $replicated->schema->storage->balancer->increment_storage; + + is $replicated->schema->storage->balancer->current_replicant, + $replicated->schema->storage->master + => 'master_read_weight is honored'; + + ## turn it off for the duration of the test + $replicated->schema->storage->balancer->master_read_weight(0); + $replicated->schema->storage->balancer->increment_storage; +} + ## Add some new rows that only the master will have This is because ## we overload any type of write operation so that is must hit the master ## database. @@ -302,6 +416,11 @@ $replicated [ 7, "Watergate"], ]); + is $debug{storage_type}, 'MASTER', + "got last query from a master: $debug{dsn}"; + + like $debug{info}, qr/INSERT/, 'Last was an insert'; + ## Make sure all the slaves have the table definitions $replicated->replicate; @@ -309,7 +428,10 @@ $replicated->replicate; ok my $artist2 = $replicated->schema->resultset('Artist')->find(5) => 'Sync succeed'; - + +is $debug{storage_type}, 'REPLICANT' + => "got last query from a replicant: $debug{dsn}"; + isa_ok $artist2 => 'DBICTest::Artist'; @@ -331,7 +453,10 @@ is $replicated->schema->storage->pool->connected_replicants => 0 ok my $artist3 = $replicated->schema->resultset('Artist')->find(6) => 'Still finding stuff.'; - + +is $debug{storage_type}, 'REPLICANT' + => "got last query from a replicant: $debug{dsn}"; + isa_ok $artist3 => 'DBICTest::Artist'; @@ -345,7 +470,10 @@ is $replicated->schema->storage->pool->connected_replicants => 1 ok ! $replicated->schema->resultset('Artist')->find(666) => 'Correctly failed to find something.'; - + +is $debug{storage_type}, 'REPLICANT' + => "got last query from a replicant: $debug{dsn}"; + ## test the reliable option TESTRELIABLE: { @@ -354,37 +482,62 @@ TESTRELIABLE: { ok $replicated->schema->resultset('Artist')->find(2) => 'Read from master 1'; - + + is $debug{storage_type}, 'MASTER', + "got last query from a master: $debug{dsn}"; + ok $replicated->schema->resultset('Artist')->find(5) => 'Read from master 2'; - + + is $debug{storage_type}, 'MASTER', + "got last query from a master: $debug{dsn}"; + $replicated->schema->storage->set_balanced_storage; ok $replicated->schema->resultset('Artist')->find(3) => 'Read from replicant'; + + is $debug{storage_type}, 'REPLICANT', + "got last query from a replicant: $debug{dsn}"; } ## Make sure when reliable goes out of scope, we are using replicants again ok $replicated->schema->resultset('Artist')->find(1) => 'back to replicant 1.'; - + + is $debug{storage_type}, 'REPLICANT', + "got last query from a replicant: $debug{dsn}"; + ok $replicated->schema->resultset('Artist')->find(2) => 'back to replicant 2.'; + is $debug{storage_type}, 'REPLICANT', + "got last query from a replicant: $debug{dsn}"; + ## set all the replicants to inactive, and make sure the balancer falls back to ## the master. $replicated->schema->storage->replicants->{$replicant_names[0]}->active(0); $replicated->schema->storage->replicants->{$replicant_names[1]}->active(0); -## Silence warning about falling back to master. -$replicated->schema->storage->debugobj->silence(1); - -ok $replicated->schema->resultset('Artist')->find(2) - => 'Fallback to master'; +{ + ## catch the fallback to master warning + open my $debugfh, '>', \my $fallback_warning; + my $oldfh = $replicated->schema->storage->debugfh; + $replicated->schema->storage->debugfh($debugfh); -$replicated->schema->storage->debugobj->silence(0); + ok $replicated->schema->resultset('Artist')->find(2) + => 'Fallback to master'; + + is $debug{storage_type}, 'MASTER', + "got last query from a master: $debug{dsn}"; + + like $fallback_warning, qr/falling back to master/ + => 'emits falling back to master warning'; + + $replicated->schema->storage->debugfh($oldfh); +} $replicated->schema->storage->replicants->{$replicant_names[0]}->active(1); $replicated->schema->storage->replicants->{$replicant_names[1]}->active(1); @@ -400,6 +553,9 @@ $replicated->schema->storage->debugobj->silence(0); ok $replicated->schema->resultset('Artist')->find(2) => 'Returned to replicates'; + +is $debug{storage_type}, 'REPLICANT', + "got last query from a replicant: $debug{dsn}"; ## Getting slave status tests @@ -463,6 +619,9 @@ SKIP: { ok $replicated->schema->resultset('Artist')->find(5) => 'replicant reactivated'; + + is $debug{storage_type}, 'REPLICANT', + "got last query from a replicant: $debug{dsn}"; is $replicated->schema->storage->pool->active_replicants => 2 => "both replicants reactivated"; @@ -473,7 +632,10 @@ SKIP: { ok my $reliably = sub { ok $replicated->schema->resultset('Artist')->find(5) - => 'replicant reactivated'; + => 'replicant reactivated'; + + is $debug{storage_type}, 'MASTER', + "got last query from a master: $debug{dsn}"; } => 'created coderef properly'; @@ -496,6 +658,8 @@ throws_ok {$replicated->schema->storage->execute_reliably($unreliably)} ok $replicated->schema->resultset('Artist')->find(3) => 'replicant reactivated'; + +is $debug{storage_type}, 'REPLICANT', "got last query from a replicant: $debug{dsn}"; ## make sure transactions are set to execute_reliably @@ -511,11 +675,17 @@ ok my $transaction = sub { ]); ok my $result = $replicated->schema->resultset('Artist')->find($id) - => 'Found expected artist'; - + => "Found expected artist for $id"; + + is $debug{storage_type}, 'MASTER', + "got last query from a master: $debug{dsn}"; + ok my $more = $replicated->schema->resultset('Artist')->find(1) - => 'Found expected artist again'; - + => 'Found expected artist again for 1'; + + is $debug{storage_type}, 'MASTER', + "got last query from a master: $debug{dsn}"; + return ($result, $more); } => 'Created a coderef properly'; @@ -527,18 +697,28 @@ ok my $transaction = sub { is $return[0]->id, 666 => 'first returned value is correct'; + + is $debug{storage_type}, 'MASTER', + "got last query from a master: $debug{dsn}"; is $return[1]->id, 1 => 'second returned value is correct'; + + is $debug{storage_type}, 'MASTER', + "got last query from a master: $debug{dsn}"; + } ## Test that asking for single return works { - ok my $return = $replicated->schema->txn_do($transaction, 777) + ok my @return = $replicated->schema->txn_do($transaction, 777) => 'did transaction'; - is $return->id, 777 + is $return[0]->id, 777 => 'first returned value is correct'; + + is $return[1]->id, 1 + => 'second returned value is correct'; } ## Test transaction returning a single value @@ -547,6 +727,7 @@ ok my $transaction = sub { ok my $result = $replicated->schema->txn_do(sub { ok my $more = $replicated->schema->resultset('Artist')->find(1) => 'found inside a transaction'; + is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}"; return $more; }) => 'successfully processed transaction'; @@ -558,15 +739,22 @@ ok my $transaction = sub { ok $replicated->schema->resultset('Artist')->find(1) => 'replicant reactivated'; + +is $debug{storage_type}, 'REPLICANT', "got last query from a replicant: $debug{dsn}"; ## Test Discard changes { ok my $artist = $replicated->schema->resultset('Artist')->find(2) => 'got an artist to test discard changes'; - - ok $artist->discard_changes + + is $debug{storage_type}, 'REPLICANT', "got last query from a replicant: $debug{dsn}"; + + ok $artist->get_from_storage({force_pool=>'master'}) => 'properly discard changes'; + + is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}"; + } ## Test some edge cases, like trying to do a transaction inside a transaction, etc @@ -576,6 +764,7 @@ ok $replicated->schema->resultset('Artist')->find(1) return $replicated->schema->txn_do(sub { ok my $more = $replicated->schema->resultset('Artist')->find(1) => 'found inside a transaction inside a transaction'; + is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}"; return $more; }); }) => 'successfully processed transaction'; @@ -590,7 +779,8 @@ ok $replicated->schema->resultset('Artist')->find(1) return $replicated->schema->txn_do(sub { return $replicated->schema->storage->execute_reliably(sub { ok my $more = $replicated->schema->resultset('Artist')->find(1) - => 'found inside crazy deep transactions and execute_reliably'; + => 'found inside crazy deep transactions and execute_reliably'; + is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}"; return $more; }); }); @@ -613,7 +803,26 @@ ok $replicated->schema->resultset('Artist')->find(1) ok my $artist = $reliable_artist_rs->find(2) => 'got an artist result via force_pool storage'; + + is $debug{storage_type}, 'MASTER', "got last query from a master: $debug{dsn}"; } +## Test the force_pool resultset attribute part two. + +{ + ok my $artist_rs = $replicated->schema->resultset('Artist') + => 'got artist resultset'; + + ## Turn on Forced Pool Storage + ok my $reliable_artist_rs = $artist_rs->search(undef, {force_pool=>$replicant_names[0]}) + => 'Created a resultset using force_pool storage'; + + ok my $artist = $reliable_artist_rs->find(2) + => 'got an artist result via force_pool storage'; + + is $debug{storage_type}, 'REPLICANT', "got last query from a replicant: $debug{dsn}"; +} ## Delete the old database files $replicated->cleanup; + +# vim: sw=4 sts=4 :