293 lines
7.5 KiB
Perl
293 lines
7.5 KiB
Perl
# Net::ZooKeeper - Perl extension for Apache ZooKeeper
|
|
#
|
|
# Licensed to the Apache Software Foundation (ASF) under one
|
|
# or more contributor license agreements. See the NOTICE file
|
|
# distributed with this work for additional information
|
|
# regarding copyright ownership. The ASF licenses this file
|
|
# to you under the Apache License, Version 2.0 (the
|
|
# "License"); you may not use this file except in compliance
|
|
# with the License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
use File::Spec;
|
|
use Test::More tests => 42;
|
|
|
|
BEGIN { use_ok('Net::ZooKeeper', qw(:all)) };
|
|
|
|
|
|
my $test_dir;
|
|
(undef, $test_dir, undef) = File::Spec->splitpath($0);
|
|
require File::Spec->catfile($test_dir, 'util.pl');
|
|
|
|
my($hosts, $root_path, $node_path) = zk_test_setup(0);
|
|
|
|
|
|
SKIP: {
|
|
my $zkh = Net::ZooKeeper->new($hosts);
|
|
my $watch = $zkh->watch() if (defined($zkh));
|
|
|
|
skip 'no valid watch handle', 4 unless (defined($watch));
|
|
|
|
|
|
## DESTROY()
|
|
|
|
my $attr = tied(%{$watch});
|
|
|
|
my $ret = $attr->DESTROY();
|
|
ok($ret,
|
|
'watch DESTROY(): destroyed inner watch hash');
|
|
|
|
$ret = $attr->DESTROY();
|
|
ok(!$ret,
|
|
'watch DESTROY(): no action on destroyed inner watch hash');
|
|
|
|
$ret = $watch->DESTROY();
|
|
ok(!$ret,
|
|
'watch DESTROY(): no action on watch handle with destroyed inner hash');
|
|
|
|
undef $watch;
|
|
ok(!defined($watch),
|
|
'undef: released watch handle with destroyed inner hash');
|
|
}
|
|
|
|
SKIP: {
|
|
my $zkh = Net::ZooKeeper->new($hosts);
|
|
my $watch = $zkh->watch() if (defined($zkh));
|
|
|
|
skip 'no valid watch handle', 37 unless (defined($watch));
|
|
|
|
|
|
## TIEHASH(), UNTIE()
|
|
|
|
eval {
|
|
tie(%{$watch}, 'Net::ZooKeeper::Watch');
|
|
};
|
|
like($@, qr/tying hashes of class Net::ZooKeeper::Watch not supported/,
|
|
'tie(): tying watch hashes not supported');
|
|
|
|
eval {
|
|
Net::ZooKeeper::Watch::TIEHASH('Net::ZooKeeper::Watch');
|
|
};
|
|
like($@, qr/tying hashes of class Net::ZooKeeper::Watch not supported/,
|
|
'watch TIEHASH(): tying watch hashes not supported');
|
|
|
|
eval {
|
|
untie(%{$watch});
|
|
};
|
|
like($@, qr/untying hashes of class Net::ZooKeeper::Watch not supported/,
|
|
'untie(): untying watch hashes not supported');
|
|
|
|
my $attr = tied(%{$watch});
|
|
|
|
eval {
|
|
$attr->UNTIE(0);
|
|
};
|
|
like($@, qr/untying hashes of class Net::ZooKeeper::Watch not supported/,
|
|
'watch UNTIE(): untying watch hashes not supported');
|
|
|
|
|
|
## FIRSTKEY(), NEXTKEY(), SCALAR()
|
|
|
|
my $copy_watch;
|
|
{
|
|
my %copy_watch = %{$watch};
|
|
$copy_watch = \%copy_watch;
|
|
}
|
|
bless($copy_watch, 'Net::ZooKeeper::Watch');
|
|
is(ref($copy_watch), 'Net::ZooKeeper::Watch',
|
|
'watch FIRSTKEY(), NEXTKEY(): copied dereferenced watch handle');
|
|
|
|
eval {
|
|
my $val = $copy_watch->FIRSTKEY();
|
|
};
|
|
like($@, qr/invalid handle/,
|
|
'watch FETCHKEY(): invalid watch handle');
|
|
|
|
eval {
|
|
my $val = $copy_watch->NEXTKEY('czxid');
|
|
};
|
|
like($@, qr/invalid handle/,
|
|
'watch NEXTKEY(): invalid watch handle');
|
|
|
|
my @keys = keys(%{$watch});
|
|
is(scalar(@keys), 3,
|
|
'keys(): count of keys from watch handle');
|
|
|
|
@keys = keys(%{$copy_watch});
|
|
is(scalar(@keys), 3,
|
|
'keys(): count of keys from copied dereferenced watch handle');
|
|
|
|
is($attr->FIRSTKEY(), 'timeout',
|
|
'watch FIRSTKEY(): retrieved first key using inner watch hash');
|
|
|
|
is($attr->NEXTKEY('event'), 'state',
|
|
'watch NEXTKEY(): retrieved last key using inner watch hash');
|
|
|
|
is($attr->NEXTKEY('state'), undef,
|
|
'NEXTKEY(): undef returned after last key using inner watch hash');
|
|
|
|
ok(scalar(%{$watch}),
|
|
'scalar(): true value returned for dereferenced watch handle');
|
|
|
|
ok($watch->SCALAR(),
|
|
'watch SCALAR(): true value returned');
|
|
|
|
|
|
## FETCH()
|
|
|
|
eval {
|
|
my $val = $copy_watch->FETCH('version');
|
|
};
|
|
like($@, qr/invalid handle/,
|
|
'watch FETCH(): invalid watch handle');
|
|
|
|
{
|
|
my $msg;
|
|
|
|
$SIG{'__WARN__'} = sub { $msg = $_[0]; };
|
|
|
|
my $val = $watch->{'foo'};
|
|
ok(!defined($val),
|
|
'watch FETCH(): undef returned for invalid element');
|
|
|
|
like($msg, qr/invalid element/,
|
|
'watch FETCH(): invalid element');
|
|
}
|
|
|
|
is($watch->{'timeout'}, 60000,
|
|
'watch FETCH(): default timeout');
|
|
|
|
is($watch->{'event'}, 0,
|
|
'watch FETCH(): default event');
|
|
|
|
is($watch->{'state'}, 0,
|
|
'watch FETCH(): default state');
|
|
|
|
is($attr->FETCH('timeout'), 60000,
|
|
'watch FETCH(): default timeout using inner watch hash');
|
|
|
|
|
|
## STORE()
|
|
|
|
eval {
|
|
my $val = $copy_watch->STORE('version', 'foo');
|
|
};
|
|
like($@, qr/invalid handle/,
|
|
'watch STORE(): invalid watch handle');
|
|
|
|
{
|
|
my $msg;
|
|
|
|
$SIG{'__WARN__'} = sub { $msg = $_[0]; };
|
|
|
|
$watch->{'foo'} = 'foo';
|
|
like($msg, qr/invalid element/,
|
|
'watch STORE(): invalid element');
|
|
}
|
|
|
|
{
|
|
my $msg;
|
|
|
|
$SIG{'__WARN__'} = sub { $msg = $_[0]; };
|
|
|
|
$watch->{'event'} = 'foo';
|
|
like($msg, qr/read-only element: event/,
|
|
'watch STORE(): read-only event element');
|
|
}
|
|
|
|
{
|
|
my $msg;
|
|
|
|
$SIG{'__WARN__'} = sub { $msg = $_[0]; };
|
|
|
|
$watch->{'state'} = 'foo';
|
|
like($msg, qr/read-only element: state/,
|
|
'watch STORE(): read-only state element');
|
|
}
|
|
|
|
$watch->{'timeout'} = 100;
|
|
is($watch->{'timeout'}, 100,
|
|
'watch STORE(): updated timeout');
|
|
|
|
$attr->STORE('timeout', 200);
|
|
is($watch->{'timeout'}, 200,
|
|
'watch STORE(): updated timeout using inner hash');
|
|
|
|
|
|
## EXISTS()
|
|
|
|
eval {
|
|
my $val = $copy_watch->EXISTS('version');
|
|
};
|
|
like($@, qr/invalid handle/,
|
|
'watch EXISTS(): invalid watch handle');
|
|
|
|
ok(!exists($watch->{'foo'}),
|
|
'exists(): invalid element of watch handle');
|
|
|
|
ok(exists($watch->{'timeout'}),
|
|
'exists(): timeout');
|
|
|
|
ok(exists($watch->{'event'}),
|
|
'exists(): event');
|
|
|
|
ok(exists($watch->{'state'}),
|
|
'exists(): state');
|
|
|
|
ok($attr->EXISTS('timeout'),
|
|
'watch EXISTS(): timeout using inner watch hash');
|
|
|
|
|
|
## DELETE(), CLEAR()
|
|
|
|
{
|
|
my $msg;
|
|
|
|
$SIG{'__WARN__'} = sub { $msg = $_[0]; };
|
|
|
|
delete($watch->{'version'});
|
|
like($msg,
|
|
qr/deleting elements from hashes of class Net::ZooKeeper::Watch not supported/,
|
|
'delete(): deleting watch hash elements not supported');
|
|
}
|
|
|
|
{
|
|
my $msg;
|
|
|
|
$SIG{'__WARN__'} = sub { $msg = $_[0]; };
|
|
|
|
$watch->DELETE({'version'});
|
|
like($msg,
|
|
qr/deleting elements from hashes of class Net::ZooKeeper::Watch not supported/,
|
|
'watch DELETE(): deleting watch hash elements not supported');
|
|
}
|
|
|
|
{
|
|
my $msg;
|
|
|
|
$SIG{'__WARN__'} = sub { $msg = $_[0]; };
|
|
|
|
%{$watch} = ();
|
|
like($msg, qr/clearing hashes of class Net::ZooKeeper::Watch not supported/,
|
|
'assign: clearing watch hashes not supported');
|
|
}
|
|
|
|
{
|
|
my $msg;
|
|
|
|
$SIG{'__WARN__'} = sub { $msg = $_[0]; };
|
|
|
|
$watch->CLEAR();
|
|
like($msg, qr/clearing hashes of class Net::ZooKeeper::Watch not supported/,
|
|
'watch CLEAR(): clearing watch hashes not supported');
|
|
}
|
|
}
|
|
|