Imported Upstream version 1.12

t/10_handler.t

@@ -0,0 +1,35 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use FindBin qw($Bin);
+use lib qq($Bin/lib);
+use JMX::Jmx4Perl::Alias;
+use Data::Dumper;
+use Test::More tests => 10;
+
+BEGIN { use_ok("JMX::Jmx4Perl"); }
+
+# Use a new handler directory
+&JMX::Jmx4Perl::_register_handlers("ProductTest");
+
+my $jmx4perl = new JMX::Jmx4Perl(url => "localhost");
+my @res = $jmx4perl->resolve_alias("memory:heap");
+ok(@res && $res[0] eq "resolved_name" && $res[1] eq "resolved_attr","Resolved alias properly");
+
+$jmx4perl = new JMX::Jmx4Perl(url => "localhost", product => "Test2");
+my @alias = $jmx4perl->resolve_alias("memory:heap");
+ok(@alias && $alias[0] eq "resolved2_name" && $alias[1] eq "resolved2_attr","Resolved alias properly");
+@alias = $jmx4perl->resolve_alias("MEMORY_GC");
+ok(@alias && $alias[0] eq "memory2_name" && $alias[1] eq "gc2_op","Resolved operation alias properly");
+
+is($JMX::Jmx4Perl::PRODUCT_HANDLER_ORDERING[0],"test2","Test ordering");
+is($JMX::Jmx4Perl::PRODUCT_HANDLER_ORDERING[1],"test1","Test ordering");
+
+$jmx4perl = new JMX::Jmx4Perl(url => "localhost");
+@res = $jmx4perl->resolve_alias(SERVER_NAME);
+is($res[0],"server","Check for alias resolving by closure");
+is($res[1],"name","Check for alias resolving by closure");
+my $code = $jmx4perl->resolve_alias(SERVER_ADDRESS);
+is(ref($code),"CODE","Check for code based resolving");
+is($code->(),"127.0.0.1","Check for code based resolving");

t/20_alias.t

@@ -0,0 +1,22 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use FindBin qw($Bin);
+use lib qq($Bin/lib);
+use Data::Dumper;
+
+use Test::More tests => 6;
+
+BEGIN { use_ok("JMX::Jmx4Perl::Alias"); }
+
+# Check names
+is(MEMORY_HEAP->name,"memory:heap","Name");
+
+# Check by name
+for $_ (qw(memory:heap:used MEMORY_HEAP_USED)) {
+    my $heap = JMX::Jmx4Perl::Alias->by_name($_);
+    ok(MEMORY_HEAP_USED == $heap,"Equality");
+    ok($heap->isa("JMX::Jmx4Perl::Alias::Object"),"isa");
+}
+

t/30_request.t

@@ -0,0 +1,75 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use FindBin qw($Bin);
+use lib qq($Bin/lib);
+
+use Test::More tests => 30;
+
+BEGIN { use_ok("JMX::Jmx4Perl::Request"); }
+
+ok(READ eq "read","Import of constants");
+
+my $names = 
+    {
+     "jmx4perl.it:name=\"name\\*with\\?strange=\\\"chars\",type=escape" => 0,
+     "*:*" => 1,
+     "*:type=bla" => 1,
+     "domain:*" => 1,
+     "domain:name=blub,*" => 1,
+     "domain:name=*,type=blub" => 1,
+     "domain:name=*,*" => 1, 
+     "domain:name=\"\\*\",type=blub" => 0,
+     "domain:name" => 0,
+     "domain:name=Bla*blub" => 1,
+     "domain:name=\"Bla\\*blub\"" => 0,
+     "domain:name=\"Bla\\*?blub\"" => 1,     
+     "domain:name=\"Bla\\*\\?blub\"" => 0,     
+     "domain:name=\"Bla\\*\\?blub\",type=?" => 1,
+     "do*1:name=bla" => 1,
+     "do?1:name=bla" => 1
+    };
+
+for my $name (keys %$names) {
+    my $req = new JMX::Jmx4Perl::Request(READ,$name,"attribute");
+    my $is_pattern = $req->is_mbean_pattern;
+    is($is_pattern,$names->{$name},"Pattern: $name");
+}
+
+# Check for autodetection of requests
+my $name="domain:attr=val";
+my $req = new JMX::Jmx4Perl::Request(READ,$name,"attribute");
+is($req->method(),undef,"Method not defined");
+$req = new JMX::Jmx4Perl::Request(READ,$name,"attribute",{method => "PoSt"});
+is($req->method(),"POST","Post method");
+$req = new JMX::Jmx4Perl::Request(READ,$name,["a1","a2"]);    
+is($req->method(),"POST","Read with attribute refs need POST");
+eval {
+    $req = new JMX::Jmx4Perl::Request(READ,$name,["a1","a2"],{method => "GET"});    
+};
+ok($@,"No attributes with GET");
+
+# Regexp for squeezing trailing slashes (RT#89108)
+my $regexps = {
+               new => 's|((?:!/)?/)/*|$1|g',
+               old => 's|(!/)?/+|$1/|g'
+              };
+my $data = {
+            '!////' => '!//',
+            '////'  => '/',
+            '/' => '/',
+            '!/' => '!/'            
+           };
+for my $d (keys %$data) {
+    no warnings;
+    for my $re (keys %$regexps) {
+        my $test = $d;
+        my $expected = $data->{$d};
+        eval '$^W = 0; $test =~ ' . $regexps->{$re};        
+        is($test,$expected,"Squeezing regexp '" . $re ."' : ".$d." --> ".$test);
+    }
+}
+
+
+

t/40_check_jmx4perl.t

@@ -0,0 +1,72 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use FindBin qw($Bin);
+use lib qq($Bin/lib);
+use vars qw(@ARGS);
+use Test::More;
+use Data::Dumper;
+
+eval { require Monitoring::Plugin };
+if ($@) {
+    plan skip_all => 'Monitoring::Plugin not installed';
+}
+else {
+    plan tests => 29;
+}
+
+Monitoring::Plugin->import();
+
+eval { require JMX::Jmx4Perl::Nagios::SingleCheck };
+ok(!$@,"JMX::Jmx4Perl::Nagios::SingleCheck loads properly");
+
+eval { require JMX::Jmx4Perl::Nagios::CheckJmx4Perl };
+ok(!$@,"JMX::Jmx4Perl::Nagios::CheckJmx4Perl loads properly");
+
+@ARGV=qw(--url http://localhost:8080/j4p -a MEMORY_HEAP_USED -c 1 -m 2 --name Memory --unit m);
+my $cj4p = new JMX::Jmx4Perl::Nagios::CheckJmx4Perl();
+my $scheck = $cj4p->{checks}->[0];
+my ($value,$unit) = $scheck->_normalize_value("0.50","MB");
+is($value,512);
+is($unit,"KB");
+($value,$unit) = $scheck->_normalize_value("2048","MB");
+is($value,2);
+is($unit,"GB");
+($value,$unit) = $scheck->_normalize_value("0.5","m");
+is($value,30);
+is($unit,"s");
+($value,$unit) = $scheck->_normalize_value("360","m");
+is($value,6);
+is($unit,"h");
+($value,$unit) = $scheck->_normalize_value("0.5","us");
+is($value,"500");
+is($unit,"ns");
+($value,$unit) = $scheck->_normalize_value("300","us");
+is($value,"300");
+is($unit,"us");
+($value,$unit) = $scheck->_normalize_value("20","d");
+is($value,"20");
+is($unit,"d");
+($value,$unit) = $scheck->_normalize_value("200","TB");
+is($value,"200");
+is($unit,"TB");
+($value,$unit) = $scheck->_normalize_value(1024*1024,"B");
+is($value,1);
+is($unit,"MB");
+($value,$unit) = $scheck->_normalize_value("1000","ms");
+is($value,1);
+is($unit,"s");
+($value,$unit) = $scheck->_normalize_value(1/60,"m");
+is($value,1);
+is($unit,"s");
+($value,$unit) = $scheck->_normalize_value(0.001,"us");
+is($value,1);
+is($unit,"ns");
+($value,$unit) = $scheck->_normalize_value(1010,"ns");
+is($value,1.01);
+is($unit,"us");
+
+my $label = $scheck->_exit_message(code => &Monitoring::Plugin::OK,mode => "numeric",value => "2.1", unit => "MB");
+is($label,"Memory : Value 2.10 MB in range");
+

t/50_config.t

@@ -0,0 +1,23 @@
+#!/usr/bin/perl
+use Test::More;
+use FindBin qw($Bin);
+use Data::Dumper;
+use JMX::Jmx4Perl::Config;
+
+my $HAS_CONFIG_GENERAL;
+BEGIN { 
+    eval "use Config::General";
+    $HAS_CONFIG_GENERAL = $@ ? 0 : 1;
+}
+plan tests => $HAS_CONFIG_GENERAL ? 4 : 1;
+$SIG{__WARN__} = sub { };
+my $config = new JMX::Jmx4Perl::Config("$Bin/j4p_test.cfg");
+if ($HAS_CONFIG_GENERAL) {
+    is(scalar(keys(%{$config->{server_config}})),2,"2 configuration entries read in");    
+    ok($config->server_config_exists("jboss"),"JBoss configuration exists");
+    my $s = $config->get_server_config("weblogic");
+    is($s->{product},"Weblogic","Proper product found");
+    is(scalar(keys(%$s)),5,"Correct number of config elements");
+} else {
+    ok(scalar(keys(%{$config->{config}})) == 0,"No config read in");
+}

t/60_parse_name.t

@@ -0,0 +1,29 @@
+#!/usr/bin/perl
+
+use strict;
+use warnings;
+use JMX::Jmx4Perl;
+use Data::Dumper;
+use Test::More tests => 16;
+
+my $data = 
+    {
+     "jmx4perl:lang=java,type=class" => [ "jmx4perl",{ lang => "java", type => "class"} ],
+     "jmx4perl:lang=java,type=class" => [ "jmx4perl",{ lang => "java", type => "class"} ],
+     "jmx4perl:lang=java:perl,type=x" => [ "jmx4perl",{ lang => "java:perl", type => "x"} ],
+     "jmx4perl:lang=\"A\\*B\",type=\",\"" => [ "jmx4perl",{ lang => "A*B", type => ","} ],
+     "jmx4perl:lang=\"A\\,B\",type=x" => [ "jmx4perl",{ lang => "A,B", type => "x"} ],
+     'jmx4perl:name="\\"\\"\\"",type=escape' => [ "jmx4perl", { name => '"""', type => "escape" }],
+     "bla:blub" => [ undef, undef ],
+     "bla:blub=" => [ undef, undef ],
+     "sDSDSADSDA" => [ undef, undef]
+    };
+
+my $jmx4perl = new JMX::Jmx4Perl(url => "localhost");
+for my $k (sort keys %$data) {
+    my ($domain,$attr) = $jmx4perl->parse_name($k);
+    my $expected = $data->{$k};
+#    print Dumper($attr);
+    is($domain,$expected->[0],"Domain: " . ($domain ? $domain : "(undef)"));
+    is_deeply($attr,$expected->[1],"Attributes for $k");
+}

t/70_pod_syntax.t

@@ -0,0 +1,13 @@
+#!perl
+
+use Test::More;
+
+unless($ENV{RELEASE_TESTING}) {
+    Test::More::plan(skip_all => 'these tests are for release candidate testing');
+}
+
+unless(eval "use Test::Pod; 1") {
+    plan skip_all => "Test::Pod required for testing POD";
+}
+
+all_pod_files_ok(grep { !/PGPKey/ } all_pod_files(qw(blib script)));

t/j4p_test.cfg

@@ -0,0 +1,19 @@
+# ================================================================
+# Sample configuration for jmx4perl
+
+<Server jboss>
+  Url  = http://localhost:8888/j4p
+  Product = JBoss
+  # User = roland
+  # Password = test
+  # Proxy_User = ....
+  # Proxy_Password = ....
+</Server>
+<Server weblogic>
+  Url  = http://localhost:8899/j4p
+  Product = Weblogic
+  User = roland
+  Password = test
+  # Proxy_User = ....
+  # Proxy_Password = ....
+</Server>

t/lib/It.pm

@@ -0,0 +1,53 @@
+#!/usr/bin/perl
+
+package It;
+
+use strict;
+use JMX::Jmx4Perl;
+use Exporter;
+use vars qw(@EXPORT);
+use Data::Dumper;
+
+@EXPORT = qw($IT_BEAN);
+
+my $IT_BEAN = "jolokia:type=it,name=testbean";
+
+
+sub new { 
+    my $class = shift;
+    my %args = @_;
+    my $self = {};
+    $self->{url} = $args{gateway} || $ENV{JMX4PERL_GATEWAY} || die "No gateway URL given";
+    $self->{product} = $args{product} || $ENV{JMX4PERL_PRODUCT};
+    $self->{user} = $args{user} || $ENV{JMX4PERL_USER};
+    $self->{password} = $args{password} || $ENV{JMX4PERL_PASSWORD};
+    $self->{verbose} = $args{verbose} || $ENV{JMX4PERL_VERBOSE};
+    my $t_url = $args{target_url} || $ENV{JMX4PERL_TARGET_URL};
+    my $t_user = $args{target_user} || $ENV{JMX4PERL_TARGET_USER};
+    my $t_password = $args{target_password} || $ENV{JMX4PERL_TARGET_PASSWORD};
+    my @params = map { $_ => $self->{$_ } } qw(url product user password verbose);
+    if ($t_url) {
+        push @params, target => {
+                                 url => $t_url,
+                                 $t_user ? (user => $t_user) : (),
+                                 $t_password ? (password => $t_password) : ()
+                                };
+    }
+    $self->{jmx4perl} = new JMX::Jmx4Perl(@params);
+    
+    bless $self,(ref($class) || $class);
+
+}
+
+sub jmx4perl {
+    my $self = shift;
+    return $self->{jmx4perl};
+}
+
+sub userAgent {
+    my $self = shift;
+    my $j4p = $self->jmx4perl;
+    return $j4p->{ua};
+}
+
+1;

t/lib/ProductTest/Test1Handler.pm

@@ -0,0 +1,31 @@
+package ProductTest::Test1Handler;
+
+use base qw(JMX::Jmx4Perl::Product::BaseHandler);
+use JMX::Jmx4Perl::Alias;
+
+
+sub id { return "Test1" };
+
+sub autodetect { return 1; }
+
+sub order { 
+    return 1;
+}
+sub init_aliases {
+    return { 
+            attributes => 
+          {
+           MEMORY_HEAP => [ "resolved_name", "resolved_attr" ],
+           SERVER_NAME => [ 
+                           sub { 
+                               return ["server","name"]
+                           }
+                           ],
+           SERVER_ADDRESS => sub { 
+               return "127.0.0.1";
+           }
+          }
+           };
+}
+
+1;

t/lib/ProductTest/Test2Handler.pm

@@ -0,0 +1,27 @@
+package ProductTest::Test2Handler;
+
+use base qw(JMX::Jmx4Perl::Product::BaseHandler);
+
+sub id { return "Test2" };
+
+sub autodetect {
+    return 0;
+}
+
+sub order { 
+    return -1;
+}
+
+sub init_aliases {
+    return 
+    { 
+     attributes => {
+                    MEMORY_HEAP => [ "resolved2_name", "resolved2_attr" ]
+                   },
+     operations => { 
+                    MEMORY_GC => [ "memory2_name", "gc2_op" ]
+                   }
+    };
+}
+
+1;