Attachment #159841 for bug #35536

View | Details | Raw Unified | Return to bug 35536
Collapse All | Expand All





use Koha::Cache::Memory::Lite;
use Koha::Exceptions::Plugin;
use Koha::Plugins::Datas;
use Koha::Plugins::Methods;

use constant ENABLED_PLUGINS_CACHE_KEY => 'enabled_plugins';

    return @plugins;
}

=head2 RemovePlugins

    Koha::Plugins->RemovePlugins;
    Koha::Plugins->RemovePlugins({ plugin_class => NAME });

    This is primarily for unit testing. Remove (all) records in plugin_data
    and plugin_methods. Clear the cache key for enabled plugins.

=cut

sub RemovePlugins {
    my ( $class, $params ) = @_;    # optional param: plugin_class

    my $cond = {
        $params->{plugin_class}
        ? ( plugin_class => $params->{plugin_class} )
        : ()
    };
    Koha::Plugins::Datas->search($cond)->delete;
    Koha::Plugins::Methods->search($cond)->delete;
    Koha::Cache::Memory::Lite->clear_from_cache( Koha::Plugins->ENABLED_PLUGINS_CACHE_KEY );
}

1;
__END__





use FindBin qw($Bin);
use Module::Load::Conditional qw(can_load);
use Test::MockModule;
use Test::More tests => 17;
use Test::Warn;

use C4::Context;
use Koha::Database;
use Koha::Plugins::Datas;
use Koha::Plugins::Methods;

use t::lib::Mocks;

    $schema->storage->txn_rollback;
};

$schema->storage->txn_begin;    # matching rollback at the very end

subtest 'feature_enabled tests' => sub {
    plan tests => 4;


    $schema->storage->txn_rollback;
};

$schema->storage->txn_begin;    # Matching rollback at very end

subtest 'output and output_html tests' => sub {

    plan tests => 6;

    is( ref($result), 'Koha::Plugins', 'calling new with enable_plugins makes it override the config' );
};

subtest 'RemovePlugins' => sub {
    plan tests => 9;

    t::lib::Mocks::mock_config( 'enable_plugins', 1 );

    # We need to mock can_load from Module::Load::Conditional in Koha/Plugins
    my $mock = Test::MockModule->new('Koha::Plugins')->mock( can_load => 1 );

    # First call without argument
    Koha::Plugins->RemovePlugins;
    is( Koha::Plugins::Datas->count,   0, 'No data in plugin_data' );
    is( Koha::Plugins::Methods->count, 0, 'No data in plugin_methods' );
    my @enabled_plugins = Koha::Plugins->get_enabled_plugins;

    # Mock creation of three new plugins
    my ( @data, @methods, @mocks );
    my $class_basename = 'Koha::Plugin::TestMR::' . time;
    foreach my $i ( 1 .. 3 ) {
        push @data,
            Koha::Plugins::Data->new(
            { plugin_class => "$class_basename$i", plugin_key => '__ENABLED__', plugin_value => 1 } )->store;
        push @methods,
            Koha::Plugins::Method->new( { plugin_class => "$class_basename$i", plugin_method => "testmr$i" } )->store;

        # no_auto => 1 here prevents loading of a not-existing module
        push @mocks,
            Test::MockModule->new( "$class_basename$i", no_auto => 1 )
            ->mock( new => bless( { mocked => 1 }, "$class_basename$i" ) );
    }

    # Check for new method and if get_enabled_plugins sees it too
    is( Koha::Plugins::Datas->count,   3, 'Records in plugin_data' );
    is( Koha::Plugins::Methods->count, 3, 'Records in plugin_methods' );
    Koha::Cache::Memory::Lite->get_instance->clear_from_cache( Koha::Plugins->ENABLED_PLUGINS_CACHE_KEY );
    is( scalar Koha::Plugins->get_enabled_plugins, 3, 'Check get_enabled_plugins again' );

    # Call with argument: delete specific method, check tables and cache again
    Koha::Plugins->RemovePlugins( { plugin_class => $class_basename . "2" } );
    is(
        Koha::Cache::Memory::Lite->get_instance->get_from_cache( Koha::Plugins->ENABLED_PLUGINS_CACHE_KEY ),
        undef, 'Cache has been cleared by delete method'
    );
    is( Koha::Plugins::Datas->count,               2, 'One record less in plugin_data' );
    is( Koha::Plugins::Methods->count,             2, 'One record less in plugin_methods' );
    is( scalar Koha::Plugins->get_enabled_plugins, 2, 'Check get_enabled_plugins' );
};

$schema->storage->txn_rollback;
- 

Return to bug 35536

Lines 32-37 use C4::Output; Link Here

(-)a/Koha/Plugins.pm (+24 lines)
32		32
33	use Koha::Cache::Memory::Lite;	33	use Koha::Cache::Memory::Lite;
34	use Koha::Exceptions::Plugin;	34	use Koha::Exceptions::Plugin;
		35	use Koha::Plugins::Datas;
35	use Koha::Plugins::Methods;	36	use Koha::Plugins::Methods;
36		37
37	use constant ENABLED_PLUGINS_CACHE_KEY => 'enabled_plugins';	38	use constant ENABLED_PLUGINS_CACHE_KEY => 'enabled_plugins';
Lines 297-302 sub InstallPlugins { Link Here
297	return @plugins;	298	return @plugins;
298	}	299	}
299		300
		301	=head2 RemovePlugins
		302
		303	Koha::Plugins->RemovePlugins;
		304	Koha::Plugins->RemovePlugins({ plugin_class => NAME });
		305
		306	This is primarily for unit testing. Remove (all) records in plugin_data
		307	and plugin_methods. Clear the cache key for enabled plugins.
		308
		309	=cut
		310
		311	sub RemovePlugins {
		312	my ( $class, $params ) = @_; # optional param: plugin_class
		313
		314	my $cond = {
		315	$params->{plugin_class}
		316	? ( plugin_class => $params->{plugin_class} )
		317	: ()
		318	};
		319	Koha::Plugins::Datas->search($cond)->delete;
		320	Koha::Plugins::Methods->search($cond)->delete;
		321	Koha::Cache::Memory::Lite->clear_from_cache( Koha::Plugins->ENABLED_PLUGINS_CACHE_KEY );
		322	}
		323
300	1;	324	1;
301	__END__	325	__END__
302		326

Lines 24-34 use File::Temp qw( tempdir tempfile ); Link Here

(-)a/t/db_dependent/Koha/Plugins/Plugins.t (-5 / +51 lines)
24	use FindBin qw($Bin);	24	use FindBin qw($Bin);
25	use Module::Load::Conditional qw(can_load);	25	use Module::Load::Conditional qw(can_load);
26	use Test::MockModule;	26	use Test::MockModule;
27	use Test::More tests => 16;	27	use Test::More tests => 17;
28	use Test::Warn;	28	use Test::Warn;
29		29
30	use C4::Context;	30	use C4::Context;
31	use Koha::Database;	31	use Koha::Database;
		32	use Koha::Plugins::Datas;
32	use Koha::Plugins::Methods;	33	use Koha::Plugins::Methods;
33		34
34	use t::lib::Mocks;	35	use t::lib::Mocks;
Lines 130-137 subtest 'more call() tests' => sub { Link Here
130	$schema->storage->txn_rollback;	131	$schema->storage->txn_rollback;
131	};	132	};
132		133
133	$schema->storage->txn_begin; # matching rollback at the very end
134
135	subtest 'feature_enabled tests' => sub {	134	subtest 'feature_enabled tests' => sub {
136	plan tests => 4;	135	plan tests => 4;
137		136
Lines 325-330 subtest 'Koha::Plugin::Test' => sub { Link Here
325	$schema->storage->txn_rollback;	324	$schema->storage->txn_rollback;
326	};	325	};
327		326
		327	$schema->storage->txn_begin; # Matching rollback at very end
		328
328	subtest 'output and output_html tests' => sub {	329	subtest 'output and output_html tests' => sub {
329		330
330	plan tests => 6;	331	plan tests => 6;
Lines 412-416 subtest 'new() tests' => sub { Link Here
412	is( ref($result), 'Koha::Plugins', 'calling new with enable_plugins makes it override the config' );	413	is( ref($result), 'Koha::Plugins', 'calling new with enable_plugins makes it override the config' );
413	};	414	};
414		415
415	Koha::Plugins::Methods->delete;	416	subtest 'RemovePlugins' => sub {
		417	plan tests => 9;
		418
		419	t::lib::Mocks::mock_config( 'enable_plugins', 1 );
		420
		421	# We need to mock can_load from Module::Load::Conditional in Koha/Plugins
		422	my $mock = Test::MockModule->new('Koha::Plugins')->mock( can_load => 1 );
		423
		424	# First call without argument
		425	Koha::Plugins->RemovePlugins;
		426	is( Koha::Plugins::Datas->count, 0, 'No data in plugin_data' );
		427	is( Koha::Plugins::Methods->count, 0, 'No data in plugin_methods' );
		428	my @enabled_plugins = Koha::Plugins->get_enabled_plugins;
		429
		430	# Mock creation of three new plugins
		431	my ( @data, @methods, @mocks );
		432	my $class_basename = 'Koha::Plugin::TestMR::' . time;
		433	foreach my $i ( 1 .. 3 ) {
		434	push @data,
		435	Koha::Plugins::Data->new(
		436	{ plugin_class => "$class_basename$i", plugin_key => '__ENABLED__', plugin_value => 1 } )->store;
		437	push @methods,
		438	Koha::Plugins::Method->new( { plugin_class => "$class_basename$i", plugin_method => "testmr$i" } )->store;
		439
		440	# no_auto => 1 here prevents loading of a not-existing module
		441	push @mocks,
		442	Test::MockModule->new( "$class_basename$i", no_auto => 1 )
		443	->mock( new => bless( { mocked => 1 }, "$class_basename$i" ) );
		444	}
		445
		446	# Check for new method and if get_enabled_plugins sees it too
		447	is( Koha::Plugins::Datas->count, 3, 'Records in plugin_data' );
		448	is( Koha::Plugins::Methods->count, 3, 'Records in plugin_methods' );
		449	Koha::Cache::Memory::Lite->get_instance->clear_from_cache( Koha::Plugins->ENABLED_PLUGINS_CACHE_KEY );
		450	is( scalar Koha::Plugins->get_enabled_plugins, 3, 'Check get_enabled_plugins again' );
		451
		452	# Call with argument: delete specific method, check tables and cache again
		453	Koha::Plugins->RemovePlugins( { plugin_class => $class_basename . "2" } );
		454	is(
		455	Koha::Cache::Memory::Lite->get_instance->get_from_cache( Koha::Plugins->ENABLED_PLUGINS_CACHE_KEY ),
		456	undef, 'Cache has been cleared by delete method'
		457	);
		458	is( Koha::Plugins::Datas->count, 2, 'One record less in plugin_data' );
		459	is( Koha::Plugins::Methods->count, 2, 'One record less in plugin_methods' );
		460	is( scalar Koha::Plugins->get_enabled_plugins, 2, 'Check get_enabled_plugins' );
		461	};
		462
416	$schema->storage->txn_rollback;	463	$schema->storage->txn_rollback;
417	-