dinislage/SOAP-WSDL
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

import SOAP-WSDL 1.27 from CPAN

Browse Source 
git-cpan-module:   SOAP-WSDL
git-cpan-version:  1.27
git-cpan-authorid: MKUTTER
git-cpan-file:     authors/id/M/MK/MKUTTER/SOAP-WSDL-1.27.tar.gz
This commit is contained in:
Martin Kutter
2009-12-12 19:48:16 -08:00
committed by Michael G. Schwern
parent 7ca2154ad6
commit 2bad767211
389 changed files with 2374 additions and 28345 deletions
Download Patch File Download Diff File Expand all files Collapse all files
t/SOAP/WSDL.t
-73
View File
@@ -1,73 +0,0 @@
use strict;
use warnings;
use Test::More tests => 12;
use File::Spec;
use File::Basename;
use_ok qw(SOAP::WSDL);
my $path = File::Spec->rel2abs(dirname( __FILE__ ) );
my $soap = SOAP::WSDL->new();
$soap->wsdl("file://$path/WSDL_NOT_FOUND.wsdl");
eval { $soap->wsdlinit() };
like $@, qr{ does \s not \s exist }x, 'does not exist';
eval { $soap = SOAP::WSDL->new(
wsdl => "file://$path/WSDL_NOT_FOUND.wsdl");
};
like $@, qr{ does \s not \s exist }x, 'does not exist (constructor)';
$soap = SOAP::WSDL->new();
$soap->wsdl( "file://$path/WSDL_EMPTY_DEFINITIONS.wsdl");
eval { $soap->wsdlinit() };
like $@, qr{ unable \s to \s extract \s schema \s from \s WSDL }x, 'empty definition';
# Try out all call() variants
eval { $soap->call('NewOperation', 'value'); };
like $@, qr{ unable \s to \s extract \s schema \s from \s WSDL }x, 'empty definition';
$soap = SOAP::WSDL->new();
$soap->wsdl( "file://$path/WSDL_NO_MESSAGE.wsdl");
eval { $soap->wsdlinit() };
eval { $soap->call('NewOperation', 'value'); };
like $@, qr{ Message \s \{http://www.example.org/WSDL_1/\}NewOperationRequest \s not \s found }x, 'empty definition';
$soap = SOAP::WSDL->new();
$soap->wsdl( "file://$path/WSDL_1.wsdl");
$soap->wsdlinit();
$soap->no_dispatch(1);
like $soap->call('NewOperation', NewOperation => { in => 'test' }), qr{ <in>test</in> }x;
like $soap->call('NewOperation', { NewOperation => { in => 'test' } }), qr{ <in>test</in> }x;
$soap = SOAP::WSDL->new( wsdl => "file://$path/WSDL_1.wsdl",
servicename => 'NewService',
portname => 'NewPort',
no_dispatch => 1,
keep_alive => 1,
);
$soap->proxy('http://example.org');
like $soap->call('NewOperation', NewOperation => { in => 'test' }), qr{ <in>test</in> }x;
like $soap->call('NewOperation', { NewOperation => { in => 'test' } }), qr{ <in>test</in> }x;
$soap = SOAP::WSDL->new( wsdl => "file://$path/WSDL_NO_BINDING.wsdl",
servicename => 'NewService',
portname => 'NewPort',
no_dispatch => 1,
);
eval {
$soap->call('NewOperation', { NewOperation => { in => 'test' } });
};
like $@, qr{ no \s binding }x, 'No binding error';
$soap = SOAP::WSDL->new( wsdl => "file://$path/WSDL_NO_PORTTYPE.wsdl",
servicename => 'NewService',
portname => 'NewPort',
no_dispatch => 1,
);
eval {
$soap->call('NewOperation', { NewOperation => { in => 'test' } });
};
like $@, qr{ cannot \s find \s portType }x, 'No porttype error';
t/SOAP/WSDL/01_use.t
-7
View File
@@ -1,7 +0,0 @@
use Test::More tests => 3;
use lib '../lib';
use_ok(qw/SOAP::WSDL/);
ok( SOAP::WSDL->new(), 'Instantiated object' );
eval { SOAP::WSDL->new( grzlmpfh => 'unknown')};
ok $@, 'die on illegal parameter';
t/SOAP/WSDL/02_port.t
-31
View File
@@ -1,31 +0,0 @@
use Test::More tests => 7;
use strict;
use warnings;
use diagnostics;
use Cwd;
use lib '../lib';
use File::Basename;
use File::Spec;
my $path = File::Spec->rel2abs( dirname __FILE__ );
my ($volume, $dir) = File::Spec->splitpath($path, 1);
my @dir_from = File::Spec->splitdir($dir);
unshift @dir_from, $volume if $volume;
my $url = join '/', @dir_from;
use_ok(qw/SOAP::WSDL/);
my $soap;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $url . '/../../acceptance/wsdl/02_port.wsdl'
), 'Instantiated object' );
ok( ($soap->servicename('testService') ), 'set service' );
ok( ($soap->portname('testPort2') ) ,'set portname');
ok( $soap->wsdlinit(), 'parsed WSDL' );
ok( $soap->wsdlinit( servicename => 'testService', portname => 'testPort'), 'parsed WSDL' );
ok( ($soap->portname() eq 'testPort' ), 'found port passed to wsdlinit');
t/SOAP/WSDL/03_complexType-all.t
-85
View File
@@ -1,85 +0,0 @@
use Test::More tests => 7;
use strict;
use warnings;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use File::Basename;
use File::Spec;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@)
{
$SKIP = "Test::Differences required for testing. ";
}
my $path = File::Spec->rel2abs( dirname __FILE__ );
my ($volume, $dir) = File::Spec->splitpath($path, 1);
my @dir_from = File::Spec->splitdir($dir);
unshift @dir_from, $volume if $volume;
my $url = join '/', @dir_from;
# print $url;
use_ok(qw/SOAP::WSDL/);
print "# SOAP::WSDL Version: $SOAP::WSDL::VERSION\n";
my $xml;
my $soap;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $url . '/../../acceptance/wsdl/03_complexType-all.wsdl',
), 'Instantiated object' );
#3
ok $soap->wsdlinit(
checkoccurs => 1,
servicename => 'testService',
), 'parse WSDL';
ok $soap->no_dispatch(1), 'set no dispatch';
# won't work without - would require SOAP::WSDL::Deserializer::SOM,
# which requires SOAP::Lite
$soap->outputxml(1);
ok ($xml = $soap->call('test',
testAll => {
Test1 => 'Test 1',
Test2 => [ 'Test 2', 'Test 3' ]
}
), 'Serialized complexType' );
# print $xml;
# $soap->wsdl_checkoccurs(1);
TODO: {
local $TODO = "not implemented yet";
eval
{
$xml = $soap->call('test',
testAll => {
Test1 => 'Test 1',
Test2 => [ 'Test 2', 'Test 3' ]
}
);
};
ok( ($@ =~m/illegal\snumber\sof\selements/),
"Died on illegal number of elements (too many)"
);
eval {
$xml = $soap->call('test',
testAll => {
Test1 => 'Test 1',
}
);
};
ok($@, 'Died on illegal number of elements (not enough)');
}
t/SOAP/WSDL/03_complexType-choice.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 2;
use lib '../lib';
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement tests";
fail "serialize choice element";
}
t/SOAP/WSDL/03_complexType-complexContent.t
-22
View File
@@ -1,22 +0,0 @@
use Test::More tests => 2;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing. $@";
}
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement <complexContent> tests";
fail "serialize complexContent element";
}
t/SOAP/WSDL/03_complexType-element-ref.t
-41
View File
@@ -1,41 +0,0 @@
use Test::More tests => 4;
use strict;
use warnings;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use File::Basename;
use File::Spec
use_ok(qw/SOAP::WSDL/);
print "# SOAP::WSDL Version: $SOAP::WSDL::VERSION\n";
my $path = File::Spec->rel2abs( dirname __FILE__ );
my ($volume, $dir) = File::Spec->splitpath($path, 1);
my @dir_from = File::Spec->splitdir($dir);
unshift @dir_from, $volume if $volume;
my $url = join '/', @dir_from;
my $xml;
my $soap;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $url . '/../../acceptance/wsdl/03_complexType-element-ref.wsdl',
no_dispatch => 1,
), 'Instantiated object' );
# won't work without - would require SOAP::WSDL::Deserializer::SOM,
# which requires SOAP::Lite
$soap->outputxml(1);
ok ($xml = $soap->call('test',
testAll => {
Test2 => 'Test2',
TestRef => 'TestRef'
}
), 'Serialized complexType' );
like $xml, qr{<SOAP-ENV:Body><testAll><TestRef>TestRef</TestRef><Test2>Test2</Test2></testAll></SOAP-ENV:Body>}
, 'element ref="" serialization';
t/SOAP/WSDL/03_complexType-group.t
-22
View File
@@ -1,22 +0,0 @@
use Test::More tests => 2;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing. $@";
}
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement <group> support";
fail "serialize group element";
}
t/SOAP/WSDL/03_complexType-sequence.t
-80
View File
@@ -1,80 +0,0 @@
BEGIN {
use Test::More tests => 6;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@)
{
$SKIP = "Test::Differences required for testing. $@";
}
}
use_ok(qw/SOAP::WSDL/);
my $xml;
my $path = File::Spec->rel2abs( dirname __FILE__ );
my ($volume, $dir) = File::Spec->splitpath($path, 1);
my @dir_from = File::Spec->splitdir($dir);
unshift @dir_from, $volume if $volume;
my $url = join '/', @dir_from;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $url . '/../../acceptance/wsdl/03_complexType-sequence.wsdl'
), 'Instantiated object' );
#3
ok( $soap->wsdlinit(
checkoccurs => 1,
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
# won't work without - would require SOAP::WSDL::Deserializer::SOM,
# which requires SOAP::Lite
$soap->outputxml(1);
#4
ok $xml = $soap->call('test',
testSequence => {
Test1 => 'Test 1',
Test2 => 'Test 2',
}
), 'Serialized complexType';
TODO: {
local $TODO = "not implemented yet";
#5
eval
{
$xml = $soap->call('test',
testSequence => {
Test1 => 'Test 1',
}
);
};
ok( ($@),
"Died on illegal number of elements"
);
#6
eval
{
$xml = $soap->call('test',
testSequence => {
Test1 => 'Test 1',
Test2 => [ 1, 2, 3, ]
}
);
};
ok( ($@),
"Died on illegal number of elements"
);
};
t/SOAP/WSDL/03_complexType-simpleContent.t
-22
View File
@@ -1,22 +0,0 @@
use Test::More tests => 2;
use lib '../lib';
use lib 't/lib';
use lib 'lib';
use Cwd;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing. $@";
}
use_ok qw/SOAP::WSDL/;
my $soap = SOAP::WSDL->new();
TODO: {
local $TODO="implement <simpleContent> support";
fail "serialize simpleContent element";
}
t/SOAP/WSDL/04_element-complexType.t
-4
View File
@@ -1,4 +0,0 @@
use Test::More skip_all => 'TODO: implement tests';
use lib '../lib';
t/SOAP/WSDL/04_element-simpleType.t
-49
View File
@@ -1,49 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use lib '../lib';
use lib 't/lib';
use File::Basename;
use File::Spec;
my $path = File::Spec->rel2abs( dirname __FILE__ );
my ($volume, $dir) = File::Spec->splitpath($path, 1);
my @dir_from = File::Spec->splitdir($dir);
unshift @dir_from, $volume if $volume;
my $url = join '/', @dir_from;
use_ok(qw/SOAP::WSDL/);
my $xml;
my $soap = undef;
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $url . '/../../acceptance/wsdl/04_element-simpleType.wsdl'
), 'Instantiated object' );
# won't work without - would require SOAP::WSDL::Deserializer::SOM,
# which requires SOAP::Lite
$soap->outputxml(1);
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
ok ( $xml = $soap->call('test', testElement1 => 1 ) ,
'Serialized (simpler) element' );
TODO: {
local $TODO="implement min/maxOccurs checks";
eval { $soap->call('test', testAll => [ 2, 3 ] ); };
like $@, qr{illegal\snumber\sof\selements}, "Died on illegal number of elements (too many)";
eval { $soap->call('test', testAll => undef ) };
ok $@, 'Died on illegal number of elements (not enough)';
}
t/SOAP/WSDL/04_element.t
-70
View File
@@ -1,70 +0,0 @@
use Test::More tests => 8;
use strict;
use warnings;
use lib '../lib';
use lib 't/lib';
use File::Spec;
use File::Basename;
our $SKIP;
eval "use Test::SOAPMessage";
if ($@) {
$SKIP = "Test::Differences required for testing.";
}
use_ok(qw/SOAP::WSDL/);
my $soap;
my $xml;
my $path = File::Spec->rel2abs( dirname __FILE__ );
my ($volume, $dir) = File::Spec->splitpath($path, 1);
my @dir_from = File::Spec->splitdir($dir);
unshift @dir_from, $volume if $volume;
my $url = join '/', @dir_from;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $url . '/../../acceptance/wsdl/04_element.wsdl'
), 'Instantiated object' );
#3
$soap->readable(1);
$soap->outputxml(1);
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
ok ($xml = $soap->call('test',
testElement1 => 'Test'
), 'Serialized (simple) element' );
ok ($xml = $soap->call('testRef',
testElementRef => 'Test'
), 'Serialized (simple) element' );
like $xml
, qr{<testElementRef\s\sxmlns="urn:Test">Test</testElementRef></SOAP-ENV:Body></SOAP-ENV:Envelope>}
, 'element ref serialization result'
;
TODO: {
local $TODO="implement min/maxOccurs checks";
eval {
$xml = $soap->call('test',
testAll => [ 'Test 2', 'Test 3' ]
);
};
ok( ($@ =~m/illegal\snumber\sof\selements/),
"Died on illegal number of elements (too many)"
);
eval {
$xml = $soap->call('test', testAll => undef );
};
ok($@, 'Died on illegal number of elements (not enough)');
}
t/SOAP/WSDL/05_simpleType-list.t
-53
View File
@@ -1,53 +0,0 @@
use Test::More tests => 8;
use strict;
use lib '../lib';
use lib 't/lib';
use File::Basename;
use File::Spec;
my $path = File::Spec->rel2abs( dirname __FILE__ );
my ($volume, $dir) = File::Spec->splitpath($path, 1);
my @dir_from = File::Spec->splitdir($dir);
unshift @dir_from, $volume if $volume;
my $url = join '/', @dir_from;
use_ok(qw/SOAP::WSDL/);
my ($soap, $xml, $xml2);
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $url . '/../../acceptance/wsdl/05_simpleType-list.wsdl'
), 'Instantiated object' );
# won't work without - would require SOAP::WSDL::Deserializer::SOM,
# which requires SOAP::Lite
$soap->outputxml(1);
#3
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
#4
ok $xml = $soap->call('test', testAll => [ 1, 2 ] ), 'Serialize list call';
#5
ok ( $xml2 = $soap->call('test', testAll => "1 2" ) , 'Serialized scalar call' );
#6
ok( $xml eq $xml2, 'Got expected result');
#7
TODO: {
local $TODO = "implement minLength check";
eval { $xml = $soap->call('test', testAll => undef ) };
ok($@, 'Died on illegal number of elements (not enough)');
}
#8
TODO: {
local $TODO = "maxLength test not implemented";
eval { $xml = $soap->call('test', testAll => [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 ] ) };
ok($@, 'Died on illegal number of elements (more than maxLength)');
}
t/SOAP/WSDL/05_simpleType-restriction.t
-63
View File
@@ -1,63 +0,0 @@
use Test::More tests => 8;
use strict;
use warnings;
use diagnostics;
use File::Spec;
use File::Basename;
use lib '../lib';
use lib 't/lib';
use File::Basename;
use File::Spec;
my $path = File::Spec->rel2abs( dirname __FILE__ );
my ($volume, $dir) = File::Spec->splitpath($path, 1);
my @dir_from = File::Spec->splitdir($dir);
unshift @dir_from, $volume if $volume;
my $url = join '/', @dir_from;
use_ok(qw/SOAP::WSDL/);
my $xml;
my $soap;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $url . '/../../acceptance/wsdl/05_simpleType-restriction.wsdl'
), 'Instantiated object' );
#3
ok( $soap->wsdlinit(
servicename => 'testService',
), 'parsed WSDL' );
$soap->no_dispatch(1);
$soap->autotype(0);
# won't work without - would require SOAP::WSDL::Deserializer::SOM,
# which requires SOAP::Lite
$soap->outputxml(1);
#4
ok $xml = $soap->call('test', testAll => [ 1, 2 ] ) , 'Serialize list call';
# print $xml, "\n";
TODO: {
local $TODO = "implement minLength/maxLength checks";
eval { $soap->call('test', testAll => [ 1, 2, 3 ] ) };
ok($@, 'Died on illegal number of elements (too many)');
eval { $soap->call('test', testAll => [] ) };
ok($@, 'Died on illegal number of elements (not enough)');
}
TODO: {
local $TODO = "minValue check not implemented ";
eval { $xml = $soap->call('test', testAll => 0 ) };
ok($@, 'Died on illegal value');
}
TODO: {
local $TODO = "maxValue check not implemented ";
eval { $xml = $soap->call('test', testAll => 100 ) };
ok($@, 'Died on illegal value');
}
t/SOAP/WSDL/05_simpleType-union.t
-61
View File
@@ -1,61 +0,0 @@
use Test::More skip_all => 'Not supported yet';
use strict;
use warnings;
use File::Spec;
use File::Basename;
use_ok qw/SOAP::WSDL/;
my $xml;
my $soap = undef;
my $path = File::Spec->rel2abs( dirname __FILE__ );
#2
ok $soap = SOAP::WSDL->new(
wsdl => 'file:///' . $path . '/t/acceptance/wsdl/05_simpleType-union.wsdl'
), 'Instantiated object';
#3
ok $soap->wsdlinit(), 'parsed WSDL';
$soap->no_dispatch(1);
# won't work without - would require SOAP::WSDL::Deserializer::SOM,
# which requires SOAP::Lite
$soap->outputxml(1);
#4
ok $xml = $soap->call('test', testAll => 1 ) , 'Serialized call';
# 6
eval {
$xml = $soap->serializer->method(
$soap->call('test',
testAll => [ 1 , 'union']
)
)
};
ok($@, 'Died on illegal number of elements (not enough)');
eval {
$xml = $soap->serializer->method(
$soap->call('test',
testAll => undef
)
)
};
ok($@, 'Died on illegal number of elements (not enough)');
#8
ok ( $xml = $soap->serializer->method( $soap->call('test2',
testAll => 1 )
),
'Serialized (simple) call (list)' );
#9
eval {
$xml = $soap->serializer->method(
$soap->call('test',
testAll => [ 1 , 'union']
)
)
};
ok($@, 'Died on illegal number of elements (not enough)');
t/SOAP/WSDL/06_keep_alive.t
-34
View File
@@ -1,34 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use diagnostics;
use lib '../lib';
use File::Basename;
use File::Spec;
my $path = File::Spec->rel2abs( dirname __FILE__ );
my ($volume, $dir) = File::Spec->splitpath($path, 1);
my @dir_from = File::Spec->splitdir($dir);
unshift @dir_from, $volume if $volume;
my $url = join '/', @dir_from;
use_ok(qw/SOAP::WSDL/);
my $soap;
#2
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $url . '/../../acceptance/wsdl/02_port.wsdl',
keep_alive => 1,
), 'Instantiated object' );
ok( ($soap->servicename('testService') ), 'set service' );
ok( ($soap->portname('testPort2') ) ,'set portname');
ok( $soap->wsdlinit(), 'parsed WSDL' );
eval {
$soap = SOAP::WSDL->new(
wsdl => 'file:///' . $path . '/../../acceptance/wsdl/FOOBAR',
keep_alive => 1,
);
};
like $@, qr{ does \s not \s exist }x, 'error on non-existant WSDL';
t/SOAP/WSDL/11_helloworld.NET.t
-55
View File
@@ -1,55 +0,0 @@
#!/usr/bin/perl -w
#######################################################################################
#
# 2_helloworld.t
#
# Acceptance test for message encoding, based on .NET wsdl and example code.
# SOAP::WSDL's encoding doesn't I<exactly> match the .NET example, because
# .NET doesn't always specify types (SOAP::WSDL does), and the namespace
# prefixes chosen are different (maybe the encoding style, too ? this would be a bug !)
#
########################################################################################
use strict;
use Test::More tests => 4;
use lib '../../../lib/';
use File::Basename;
use File::Spec;
my $path = File::Spec->rel2abs( dirname __FILE__ );
my ($volume, $dir) = File::Spec->splitpath($path, 1);
my @dir_from = File::Spec->splitdir($dir);
unshift @dir_from, $volume if $volume;
my $url = join '/', @dir_from;
use_ok q/SOAP::WSDL/;
### test vars END
print "# Testing SOAP::WSDL ". $SOAP::WSDL::VERSION."\n";
print "# Acceptance test against sample output with simple WSDL\n";
my $data = {
name => 'test',
givenName => 'test',
};
my $soap = undef;
ok $soap = SOAP::WSDL->new(
wsdl => 'file://'.$url.'/../../acceptance/wsdl/11_helloworld.wsdl',
no_dispatch => 1
), 'Create SOAP::WSDL object';
# won't work without - would require SOAP::WSDL::Deserializer::SOM,
# which requires SOAP::Lite
$soap->outputxml(1);
$soap->proxy('http://helloworld/helloworld.asmx');
ok $soap->wsdlinit(
servicename => 'Service1',
), 'wsdlinit';
ok $soap->call('sayHello', 'sayHello' => $data), 'soap call';
t/SOAP/WSDL/12_binding.t
-28
View File
@@ -1,28 +0,0 @@
use strict;
use warnings;
use lib '../../../lib';
use Test::More tests => 4;
use SOAP::WSDL;
use File::Basename;
use File::Spec;
my $path = File::Spec->rel2abs( dirname __FILE__ );
my ($volume, $dir) = File::Spec->splitpath($path, 1);
my @dir_from = File::Spec->splitdir($dir);
unshift @dir_from, $volume if $volume;
my $url = join '/', @dir_from;
print "# Using SOAP::WSDL Version $SOAP::WSDL::VERSION\n";
# chdir to my location
my $soap = undef;
my $proxy = 'http://127.0.0.1/testPort';
ok( $soap = SOAP::WSDL->new(
wsdl => 'file://' . $url . '/../../acceptance/wsdl/02_port.wsdl'
) );
ok $soap->wsdlinit( url => $proxy );
ok $soap->servicename('testService');
ok $soap->portname('testPort');
t/SOAP/WSDL/Client/Base.t
-65
View File
@@ -1,65 +0,0 @@
package MyPart;
use Class::Std::Fast;
package main;
use strict;
use warnings;
use Test::More qw(no_plan);
use_ok qw(SOAP::WSDL::Client::Base);
my $client = SOAP::WSDL::Client::Base->new();
{
no warnings qw(redefine once);
*SOAP::WSDL::Client::call = sub { is $_[1]->{ operation }, 'sayHello', 'Called method';
return $_[2], $_[3];
};
}
my @result = $client->call({
operation => 'sayHello',
soap_action => 'urn:HelloWorld#sayHello',
style => 'document',
body => {
'use' => 'literal',
namespace => '',
encodingStyle => '',
parts => [qw( SOAP::WSDL::XSD::Typelib::Builtin::string )],
},
header => {
parts => [qw( SOAP::WSDL::XSD::Typelib::Builtin::string )],
},
headerfault => {
}
}, { value => 'Body' }, { value => 'Header' });
is $result[0], 'Body';
is $result[1], 'Header';
isa_ok $result[0], 'SOAP::WSDL::XSD::Typelib::Builtin::string';
@result = $client->call({
operation => 'sayHello',
soap_action => 'urn:HelloWorld#sayHello',
style => 'document',
body => {
'use' => 'literal',
namespace => '',
encodingStyle => '',
parts => [qw( SOAP::WSDL::XSD::Typelib::Builtin::string )],
},
header => {
parts => [qw( SOAP::WSDL::XSD::Typelib::Builtin::string )],
},
headerfault => {
}
}, SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => 'Body2' }),
SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => 'Header2' })
);
is $result[0], 'Body2';
is $result[1], 'Header2';
isa_ok $result[1], 'SOAP::WSDL::XSD::Typelib::Builtin::string';
t/SOAP/WSDL/Deserializer/Hash.t
-39
View File
@@ -1,39 +0,0 @@
use Test::More tests => 13;
use lib '../../../lib';
use_ok qw(SOAP::WSDL::Deserializer::Hash);
# Try all instanciation variants
ok my $deserializer = SOAP::WSDL::Deserializer::Hash->new();
ok $deserializer = SOAP::WSDL::Deserializer::Hash->new({
class_resolver => 'SomeFunkyClass',
});
ok my $data = $deserializer->deserialize(q{<a><b>1</b><b>2</b><c>3</c></a>});
is $data->{a}->{b}->[0], 1;
is $data->{a}->{b}->[1], 2;
is $data->{a}->{c}, 3;
# need 3 elements in array to trigger all branches...
# need ignorable whitespace to trigger removal...
ok $data = $deserializer->deserialize(
q{<a>
<b><c>1</c></b>
<b><c>2</c></b>
<b><c>3</c></b>
</a>});
is $data->{a}->{b}->[0]->{c}, 1;
is $data->{a}->{b}->[1]->{c}, 2;
eval { $deserializer->deserialize('grzlmpfh') };
ok $@->isa('SOAP::WSDL::SOAP::Typelib::Fault11');
my $fault = $deserializer->generate_fault({
message => 'Foo',
code => 'Bar',
role => 'mine',
});
is $fault->get_faultstring(), 'Foo';
$fault = $deserializer->generate_fault({});
is $fault->get_faultstring(), 'Unknown error';
t/SOAP/WSDL/Deserializer/SOM.t
-37
View File
@@ -1,37 +0,0 @@
use Test::More;
eval { require SOAP::Lite; 1; } or do {
plan skip_all => 'SOAP::Lite not available';
exit 0;
};
print "# Using SOAP::Lite $SOAP::Lite::VERSION\n";
use lib '../../../lib';
plan tests => 10;
use_ok qw(SOAP::WSDL::Deserializer::SOM);
ok my $deserializer = SOAP::WSDL::Deserializer::SOM->new();
ok my $som = $deserializer->deserialize(q{<a><b>1</b><b>2</b><c>3</c></a>});
my $data = $som->match('/a')->valueof;
is $data->{ c } , 3;
SKIP: {
skip "SOAP::Lite > 0.69 required" , 2 if ($SOAP::Lite::VERSION lt '0.69');
is $data->{ b }->[0] , 1, "array values - SOAP::Lite $SOAP::Lite::VERSION";;
is $data->{ b }->[1] , 2, "array values - SOAP::Lite $SOAP::Lite::VERSION";;
}
eval { $deserializer->generate_fault({
role => 'soap:Server',
code => 'Test',
message => 'Teststring'
});
};
ok $@->isa('SOAP::Fault');
is $@->faultcode(), 'Test';
is $@->faultactor(), 'soap:Server';
is $@->faultstring(), 'Teststring';
t/SOAP/WSDL/Deserializer/XSD.t
-27
View File
@@ -1,27 +0,0 @@
use strict;
use warnings;
package TestResolver;
sub get_typemap { {} };
package main;
use Test::More tests => 8;
use SOAP::WSDL::Deserializer::XSD;
my $obj;
ok $obj = SOAP::WSDL::Deserializer::XSD->new();
ok $obj = SOAP::WSDL::Deserializer::XSD->new({
class_resolver => 'TestResolver',
some_other_option => 'ignored',
});
my $fault = $obj->generate_fault();
is $fault->get_faultstring(), 'Unknown error';
is $fault->get_faultactor(), 'urn:localhost';
is $fault->get_faultcode(), 'soap:Client';
isa_ok $obj->deserialize('rubbeldiekatz'), 'SOAP::WSDL::SOAP::Typelib::Fault11';
isa_ok $obj->deserialize('<zumsel></zumsel>'), 'SOAP::WSDL::SOAP::Typelib::Fault11';
isa_ok $obj->deserialize('<Envelope xmlns="huchmampf"></Envelope>'), 'SOAP::WSDL::SOAP::Typelib::Fault11';
t/SOAP/WSDL/Expat/Base.t
-12
View File
@@ -1,12 +0,0 @@
use strict;
use warnings;
use Test::More tests => 3;
use_ok qw(SOAP::WSDL::Expat::Base);
my $parser = SOAP::WSDL::Expat::Base->new();
eval { $parser->parse('Foobar')};
ok $@;
eval { $parser->parsefile('Foobar')};
ok $@;
t/SOAP/WSDL/Factory/Deserializer.t
-21
View File
@@ -1,21 +0,0 @@
use strict;
use warnings;
use Test::More tests => 3;
use SOAP::WSDL::Factory::Serializer;
eval { SOAP::WSDL::Factory::Serializer->get_serializer({
soap_version => 'zumsl'
}) };
like $@, qr{^no serializer};
ok my $serializer = SOAP::WSDL::Factory::Serializer->get_serializer({
soap_version => '1.1'
});
SOAP::WSDL::Factory::Serializer->register('1.1', 'Hope_You_Have_No_Such_Package_Installed');
eval { SOAP::WSDL::Factory::Serializer->get_serializer({
soap_version => '1.1'
}) };
like $@, qr{^Cannot load};
t/SOAP/WSDL/Factory/Serializer.t
-21
View File
@@ -1,21 +0,0 @@
use strict;
use warnings;
use Test::More tests => 3;
use SOAP::WSDL::Factory::Deserializer;
eval { SOAP::WSDL::Factory::Deserializer->get_deserializer({
soap_version => 'zumsl'
}) };
like $@, qr{^no deserializer};
ok my $serializer = SOAP::WSDL::Factory::Deserializer->get_deserializer({
soap_version => '1.1'
});
SOAP::WSDL::Factory::Deserializer->register('1.1', 'Hope_You_Have_No_Such_Package_Installed');
eval { SOAP::WSDL::Factory::Deserializer->get_deserializer({
soap_version => '1.1'
}) };
like $@, qr{^Cannot load};
t/SOAP/WSDL/Factory/Transport.t
-20
View File
@@ -1,20 +0,0 @@
use strict;
use warnings;
use Test::More tests => 5;
use Scalar::Util qw(blessed);
use SOAP::WSDL::Factory::Transport;
eval { SOAP::WSDL::Factory::Transport->get_transport('zumsl') };
like $@, qr{^no transport};
ok my $obj = SOAP::WSDL::Factory::Transport->get_transport('http');
ok blessed $obj;
SOAP::WSDL::Factory::Transport->register('zumsl', 'Hope_You_Have_No_Such_Package_Installed');
eval { SOAP::WSDL::Factory::Transport->get_transport('zumsl') };
like $@, qr{^Cannot load};
eval { SOAP::WSDL::Factory::Transport->register( \'zumsl', 'Foo') };
like $@, qr{^Cannot use reference};
t/SOAP/WSDL/Generator/Template.t
-69
View File
@@ -1,69 +0,0 @@
use strict;
use warnings;
use Test::More qw(no_plan);
use Template;
use File::Basename;
use File::Spec;
use SOAP::WSDL::Expat::WSDLParser;
use SOAP::WSDL::Generator::Template::XSD;
my $path = dirname __FILE__;
my $parser = SOAP::WSDL::Expat::WSDLParser->new();
$parser->parse_file("$path/../../../acceptance/wsdl/006_sax_client.wsdl");
#"$path/../../../../example/wsdl/globalweather.xml");
my $definitions = $parser->get_data();
my $generator = SOAP::WSDL::Generator::Template::XSD->new({
definitions => $definitions,
});
my $output = q{};
$generator->generate_typemap({
NO_POD => 1,
output => \$output,
});
ok eval $output;
print $@ if $@;
#print $output;
$output = q{};
$generator->generate_interface({
NO_POD => 1,
output => \$output,
});
ok eval $output;
print $@ if $@;
# print $output;
__END__
my $tt = Template->new(
DEBUG => 1,
EVAL_PERL => 1,
RECURSION => 1,
INCLUDE_PATH => "$path/../../../../lib/SOAP/WSDL/Template",
);
foreach my $service (@{ $definitions->get_service }) {
my $output;
$tt->process( 'Interface.tt', {
definitions => $definitions,
service => $service,
interface_prefix => 'MyInterface',
type_prefix => 'MyTypes',
TYPE_PREFIX => 'MyTypes',
element_prefix => 'MyElement',
}, \$output);
die $tt->error if $tt->error();
ok eval $output, 'eval output';
print $output;
};
t/SOAP/WSDL/Generator/Visitor.t
-22
View File
@@ -1,22 +0,0 @@
use Test::More tests => 15;;
use SOAP::WSDL::Generator::Visitor;
my $visitor = SOAP::WSDL::Generator::Visitor->new();
is undef, $visitor->visit_Definitions();
is undef, $visitor->visit_Binding();
is undef, $visitor->visit_Message();
is undef, $visitor->visit_Operation();
is undef, $visitor->visit_OpMessage();
is undef, $visitor->visit_Part();
is undef, $visitor->visit_Port();
is undef, $visitor->visit_PortType();
is undef, $visitor->visit_Service();
is undef, $visitor->visit_SoapOperation();
is undef, $visitor->visit_Types();
# XML Schema stuff
is undef, $visitor->visit_XSD_Schema();
is undef, $visitor->visit_XSD_ComplexType();
is undef, $visitor->visit_XSD_Element();
is undef, $visitor->visit_XSD_SimpleType();
t/SOAP/WSDL/Generator/Visitor/Typemap.t
-140
View File
@@ -1,140 +0,0 @@
use strict;
use warnings;
use Test::More tests => 5;
use File::Basename;
use File::Spec;
my $path = File::Spec->rel2abs( dirname __FILE__ );
use_ok qw(SOAP::WSDL::Generator::Visitor::Typemap);
my $visitor;
ok $visitor = SOAP::WSDL::Generator::Visitor::Typemap->new(), 'constructor';
use SOAP::WSDL::Expat::WSDLParser;
my $parser = SOAP::WSDL::Expat::WSDLParser->new();
$parser->parse_file(
$path . '/../../../../acceptance/wsdl/'
#. '04_element.wsdl'
#. '11_helloworld.wsdl'
#. '008_complexType.wsdl'
. '006_sax_client.wsdl'
);
my $definitions = $parser->get_data();
$definitions->_accept( $visitor );
my $typemap = $visitor->get_typemap();
is $typemap->{'EnqueueMessage/MMessage/MKeepalive'}, 'MyTypes::TKeepalive', 'content';
is $typemap->{'EnqueueMessageResponse'}, 'MyElements::EnqueueMessageResponse', 'content';
is $typemap->{'KeepaliveMessageResponse'}, 'MyElements::KeepaliveMessageResponse', 'content';
sub wsdl {
q{<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns:http="http://schemas.xmlsoap.org/wsdl/http/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:s="http://www.w3.org/2001/XMLSchema"
xmlns:s0="urn:HelloWorld"
xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:tm="http://microsoft.com/wsdl/mime/textMatching/"
xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/"
targetNamespace="urn:HelloWorld"
xmlns="http://schemas.xmlsoap.org/wsdl/">
<types>
<s:schema elementFormDefault="qualified"
targetNamespace="urn:HelloWorld">
<s:element name="sayHello">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="name"
type="s:string" />
<s:element minOccurs="0" maxOccurs="1" name="givenName"
type="s:string" nillable="1"/>
<!-- <s:element minOccurs="0" maxOccurs="1" name="test"
type="s0:test2" /> //-->
</s:sequence>
</s:complexType>
</s:element>
<s:element name="sayHelloResponse">
<s:complexType>
<s:sequence>
<s:element minOccurs="0" maxOccurs="1"
name="sayHelloResult" type="s:string" />
</s:sequence>
</s:complexType>
</s:element>
<s:complexType name="test2">
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="name"
type="s:string" />
<s:element minOccurs="0" maxOccurs="1" name="givenName"
type="s:string" />
</s:sequence>
</s:complexType>
<s:complexType name="testExtended">
<s:extension base="s0:test2">
<s:sequence>
<s:element minOccurs="0" maxOccurs="1" name="extend"
type="s:string" />
</s:sequence>
</s:extension>
</s:complexType>
</s:schema>
</types>
<message name="sayHelloSoapIn">
<part name="parameters" element="s0:sayHello" />
<!-- <part name="test1" type="s0:testExtended" />
<part name="test2" type="s0:test2"
targetNamespace="urn:test2" /> //-->
</message>
<message name="sayHelloSoapOut">
<part name="parameters" element="s0:sayHelloResponse" />
</message>
<portType name="Service1Soap">
<operation name="sayHello">
<input message="s0:sayHelloSoapIn" />
<output message="s0:sayHelloSoapOut" />
</operation>
</portType>
<binding name="Service1Soap" type="s0:Service1Soap">
<soap:binding transport="http://schemas.xmlsoap.org/soap/http"
style="document" />
<operation name="sayHello">
<soap:operation soapAction="urn:HelloWorld#sayHello"
style="document" />
<input>
<soap:body use="literal" />
</input>
<output>
<soap:body use="literal" />
</output>
</operation>
</binding>
<service name="Service1">
<port name="Service1Soap" binding="s0:Service1Soap">
<soap:address
location="http://helloworld/helloworld.asmx" />
</port>
</service>
</definitions>
}
}
t/SOAP/WSDL/Generator/XCS.t
-25
View File
@@ -1,25 +0,0 @@
use strict;
use warnings;
use Test::More;
use File::Spec;
use File::Basename;
eval { require XML::Compile::WSDL11 }
or plan skip_all => 'Cannot test without XML::Compile::WSDL11';
eval { require XML::LibXML }
or plan skip_all => 'Cannot test without XML::LibXML';
plan skip_all => 'XML::Compile::WSDL11 is not functional yet';
plan tests => qw(no_plan);
my $path = File::Spec->rel2abs( dirname __FILE__ );
my $libxml = XML::LibXML->new();
my $xml = $libxml->parse_file("$path/../../../acceptance/wsdl/generator_test.wsdl");
my $wsdl = XML::Compile::WSDL11->new($xml);
my $schemas = $wsdl->schemas;
my $operation = $wsdl->operation('testHeader');
my $client = $operation->prepareClient();
t/SOAP/WSDL/Generator/XSD.t
-153
View File
@@ -1,153 +0,0 @@
use Test::More tests => 38;
use File::Basename qw(dirname);
use File::Spec;
use File::Path;
my $path = File::Spec->rel2abs( dirname __FILE__ );
use_ok qw(SOAP::WSDL::Generator::Visitor::Typelib);
use_ok qw(SOAP::WSDL::Generator::Template::XSD);
use SOAP::WSDL::Expat::WSDLParser;
my $parser = SOAP::WSDL::Expat::WSDLParser->new();
my $definitions = $parser->parse_file(
"$path/../../../acceptance/wsdl/generator_test.wsdl"
#"$path/../../../acceptance/wsdl/elementAtomicComplexType.xml"
);
my $generator = SOAP::WSDL::Generator::Template::XSD->new({
definitions => $definitions,
type_prefix => 'Foo',
element_prefix => 'Foo',
typemap_prefix => 'Foo',
OUTPUT_PATH => "$path/testlib",
});
my $code = "";
$generator->set_output(\$code);
$generator->generate_typelib();
{
eval $code;
ok !$@;
print $@ if $@;
}
# print $code;
$generator->set_type_prefix('MyTypes');
$generator->set_element_prefix('MyElements');
$generator->set_typemap_prefix('MyTypemaps');
$generator->set_interface_prefix('MyInterfaces');
$generator->set_output(undef);
$generator->generate();
#$generator->generate_typelib();
#$generator->generate_typemap();
if (eval { require Test::Warn; }) {
Test::Warn::warning_like( sub { $generator->generate_interface() },
qr{\A Multiple \s parts \s detected \s in \s message \s testMultiPartWarning}xms);
}
else {
$generator->generate_interface();
SKIP: { skip 'Cannot test warnings without Test::Warn', 1 };
}
$generator->generate_server();
eval "use lib '$path/testlib'";
use_ok qw( MyInterfaces::testService::testPort );
my $interface;
ok $interface = MyInterfaces::testService::testPort->new(), 'instanciate interface';
$interface->set_no_dispatch(1);
my $message;
ok $message = $interface->testHeader( { Test1 => 'Test1', Test2 => 'Test2'}
, { Test1 => 'Header1', Test2 => 'Header2'}), 'call soap method (no_dispatch)';
use_ok qw(SOAP::WSDL::Expat::MessageParser);
use_ok qw(MyTypemaps::testService);
$parser = SOAP::WSDL::Expat::MessageParser->new({
class_resolver => 'MyTypemaps::testService'
});
ok $parser->parse_string($message), 'parse message with header';
ok $parser->get_header()->get_Test1(), 'Header1';ok $message = $interface->testChoice( { Test1 => 'Test1' } ), 'call soap method (no_dispatch)';
ok $parser->get_header()->get_Test2(), 'Header2';
ok $parser->get_data()->get_Test1(), 'Test1';
ok $parser->get_data()->get_Test2(), 'Test2';
use_ok qw(SOAP::WSDL::Transport::Loopback);
$interface->set_no_dispatch(undef);
$interface->set_transport(undef);
$interface->set_proxy('http://127.0.0.1/Test');
for (1..2) {
my ($body, $header) = $interface->testHeader( { Test1 => 'Test1', Test2 => 'Test2'} , { Test1 => 'Header1', Test2 => 'Header2'});
is $header->get_Test1(), 'Header1', 'Header content';
is $header->get_Test2(), 'Header2', 'Header content';
}
# complexType choice test
ok $message = $interface->testChoice( { Test1 => 'Test1' } ), 'call soap method (no_dispatch)';
ok $message = $interface->testChoice( { Test2 => 'Test2' } ), 'call soap method (no_dispatch)';
TODO: {
local $TODO = 'implement content check';
eval { $interface->testChoice( { Test1 => 'Test1', Test2 => 'Test2' } ) };
ok $@, 'fail on both choice options';
}
#
ok eval { require MyTypes::testComplexTypeRestriction };
my $complexRestriction = MyTypes::testComplexTypeRestriction->new();
$complexRestriction->set_Test1('Test');
is $complexRestriction->get_Test1(), 'Test';
$complexRestriction = MyTypes::testComplexTypeRestriction->new({
Test1 => 'test1',
Test2 => 'test2',
});
is $complexRestriction->get_Test1(), 'test1';
is $complexRestriction->get_Test2(), 'test2';
ok eval { require MyTypes::testComplexTypeExtension };
$complexExtension = MyTypes::testComplexTypeExtension->new({
Test1 => 'test1',
Test2 => 'test2',
Test3 => 'test3',
});
is $complexExtension->get_Test1(), 'test1';
is $complexExtension->get_Test2(), 'test2';
is $complexExtension->get_Test3(), 'test3';
ok eval { require MyTypes::testComplexTypeElementAtomicSimpleType; };
my $ct_east = MyTypes::testComplexTypeElementAtomicSimpleType->new({
testString => 'Just some test',
testAtomicSimpleTypeElement => 42,
testAtomicSimpleTypeElement2 => 23,
});
is $ct_east->get_testAtomicSimpleTypeElement, 42;
is $ct_east->get_testAtomicSimpleTypeElement->get_value(), 42;
isa_ok($ct_east->get_testAtomicSimpleTypeElement,
'MyTypes::testComplexTypeElementAtomicSimpleType::_testAtomicSimpleTypeElement');
is $ct_east->get_testAtomicSimpleTypeElement2, 23;
is $ct_east->get_testAtomicSimpleTypeElement2->get_value(), 23;
isa_ok($ct_east->get_testAtomicSimpleTypeElement2,
'MyTypes::testComplexTypeElementAtomicSimpleType::_testAtomicSimpleTypeElement2');
rmtree "$path/testlib";
t/SOAP/WSDL/Generator/XSD_unsupported.t
-24
View File
@@ -1,24 +0,0 @@
use Test::More tests => 3;
use File::Basename qw(dirname);
use File::Spec;
my $path = File::Spec->rel2abs( dirname __FILE__ );
use_ok qw(SOAP::WSDL::Generator::Visitor::Typelib);
use_ok qw(SOAP::WSDL::Generator::Template::XSD);
use SOAP::WSDL::Expat::WSDLParser;
my $parser = SOAP::WSDL::Expat::WSDLParser->new();
my $definitions = $parser->parse_file(
"$path/../../../acceptance/wsdl/generator_unsupported_test.wsdl"
);
my $generator = SOAP::WSDL::Generator::Template::XSD->new({
definitions => $definitions,
});
{
eval { $generator->generate_typelib() };
}
ok $@;
t/SOAP/WSDL/Part.t
-44
View File
@@ -1,44 +0,0 @@
package MyTypelib;
use strict;
use warnings;
sub find_element {};
sub find_type {};
package main;
use strict;
use warnings;
use Test::More tests => 5;
use_ok qw(SOAP::WSDL::Part);
my $typelib = {};
eval { SOAP::WSDL::Part->serialize() };
like $@, qr{No typelib};
my $opt = {
typelib => 'MyTypelib',
namespace => { foo => 'bar'}
};
my $data = {};
my $part = SOAP::WSDL::Part->new();
eval { $part->serialize('name', $data, $opt ) };
like $@, qr{Neither type nor element};
$part->set_type('foo:Foo');
eval { $part->serialize('name', $data, $opt ) };
like $@, qr{type foo:Foo};
$part->set_type(undef);
$part->set_element('foo:Foo');
eval { $part->serialize('name', $data, $opt ) };
like $@, qr{element foo:Foo};
t/SOAP/WSDL/Serializer/XSD.t
-13
View File
@@ -1,13 +0,0 @@
use strict;
use warnings;
use Test::More qw(no_plan);
use_ok qw(SOAP::WSDL::Serializer::XSD);
my $serializer = SOAP::WSDL::Serializer::XSD->new();
like $serializer->serialize(), qr{<SOAP-ENV:Body></SOAP-ENV:Body>}, 'empty body';
like $serializer->serialize({ body => {} }), qr{<SOAP-ENV:Body></SOAP-ENV:Body>}, 'empty body';
like $serializer->serialize({ body => [] }), qr{<SOAP-ENV:Body></SOAP-ENV:Body>}, 'empty body';
like $serializer->serialize({ header => {}, body => [] }),
qr{<SOAP-ENV:Header></SOAP-ENV:Header><SOAP-ENV:Body></SOAP-ENV:Body>}, 'empty header and body';
t/SOAP/WSDL/Server.t
-62
View File
@@ -1,62 +0,0 @@
package MyDeserializer;
use Class::Std::Fast;
require Test::More;
my %class_resolver_of :ATTR(:name<class_resolver> :default<()>);
sub generate_fault {
Test::More::pass("generate fault on $_[1]->{ message }");
return $_[1]->{ message };
}
sub deserialize {
return ('Body', 'Header');
}
package MyDeserializer2;
use Class::Std::Fast;
sub deserialize {
die "Deserialize";
}
sub generate_fault {
Test::More::like($_[1]->{ message }, qr{\A Error \s deserializing }x, 'Generate fault on deserialize error' );
return $_[1]->{ message };
}
package MyHandler;
sub test {
return 'Test';
}
package main;
use strict;
use warnings;
use HTTP::Request;
use Test::More qw(no_plan);
use_ok qw(SOAP::WSDL::Server);
my $server = SOAP::WSDL::Server->new();
$server->set_deserializer('MyDeserializer');
eval { $server->handle(HTTP::Request->new()) };
like $@, qr{\A No \s handler}x, 'No handler fault caught';
$server->set_dispatch_to('MyHandler');
eval { $server->handle(HTTP::Request->new()) };
like $@, qr{\A Not \s found: \sNo \s SOAPAction \s given}x, 'No SOAPAction fault caught';
my $request = HTTP::Request->new();
$request->header('SOAPAction', 'Test');
$server->set_dispatch_to('MyHandler');
eval { $server->handle($request) };
like $@, qr{\A Not \s found: \sNo \s method \s found \s for \s the \s SOAPAction \s 'Test'}x, 'No SOAPAction fault caught';
$server->set_action_map_ref({ Test => 'test2'});
eval { $server->handle($request) };
like $@, qr{\A Not \s implemented:}x, 'Not implemented fault caught';
$server->set_deserializer('MyDeserializer2');
eval { $server->handle(HTTP::Request->new()) };
like $@, qr{\A Error \s deserializing}x, 'Error deserializing caught';
t/SOAP/WSDL/Server/CGI.t
-80
View File
@@ -1,80 +0,0 @@
package MyTypemap;
sub get_typemap { return {} };
package HandlerClass;
sub bar {
return "Verdammte Axt";
}
package main;
use Test::More;
eval "require IO::Scalar"
or plan skip_all => 'IO::Scalar required for testing...';
plan tests => 8;
use_ok(SOAP::WSDL::Server);
use_ok(SOAP::WSDL::Server::CGI);
my $server = SOAP::WSDL::Server::CGI->new({
class_resolver => 'MyTypemap',
});
$server->set_action_map_ref({
'testaction' => 'testmethod',
});
{
no warnings qw(once);
*IO::Scalar::BINMODE = sub {};
}
my $output = q{};
my $fh = IO::Scalar->new(\$output);
my $stdout = *STDOUT;
*STDOUT = $fh;
$server->handle();
like $output, qr{ \A Status: \s 411 \s Length \s Required}x;
$output = q{};
$ENV{'CONTENT_LENGTH'} = '0e0';
$server->handle();
like $output, qr{ Error \s deserializing }xsm;
$output = q{};
$server->set_action_map_ref({
'foo' => 'bar',
});
$server->set_dispatch_to( 'HandlerClass' );
$server->handle();
like $output, qr{no \s element \s found}xms;
$output = q{};
$ENV{REQUEST_METHOD} = 'POST';
$ENV{HTTP_SOAPACTION} = 'test';
$server->handle();
like $output, qr{no \s element \s found}xms;
$output = q{};
delete $ENV{HTTP_SOAPACTION};
$ENV{EXPECT} = 'Foo';
$ENV{HTTP_SOAPAction} = 'foo';
$server->handle();
like $output, qr{no \s element \s found}xms;
$output = q{};
$ENV{EXPECT} = '100-Continue';
$ENV{HTTP_SOAPAction} = 'foo';
$server->handle();
like $output, qr{100 \s Continue}xms;
$output = q{};
*STDOUT = $stdout;
# print $output;
t/SOAP/WSDL/Transport/01_Test.t
-49
View File
@@ -1,49 +0,0 @@
use Test::More tests => 9;
use strict;
use warnings;
use File::Basename;
use SOAP::WSDL::Client;
my $soap;
my $base_dir = dirname( __FILE__ );
use_ok(qw/SOAP::WSDL::Transport::Test/);
$soap = SOAP::WSDL::Client->new();
$soap->set_proxy('http://somewhere.over.the.rainbow');
$soap->get_transport->set_base_dir( join '/', $base_dir, 'acceptance' );
ok $soap->get_transport->get_base_dir();
{
local $SIG{__WARN__} = sub {};
my $response = $soap->call({ operation => 'test', soap_action => 'http://test' }, {});
ok ! $response, 'Returned fault on error';
is $response->get_faultcode(), 'soap:Server', 'faultcode';
is $response->get_faultactor(), 'urn:localhost', 'faultactor';
$soap->outputxml(1);
$response = $soap->call({ operation => 'test', soap_action => 'http://test2' }, {});
is $response, 'test2', 'Returned file content';
}
SKIP: {
eval { require SOAP::WSDL::Deserializer::SOM; }
or skip 'SOAP::WSDL::Deserializer::SOM required', 3;
# requre SOAP::WSDL::Factory::Deserializer;
SOAP::WSDL::Factory::Deserializer->register('1.1', 'SOAP::WSDL::Deserializer::SOM');
my $soap_som = SOAP::WSDL::Client->new();
$soap_som->set_proxy('http://somewhere.over.the.rainbow');
$soap_som->get_transport->set_base_dir( join '/', $base_dir, 'acceptance' );
my $som;
ok $som = $soap_som->call({ operation => 'test', soap_action => 'http://test3' }, {})
, 'Call with SOAP::WSDL::Deserializer::SOM';
# In the somewhat weird logic of SOAP::Lite, the first node inside the root element
# is the reault, all others are output parameters (and may be accessed via "paramsout")
is $som->result(), 'Munich', 'Result match';
is $som->paramsout(), 'Germany' , 'Output parameter match';
}
t/SOAP/WSDL/Transport/02_HTTP.t
-20
View File
@@ -1,20 +0,0 @@
use Test::More tests => 6;
use strict;
use utf8;
use SOAP::WSDL::Transport::HTTP;
my $transport = SOAP::WSDL::Transport::HTTP->new();
ok $transport->is_success(1);
ok $transport->code(200);
ok $transport->status('200 OK');
ok $transport->message('OK');
my $result = $transport->send_receive(envelope => 'Test', action => 'foo');
ok ! $transport->is_success();
$result = $transport->send_receive(encoding => 'utf8', envelope => 'ÄÖÜ',
action => 'foo');
ok ! $transport->is_success();
t/SOAP/WSDL/Transport/acceptance/test2.xml
-1
View File
@@ -1 +0,0 @@
test2
t/SOAP/WSDL/Transport/acceptance/test3.xml
-1
View File
@@ -1 +0,0 @@
<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" ><SOAP-ENV:Body><GetWeatherResponse xmlns="http://www.webserviceX.NET"><CityName>Munich</CityName><CountryName>Germany</CountryName></GetWeatherResponse></SOAP-ENV:Body></SOAP-ENV:Envelope>
t/SOAP/WSDL/Typelib/Fault11.t
-22
View File
@@ -1,22 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
# use_ok fails to trigger Class::Std's overloading attributes
use SOAP::WSDL::SOAP::Typelib::Fault11;
my $fault = SOAP::WSDL::SOAP::Typelib::Fault11->new({
faultcode => 'soap:Server',
faultstring => 'Fault message',
});
ok "$fault", 'stringification';
if ($fault) { fail 'boolify' } else { pass 'boolify' }
ok ! $fault->as_bool() , 'as_bool';
is $fault->get_xmlns(), 'http://schemas.xmlsoap.org/soap/envelope/';
is $fault->get_faultcode(), 'soap:Server', 'content';
is $fault->get_faultstring(), 'Fault message', 'content';
t/SOAP/WSDL/XSD/ComplexType.t
-11
View File
@@ -1,11 +0,0 @@
use strict;
use warnings;
use Test::More tests => 2; #qw(no_plan);
use_ok qw(SOAP::WSDL::XSD::ComplexType);
my $obj = SOAP::WSDL::XSD::ComplexType->new();
$obj->set_flavor('extension');
eval { $obj->serialize('foo') };
like $@, qr{sorry, \s we \s just}xsm;
t/SOAP/WSDL/XSD/Element.t
-43
View File
@@ -1,43 +0,0 @@
package Foo;
sub serialize {
return "serialized $_[1] $_[2]";
}
package main;
use strict;
use warnings;
use Test::More tests => 12;
use_ok qw(SOAP::WSDL::XSD::Element);
my $element = SOAP::WSDL::XSD::Element->new();
is $element->first_simpleType(), undef;
$element->set_simpleType('Foo');
is $element->first_simpleType(), 'Foo';
$element->set_simpleType( [ 'Foo', 'Bar' ]);
is $element->first_simpleType(), 'Foo';
is $element->first_complexType(), undef;
$element->set_complexType('Foo');
is $element->first_complexType(), 'Foo';
$element->set_complexType( [ 'Foo', 'Bar' ]);
is $element->first_complexType(), 'Foo';
$element->set_default('Foo');
is $element->serialize('Foobar', undef, { namespace => {} } ), 'serialized Foobar Foo';
$element->set_name('Bar');
is $element->serialize(undef, undef, { namespace => {} } ), 'serialized Bar Foo';
$element->set_fixed('Foobar');
is $element->serialize(undef, undef, { namespace => {} } ), 'serialized Bar Foobar';
$element->set_abstract('1');
is $element->serialize('Bar', undef, { namespace => {} } ), 'serialized Bar Foobar';
eval { $element->serialize(undef, undef, { namespace => {} } ) };
like $@, qr{cannot \s serialize \s abstract}xms;
t/SOAP/WSDL/XSD/SimpleType.t
-33
View File
@@ -1,33 +0,0 @@
use strict;
use warnings;
use Test::More tests => 11;
use_ok qw(SOAP::WSDL::XSD::SimpleType);
my $obj = SOAP::WSDL::XSD::SimpleType->new();
$obj->set_list({ LocalName => 'foo', Value => 'bar'},
{ LocalName => 'itemType', Value => 'xsd:int'} );
is $obj->get_flavor(), 'list';
is $obj->get_itemType(), 'xsd:int';
is $obj->serialize('Foo', ['Foo', 'Bar']), '<Foo>Foo Bar</Foo>';
$obj->set_union({ LocalName => 'foo', Value => 'bar'},
{ LocalName => 'memberTypes', Value => 'xsd:int'} );
is $obj->get_flavor(), 'union';
is $obj->get_base()->[0], 'xsd:int';
$obj->set_union({ LocalName => 'foo', Value => 'bar'},
{ LocalName => 'memberTypes', Value => 'xsd:int xsd:string'} );
is $obj->get_flavor(), 'union';
is $obj->get_base()->[1], 'xsd:string';
is $obj->serialize('Foo', 'Foobar'), '<Foo>Foobar</Foo>';
$obj->set_flavor('enumeration');
is $obj->serialize('Foo', 'Foobar'), '<Foo>Foobar</Foo>';
# TODO die on non-serializable content...
$obj->set_flavor('');
is $obj->serialize('Foo', 'Foobar'), '';
t/SOAP/WSDL/XSD/Typelib/Builtin/01_constructors.t
-104
View File
@@ -1,104 +0,0 @@
use Test::More tests => 176;
use Scalar::Util qw(blessed);
# use SOAP::WSDL::XSD::Typelib::Builtin::anyType;
use SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType;
use SOAP::WSDL::XSD::Typelib::Builtin::anyURI;
use SOAP::WSDL::XSD::Typelib::Builtin::base64Binary;
use SOAP::WSDL::XSD::Typelib::Builtin::boolean;
use SOAP::WSDL::XSD::Typelib::Builtin::byte;
use SOAP::WSDL::XSD::Typelib::Builtin::date;
use SOAP::WSDL::XSD::Typelib::Builtin::dateTime;
use SOAP::WSDL::XSD::Typelib::Builtin::decimal;
use SOAP::WSDL::XSD::Typelib::Builtin::double;
use SOAP::WSDL::XSD::Typelib::Builtin::duration;
use SOAP::WSDL::XSD::Typelib::Builtin::ENTITY;
use SOAP::WSDL::XSD::Typelib::Builtin::float;
use SOAP::WSDL::XSD::Typelib::Builtin::gDay;
use SOAP::WSDL::XSD::Typelib::Builtin::gMonth;
use SOAP::WSDL::XSD::Typelib::Builtin::gMonthDay;
use SOAP::WSDL::XSD::Typelib::Builtin::gYear;
use SOAP::WSDL::XSD::Typelib::Builtin::gYearMonth;
use SOAP::WSDL::XSD::Typelib::Builtin::hexBinary;
use SOAP::WSDL::XSD::Typelib::Builtin::ID;
use SOAP::WSDL::XSD::Typelib::Builtin::IDREF;
use SOAP::WSDL::XSD::Typelib::Builtin::IDREFS;
use SOAP::WSDL::XSD::Typelib::Builtin::int;
use SOAP::WSDL::XSD::Typelib::Builtin::integer;
use SOAP::WSDL::XSD::Typelib::Builtin::language;
use SOAP::WSDL::XSD::Typelib::Builtin::long;
use SOAP::WSDL::XSD::Typelib::Builtin::Name;
use SOAP::WSDL::XSD::Typelib::Builtin::NCName;
use SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN;
use SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS;
use SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger;
use SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger;
use SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger;
use SOAP::WSDL::XSD::Typelib::Builtin::normalizedString;
use SOAP::WSDL::XSD::Typelib::Builtin::NOTATION;
use SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger;
use SOAP::WSDL::XSD::Typelib::Builtin::QName;
use SOAP::WSDL::XSD::Typelib::Builtin::short;
use SOAP::WSDL::XSD::Typelib::Builtin::string;
use SOAP::WSDL::XSD::Typelib::Builtin::time;
use SOAP::WSDL::XSD::Typelib::Builtin::token;
use SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte;
use SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt;
use SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong;
use SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort;
for (
qw(
SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType
SOAP::WSDL::XSD::Typelib::Builtin::anyURI
SOAP::WSDL::XSD::Typelib::Builtin::base64Binary
SOAP::WSDL::XSD::Typelib::Builtin::boolean
SOAP::WSDL::XSD::Typelib::Builtin::byte
SOAP::WSDL::XSD::Typelib::Builtin::date
SOAP::WSDL::XSD::Typelib::Builtin::dateTime
SOAP::WSDL::XSD::Typelib::Builtin::decimal
SOAP::WSDL::XSD::Typelib::Builtin::double
SOAP::WSDL::XSD::Typelib::Builtin::duration
SOAP::WSDL::XSD::Typelib::Builtin::ENTITY
SOAP::WSDL::XSD::Typelib::Builtin::float
SOAP::WSDL::XSD::Typelib::Builtin::gDay
SOAP::WSDL::XSD::Typelib::Builtin::gMonth
SOAP::WSDL::XSD::Typelib::Builtin::gMonthDay
SOAP::WSDL::XSD::Typelib::Builtin::gYear
SOAP::WSDL::XSD::Typelib::Builtin::gYearMonth
SOAP::WSDL::XSD::Typelib::Builtin::hexBinary
SOAP::WSDL::XSD::Typelib::Builtin::ID
SOAP::WSDL::XSD::Typelib::Builtin::IDREF
SOAP::WSDL::XSD::Typelib::Builtin::IDREFS
SOAP::WSDL::XSD::Typelib::Builtin::int
SOAP::WSDL::XSD::Typelib::Builtin::integer
SOAP::WSDL::XSD::Typelib::Builtin::language
SOAP::WSDL::XSD::Typelib::Builtin::long
SOAP::WSDL::XSD::Typelib::Builtin::Name
SOAP::WSDL::XSD::Typelib::Builtin::NCName
SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger
SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN
SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS
SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger
SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger
SOAP::WSDL::XSD::Typelib::Builtin::normalizedString
SOAP::WSDL::XSD::Typelib::Builtin::NOTATION
SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger
SOAP::WSDL::XSD::Typelib::Builtin::QName
SOAP::WSDL::XSD::Typelib::Builtin::short
SOAP::WSDL::XSD::Typelib::Builtin::string
SOAP::WSDL::XSD::Typelib::Builtin::time
SOAP::WSDL::XSD::Typelib::Builtin::token
SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte
SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt
SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong
SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort
) ) {
my $obj = $_->new();
ok blessed $obj;
is $obj->get_value(), undef;
$obj = $_->new({});
ok blessed $obj;
is $obj->get_value(), undef;
}
t/SOAP/WSDL/XSD/Typelib/Builtin/ENTITY.t
-19
View File
@@ -1,19 +0,0 @@
use Test::More tests => 9;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::ENTITY;
my $ENTITY = SOAP::WSDL::XSD::Typelib::Builtin::ENTITY->new();
is $ENTITY->get_value(), undef;
$ENTITY->set_value(127);
is "$ENTITY", "127", 'stringification';
ok $ENTITY = SOAP::WSDL::XSD::Typelib::Builtin::ENTITY->new({ value => 127 });
is "$ENTITY", "127", 'stringification';
undef $ENTITY;
$ENTITY = SOAP::WSDL::XSD::Typelib::Builtin::ENTITY->new({});
is $ENTITY->get_value(), undef;
ok $ENTITY = SOAP::WSDL::XSD::Typelib::Builtin::ENTITY->new({ value => 127 });
is "$ENTITY", "127", 'stringification';
is $ENTITY->get_value(), "127", 'stringification';
ok $ENTITY->isa('SOAP::WSDL::XSD::Typelib::Builtin::NCName'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/ID.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 5;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::ID;
my $ID = SOAP::WSDL::XSD::Typelib::Builtin::ID->new();
is $ID->get_value(), undef;
$ID = SOAP::WSDL::XSD::Typelib::Builtin::ID->new({});
is $ID->get_value(), undef;
ok $ID = SOAP::WSDL::XSD::Typelib::Builtin::ID->new({ value => 'Test' });
is "$ID", 'Test', 'stringification';
ok $ID->isa('SOAP::WSDL::XSD::Typelib::Builtin::NCName'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/IDREF.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 5;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::IDREF;
my $IDREF = SOAP::WSDL::XSD::Typelib::Builtin::IDREF->new();
is $IDREF->get_value(), undef;
$IDREF = SOAP::WSDL::XSD::Typelib::Builtin::IDREF->new({});
is $IDREF->get_value(), undef;
ok $IDREF = SOAP::WSDL::XSD::Typelib::Builtin::IDREF->new({ value => 127 });
is "$IDREF", "127", 'stringification';
ok $IDREF->isa('SOAP::WSDL::XSD::Typelib::Builtin::NCName'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/IDREFS.t
-16
View File
@@ -1,16 +0,0 @@
use Test::More tests => 8;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::IDREFS;
my $IDREFS = SOAP::WSDL::XSD::Typelib::Builtin::IDREFS->new();
is $IDREFS->get_value(), undef;
$IDREFS = SOAP::WSDL::XSD::Typelib::Builtin::IDREFS->new({});
is $IDREFS->get_value(), undef;
ok $IDREFS = SOAP::WSDL::XSD::Typelib::Builtin::IDREFS->new({ value => [ 127 , 'Test' ] });
is $IDREFS->serialize(), "127 Test", 'stringification';
ok $IDREFS = SOAP::WSDL::XSD::Typelib::Builtin::IDREFS->new({ value => 'Test' });
is "$IDREFS", "Test", 'stringification';
ok $IDREFS->isa('SOAP::WSDL::XSD::Typelib::Builtin::IDREF'), 'inheritance';
ok $IDREFS->isa('SOAP::WSDL::XSD::Typelib::Builtin::list'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/NCName.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 5;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::NCName;
my $NCName = SOAP::WSDL::XSD::Typelib::Builtin::NCName->new();
is $NCName->get_value(), undef;
$NCName = SOAP::WSDL::XSD::Typelib::Builtin::NCName->new({});
is $NCName->get_value(), undef;
ok $NCName = SOAP::WSDL::XSD::Typelib::Builtin::NCName->new({ value => 'Test' });
is "$NCName", "Test", 'stringification';
ok $NCName->isa('SOAP::WSDL::XSD::Typelib::Builtin::Name'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKEN.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 5;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::token;
my $token = SOAP::WSDL::XSD::Typelib::Builtin::token->new();
is $token->get_value(), undef;
$token = SOAP::WSDL::XSD::Typelib::Builtin::token->new({});
is $token->get_value(), undef;
ok $token = SOAP::WSDL::XSD::Typelib::Builtin::token->new({ value => 127 });
is "$token", "127", 'stringification';
ok $token->isa('SOAP::WSDL::XSD::Typelib::Builtin::normalizedString'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/NMTOKENS.t
-21
View File
@@ -1,21 +0,0 @@
use Test::More tests => 9;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS;
my $NMTOKENS = SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS->new();
is $NMTOKENS->get_value(), undef;
$NMTOKENS = SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS->new({});
is $NMTOKENS->get_value(), undef;
ok $NMTOKENS = SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS->new({ value => [ 127 , 'Test' ] });
is $NMTOKENS->serialize, '127 Test', 'stringification';
ok $NMTOKENS = SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS->new({ value => 'Test' });
is "$NMTOKENS", "Test", 'stringification';
$NMTOKENS = SOAP::WSDL::XSD::Typelib::Builtin::NMTOKENS->new({ value => undef });
is $NMTOKENS, undef, 'stringification';
ok $NMTOKENS->isa('SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN'), 'inheritance';
ok $NMTOKENS->isa('SOAP::WSDL::XSD::Typelib::Builtin::list'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/NOTATION.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 5;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::NOTATION;
my $NOTATION = SOAP::WSDL::XSD::Typelib::Builtin::NOTATION->new();
is $NOTATION->get_value(), undef;
$NOTATION = SOAP::WSDL::XSD::Typelib::Builtin::NOTATION->new({});
is $NOTATION->get_value(), undef;
ok $NOTATION = SOAP::WSDL::XSD::Typelib::Builtin::NOTATION->new({ value => 'Test' });
is "$NOTATION", "Test", 'stringification';
ok $NOTATION->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/Name.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 5;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::Name;
my $Name = SOAP::WSDL::XSD::Typelib::Builtin::Name->new();
is $Name->get_value(), undef;
$Name = SOAP::WSDL::XSD::Typelib::Builtin::Name->new({});
is $Name->get_value(), undef;
ok $Name = SOAP::WSDL::XSD::Typelib::Builtin::Name->new({ value => 'xsd:Test' });
is "$Name", "xsd:Test", 'stringification';
ok $Name->isa('SOAP::WSDL::XSD::Typelib::Builtin::normalizedString'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/anySimpleType.t
-62
View File
@@ -1,62 +0,0 @@
use strict;
use warnings;
use Test::More tests => 23;
use Scalar::Util qw(blessed);
use lib '../../../../../../lib';
use_ok qw(SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType);
my $obj = SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType->new();
my $id = ${ $obj };
undef $obj;
$obj = SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType->new();
is ${ $obj }, $id;
ok blessed $obj, 'constructor returned blessed reference';
$obj = SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType->new({ value => 'test1' });
ok blessed $obj, 'constructor returned blessed reference';
is $obj->get_value(), 'test1', 'get_value';
is $obj->get_xmlns(), 'http://www.w3.org/2001/XMLSchema', 'get_xmlns';
is $obj->start_tag({ name => 'test' }), '<test >', 'start_tag';
is $obj->end_tag({ name => 'test' }), '</test >', 'end_tag';
ok $obj->set_value('test'), 'set_value';
is $obj->get_value(), 'test', 'get_value';
is "$obj", q{test}, 'stringification overloading';
is $obj->serialize, q{test}, 'stringification overloading';
ok ($obj)
? pass 'boolean overloading'
: fail 'boolean overloading';
ok ! $obj->set_value(undef), 'set_value with explicit undef';
is $obj->get_value(), undef, 'get_value';
{
no warnings qw(uninitialized);
is "$obj", q{}, 'stringification overloading';
}
is $obj->serialize, q{}, 'stringification overloading';
ok $obj = SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType->new({
value => 'test2',
});
is $obj->get_value(), 'test2', 'get_value on attr value';
$obj->set_value(undef);
is $obj->serialize({ name => 'foo' }), '<foo ></foo >'
, 'serialize undef value with name';
is $obj->serialize(), q{}, 'serialize undef value without name';
ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anyType'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/anyType.t
-32
View File
@@ -1,32 +0,0 @@
use strict;
use warnings;
use Test::More tests => 3;
use Scalar::Util qw(blessed);
use_ok qw(SOAP::WSDL::XSD::Typelib::Builtin::anyType);
is SOAP::WSDL::XSD::Typelib::Builtin::anyType->get_xmlns(), 'http://www.w3.org/2001/XMLSchema', 'get_xmlns';
is SOAP::WSDL::XSD::Typelib::Builtin::anyType->serialize(), q{}, 'serialize to empty';
exit 0;
__END__
# cannot instantiate abstract type...
my $obj = SOAP::WSDL::XSD::Typelib::Builtin::anyType->new();
ok blessed $obj, 'constructor returned blessed reference';
$obj = SOAP::WSDL::XSD::Typelib::Builtin::anyType->new({
xmlns => 'urn:Siemens.mosaic'
});
ok blessed $obj, 'constructor returned blessed reference';
is $obj->get_xmlns(), 'http://www.w3.org/2001/XMLSchema', 'get_xmlns';
is $obj->start_tag({ name => 'test' }), '<test >', 'start_tag';
is $obj->end_tag({ name => 'test' }), '</test >', 'end_tag';
is "$obj", q{}, 'serialize overloading';
t/SOAP/WSDL/XSD/Typelib/Builtin/anyURI.t
-14
View File
@@ -1,14 +0,0 @@
use Test::More tests => 7;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::anyURI;
my $anyURI = SOAP::WSDL::XSD::Typelib::Builtin::anyURI->new();
is $anyURI->get_value(), undef;
$anyURI = SOAP::WSDL::XSD::Typelib::Builtin::anyURI->new({});
is $anyURI->get_value(), undef;
ok $anyURI = SOAP::WSDL::XSD::Typelib::Builtin::anyURI->new({ value => 'isbn:1234567' });
is "$anyURI", "isbn:1234567", 'stringification';
ok $anyURI->set_value('http://example.org');
is "$anyURI", 'http://example.org', 'stringification';
$anyURI = SOAP::WSDL::XSD::Typelib::Builtin::anyURI->new();
ok $anyURI->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/base64Binary.t
-15
View File
@@ -1,15 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::base64Binary;
my $obj = SOAP::WSDL::XSD::Typelib::Builtin::base64Binary->new();
{
no warnings qw(uninitialized);
is "$obj", '', 'stringification';
}
ok defined $obj;
ok $obj->set_value('AAAA==');
ok $obj = SOAP::WSDL::XSD::Typelib::Builtin::base64Binary->new({ value => 'AAAA==' });
is "$obj", 'AAAA==', 'stringification';
ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/boolean.t
-68
View File
@@ -1,68 +0,0 @@
use Test::More tests => 29;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::boolean;
my $bool;
$bool = SOAP::WSDL::XSD::Typelib::Builtin::boolean->new();
ok defined $bool;
is "$bool", '', 'serialized undef to empty string';
$bool = SOAP::WSDL::XSD::Typelib::Builtin::boolean->new({});
ok defined $bool;
ok $bool = SOAP::WSDL::XSD::Typelib::Builtin::boolean->new({ value => 'true' });
is $bool * 1 , 1, 'numerification';
ok $bool, 'boolification';
is $bool->serialize(), 'true', 'serialization';
$bool->set_value('1');
is $bool->serialize(), 'true';
is "$bool", 1, 'stringification';
$bool ? pass 'boolification' : fail 'boolification';
$bool->set_value('0');
is $bool->serialize(), 'false';
! $bool ? pass 'boolification' : fail 'boolification';
$bool->set_value(undef);
is $bool->serialize(), 'false';
! $bool ? pass 'boolification' : fail 'boolification';
$bool->set_value('false');
if ($bool) {
fail 'boolification';
}
else {
pass 'boolification';
}
is "$bool", '0', 'stringification';
ok $bool->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType'), 'inheritance';
is $bool->serialize({ name => 'test'}), '<test >false</test >';
is $bool->serialize(), 'false';
$bool->delete_value();
is $bool->serialize, '', 'serialized undef to empty string';
is "$bool", '', 'stringified undef to empty string';
$bool->set_value('');
is $bool->serialize, 'false', 'serialized empty string to false';
is "$bool", 0, 'stringified empty string to 0';
$SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType::___value->{ ${ $bool } } = 'true';
is $bool->serialize(), 'true', 'serialization';
is "$bool", 1, 'stringification';
is 3 * $bool, 3, 'numerification';
$SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType::___value->{ ${ $bool } } = 'false';
is $bool->serialize(), 'false', 'serialization';
is "$bool", 0, 'numerification';
is 3 * $bool, 0, 'stringification';
t/SOAP/WSDL/XSD/Typelib/Builtin/byte.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::byte;
my $byte = SOAP::WSDL::XSD::Typelib::Builtin::byte->new();
ok defined $byte;
ok $byte->set_value('127');
ok $byte = SOAP::WSDL::XSD::Typelib::Builtin::byte->new({ value => 127 });
is $byte * 1, 127, 'numerification';
is "$byte", "127", 'stringification';
ok $byte->isa('SOAP::WSDL::XSD::Typelib::Builtin::short'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/date.t
-81
View File
@@ -1,81 +0,0 @@
use Test::More tests => 30;
use strict;
use warnings;
#use Carp qw(cluck);
#
#$SIG{__WARN__} = sub { cluck @_ };
#use warnings;
use lib '../lib';
use Date::Format;
use Date::Parse;
use_ok('SOAP::WSDL::XSD::Typelib::Builtin::date');
my $obj;
sub timezone {
my @time = map { defined $_ ? $_ : 0 } strptime shift;
my $tz = strftime('%z', @time);
substr $tz, -2, 0, ':';
return $tz;
}
my %dates = (
'2007/12/31' => '2007-12-31',
'2007:08:31' => '2007-08-31',
'30 Aug 2007' => '2007-08-30',
);
my %localized_date_of = (
'2007-12-31T00:00:00.0000000+0000' => '2007-12-31+00:00',
'2007-12-31T00:00:00.0000000+0130' => '2007-12-31+01:30',
'2007-12-31T00:00:00.0000000+0200' => '2007-12-31+02:00',
'2007-12-31T00:00:00.0000000+0300' => '2007-12-31+03:00',
'2007-12-31T00:00:00.0000000+0400' => '2007-12-31+04:00',
'2007-12-31T00:00:00.0000000+0500' => '2007-12-31+05:00',
'2007-12-31T00:00:00.0000000+0600' => '2007-12-31+06:00',
'2007-12-31T00:00:00.0000000+0700' => '2007-12-31+07:00',
'2007-12-31T00:00:00.0000000+0800' => '2007-12-31+08:00',
'2007-12-31T00:00:00.0000000+0900' => '2007-12-31+09:00',
'2007-12-31T00:00:00.0000000+1000' => '2007-12-31+10:00',
'2007-12-31T00:00:00.0000000+1100' => '2007-12-31+11:00',
'2007-12-31T00:00:00.0000000+1200' => '2007-12-31+12:00',
'2007-12-31T00:00:00.0000000-0100' => '2007-12-31-01:00',
'2007-12-31T00:00:00.0000000-0200' => '2007-12-31-02:00',
'2007-12-31T00:00:00.0000000-0300' => '2007-12-31-03:00',
'2007-12-31T00:00:00.0000000-0400' => '2007-12-31-04:00',
'2007-12-31T00:00:00.0000000-0500' => '2007-12-31-05:00',
'2007-12-31T00:00:00.0000000-0600' => '2007-12-31-06:00',
'2007-12-31T00:00:00.0000000-0700' => '2007-12-31-07:00',
'2007-12-31T00:00:00.0000000-0800' => '2007-12-31-08:00',
'2007-12-31T00:00:00.0000000-0900' => '2007-12-31-09:00',
'2007-12-31T00:00:00.0000000-1000' => '2007-12-31-10:00',
'2007-12-31T00:00:00.0000000-1100' => '2007-12-31-11:00',
'2007-12-31T00:00:00.0000000-1200' => '2007-12-31-12:00',
);
$obj = SOAP::WSDL::XSD::Typelib::Builtin::date->new();
$obj = SOAP::WSDL::XSD::Typelib::Builtin::date->new({});
$obj = SOAP::WSDL::XSD::Typelib::Builtin::date->new({
value => '2007-12-31'
});
while (my ($date, $converted) = each %localized_date_of ) {
$obj = SOAP::WSDL::XSD::Typelib::Builtin::date->new();
$obj->set_value( $date );
is $obj->get_value() , $converted , 'conversion';
}
while (my ($date, $converted) = each %dates ) {
$obj = SOAP::WSDL::XSD::Typelib::Builtin::date->new();
$obj->set_value( $date );
is $obj->get_value() , $converted . timezone($date), 'conversion';
}
$obj->set_value( '2037-12-31+12:00' );
is $obj->get_value() , '2037-12-31+12:00', 'no conversion on match';
t/SOAP/WSDL/XSD/Typelib/Builtin/dateTime.t
-42
View File
@@ -1,42 +0,0 @@
use strict;
use warnings;
use lib '../lib';
use Test::More tests => 7;
use Date::Parse;
use Date::Format;
sub timezone {
my @time = strptime shift;
my $tz = strftime('%z', @time);
substr $tz, -2, 0, ':';
return $tz;
}
use_ok('SOAP::WSDL::XSD::Typelib::Builtin::dateTime');
print "# timezone is " . timezone( scalar localtime(time) ) . "\n";
my $obj;
my %dates = (
'2007-12-31 12:32' => '2007-12-31T12:32:00',
'2007-08-31 00:32' => '2007-08-31T00:32:00',
'30 Aug 2007' => '2007-08-30T00:00:00',
);
$obj = SOAP::WSDL::XSD::Typelib::Builtin::dateTime->new();
$obj = SOAP::WSDL::XSD::Typelib::Builtin::dateTime->new({});
$obj = SOAP::WSDL::XSD::Typelib::Builtin::dateTime->new({ value => '2007-08-31T00:32:00' });
while (my ($date, $converted) = each %dates ) {
$obj = SOAP::WSDL::XSD::Typelib::Builtin::dateTime->new();
$obj->set_value( $date );
is $obj->get_value() , $converted . timezone($date), 'conversion with timezone';
}
$obj->set_value('2007-12-31T00:00:00.0000000+01:00');
is $obj->get_value(), '2007-12-31T00:00:00.0000000+01:00';
$obj->set_value(undef);
is $obj->get_value(), undef;
eval { $obj->set_value(1) };
ok $@, 'Die on illegal datetime';
t/SOAP/WSDL/XSD/Typelib/Builtin/decimal.t
-15
View File
@@ -1,15 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use Scalar::Util qw(blessed);
use SOAP::WSDL::XSD::Typelib::Builtin::decimal;
my $decimal = SOAP::WSDL::XSD::Typelib::Builtin::decimal->new();
ok blessed $decimal;
is $decimal->get_value(), undef;
ok $decimal = SOAP::WSDL::XSD::Typelib::Builtin::decimal->new({ value => 127 });
is $decimal * 1, 127, 'numerification';
is "$decimal", "127", 'stringification';
ok $decimal->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType'), 'inheritance';
# TODO: test range (bigint)
t/SOAP/WSDL/XSD/Typelib/Builtin/double.t
-13
View File
@@ -1,13 +0,0 @@
use Test::More tests => 4;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::double;
my $double = SOAP::WSDL::XSD::Typelib::Builtin::double->new();
ok $double = SOAP::WSDL::XSD::Typelib::Builtin::double->new({ value => 127.23 });
is $double * 1, 127.23, 'numerification';
is "$double", "127.23", 'stringification';
ok $double->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType'), 'inheritance';
# TODO test range
t/SOAP/WSDL/XSD/Typelib/Builtin/float.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 4;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::float;
my $float = SOAP::WSDL::XSD::Typelib::Builtin::float->new();
ok $float = SOAP::WSDL::XSD::Typelib::Builtin::float->new({ value => 127.23 });
is $float * 1, 127.23, 'numerification';
is "$float", "127.23", 'stringification';
ok $float->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType'), 'inheritance';
# TODO test range
t/SOAP/WSDL/XSD/Typelib/Builtin/hexBinary.t
-11
View File
@@ -1,11 +0,0 @@
use Test::More tests => 5;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::hexBinary;
my $hexBinary = SOAP::WSDL::XSD::Typelib::Builtin::hexBinary->new();
is $hexBinary->get_value(), undef;
$hexBinary = SOAP::WSDL::XSD::Typelib::Builtin::hexBinary->new({});
is $hexBinary->get_value(), undef;
ok $hexBinary = SOAP::WSDL::XSD::Typelib::Builtin::hexBinary->new({ value => 'a1b2c3d4' });
is "$hexBinary", "a1b2c3d4", 'stringification';
ok $hexBinary->isa('SOAP::WSDL::XSD::Typelib::Builtin::anySimpleType'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/int.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::int;
my $int = SOAP::WSDL::XSD::Typelib::Builtin::int->new();
ok defined $int;
ok $int->set_value('127');
ok $int = SOAP::WSDL::XSD::Typelib::Builtin::int->new({ value => 127 });
is $int * 1, 127, 'numerification';
is "$int", "127", 'stringification';
ok $int->isa('SOAP::WSDL::XSD::Typelib::Builtin::long'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/integer.t
-13
View File
@@ -1,13 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::integer;
my $integer = SOAP::WSDL::XSD::Typelib::Builtin::integer->new();
is $integer->get_value(), undef;
$integer = SOAP::WSDL::XSD::Typelib::Builtin::integer->new({});
is $integer->get_value(), undef;
ok $integer = SOAP::WSDL::XSD::Typelib::Builtin::integer->new({ value => 127 });
is $integer * 1, 127, 'numerification';
is "$integer", "127", 'stringification';
ok $integer->isa('SOAP::WSDL::XSD::Typelib::Builtin::decimal'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/language.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 5;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::language;
my $Name = SOAP::WSDL::XSD::Typelib::Builtin::language->new();
is $Name->get_value(), undef;
$Name = SOAP::WSDL::XSD::Typelib::Builtin::language->new({});
is $Name->get_value(), undef;
ok $Name = SOAP::WSDL::XSD::Typelib::Builtin::language->new({ value => 'DE' });
is "$Name", "DE", 'stringification';
ok $Name->isa('SOAP::WSDL::XSD::Typelib::Builtin::token'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/list.t
-28
View File
@@ -1,28 +0,0 @@
package ListTest;
use base qw(SOAP::WSDL::XSD::Typelib::Builtin::list
SOAP::WSDL::XSD::Typelib::Builtin::string);
package main;
use Test::More tests => 11;
use strict;
use warnings;
my $obj = ListTest->new();
is $obj->get_value(), undef;
$obj = ListTest->new({});
is $obj->get_value(), undef;
ok $obj = ListTest->new({ value => 'Test' });
is "$obj", 'Test', 'stringification';
ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::string'), 'inheritance';
$obj->set_value(undef);
is $obj->get_value, undef;
is $obj->serialize(), '', 'serialize undef to empty string';
is $obj->serialize({ empty => 1 }), '', 'serialize undef to empty string';
$obj->set_value(42);
is $obj->get_value, 42;
is $obj->serialize(), '42', 'serialize undef to empty string';
$obj->set_value([1,2,3]);
is $obj->serialize(), '1 2 3', 'list serialization';
t/SOAP/WSDL/XSD/Typelib/Builtin/long.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::long;
my $long = SOAP::WSDL::XSD::Typelib::Builtin::long->new();
ok defined $long;
ok $long->set_value('127');
ok $long = SOAP::WSDL::XSD::Typelib::Builtin::long->new({ value => 127 });
is $long * 1, 127, 'numerification';
is "$long", "127", 'stringification';
ok $long->isa('SOAP::WSDL::XSD::Typelib::Builtin::decimal'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/negativeInteger.t
-10
View File
@@ -1,10 +0,0 @@
use Test::More tests => 4;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger;
my $negativeInteger = SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger->new();
ok $negativeInteger = SOAP::WSDL::XSD::Typelib::Builtin::negativeInteger->new({ value => 127 });
is $negativeInteger * 1, 127, 'numerification';
is "$negativeInteger", "127", 'stringification';
ok $negativeInteger->isa('SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/nonNegativeInteger.t
-10
View File
@@ -1,10 +0,0 @@
use Test::More tests => 4;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger;
my $nonNegativeInteger = SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger->new();
ok $nonNegativeInteger = SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger->new({ value => 127 });
is $nonNegativeInteger * 1, 127, 'numerification';
is "$nonNegativeInteger", "127", 'stringification';
ok $nonNegativeInteger->isa('SOAP::WSDL::XSD::Typelib::Builtin::integer'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/nonPositiveInteger.t
-10
View File
@@ -1,10 +0,0 @@
use Test::More tests => 4;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger;
my $nonPositiveInteger = SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger->new();
ok $nonPositiveInteger = SOAP::WSDL::XSD::Typelib::Builtin::nonPositiveInteger->new({ value => 127 });
is $nonPositiveInteger * 1, 127, 'numerification';
is "$nonPositiveInteger", "127", 'stringification';
ok $nonPositiveInteger->isa('SOAP::WSDL::XSD::Typelib::Builtin::integer'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/normalizedString.t
-24
View File
@@ -1,24 +0,0 @@
use Test::More tests => 9;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::normalizedString;
my $obj = SOAP::WSDL::XSD::Typelib::Builtin::normalizedString->new();
is $obj->get_value(), undef;
$obj = SOAP::WSDL::XSD::Typelib::Builtin::normalizedString->new({});
is $obj->get_value(), undef;
ok $obj = SOAP::WSDL::XSD::Typelib::Builtin::normalizedString->new({ value => 'Test' });
is "$obj", 'Test', 'stringification';
ok $obj->isa('SOAP::WSDL::XSD::Typelib::Builtin::string'), 'inheritance';
$obj->set_value(undef);
is $obj->get_value, undef;
$obj->set_value( "&\t\"Aber\"\n\r<test>");
is $obj->get_value() , '& "Aber" <test>';
is $obj->serialize, '&amp; &quot;Aber&quot; &lt;test&gt;'
, 'escape text on serialization';
is $obj->serialize({ name => 'test'})
, '<test >&amp; &quot;Aber&quot; &lt;test&gt;</test >'
, 'Serialization with name';
t/SOAP/WSDL/XSD/Typelib/Builtin/positiveInteger.t
-10
View File
@@ -1,10 +0,0 @@
use Test::More tests => 4;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger;
my $positiveInteger = SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger->new();
ok $positiveInteger = SOAP::WSDL::XSD::Typelib::Builtin::positiveInteger->new({ value => 127 });
is $positiveInteger * 1, 127, 'numerification';
is "$positiveInteger", "127", 'stringification';
ok $positiveInteger->isa('SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/short.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::short;
my $short = SOAP::WSDL::XSD::Typelib::Builtin::short->new();
ok defined $short;
ok $short->set_value('127');
ok $short = SOAP::WSDL::XSD::Typelib::Builtin::short->new({ value => 127 });
is $short * 1, 127, 'numerification';
is "$short", "127", 'stringification';
ok $short->isa('SOAP::WSDL::XSD::Typelib::Builtin::int'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/string.t
-23
View File
@@ -1,23 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use lib '../lib';
use_ok('SOAP::WSDL::XSD::Typelib::Builtin::string');
my $obj;
$obj = SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => '& "Aber" <test>'});
is $obj->serialize, '&amp; &quot;Aber&quot; &lt;test&gt;'
, 'escape text on serialization';
$obj = SOAP::WSDL::XSD::Typelib::Builtin::string->new();
$obj = SOAP::WSDL::XSD::Typelib::Builtin::string->new({});
$obj->set_value( '& "Aber" <test>');
is $obj->get_value() , '& "Aber" <test>';
is $obj, '& "Aber" <test>';
is $obj->serialize(), '&amp; &quot;Aber&quot; &lt;test&gt;'
, 'escape text on serialization';
is $obj->serialize({ name => 'test'})
, '<test >&amp; &quot;Aber&quot; &lt;test&gt;</test >'
, 'Serialization with name';
t/SOAP/WSDL/XSD/Typelib/Builtin/time.t
-39
View File
@@ -1,39 +0,0 @@
use Test::More tests => 3;
use strict;
use warnings;
use lib '../lib';
use Date::Parse;
use Date::Format;
sub timezone {
my @time = localtime;
my $tz = strftime('%z', @time);
substr $tz, -2, 0, ':';
return $tz;
}
my $timezone = timezone;
use_ok('SOAP::WSDL::XSD::Typelib::Builtin::time');
my $obj;
$obj = SOAP::WSDL::XSD::Typelib::Builtin::time->new({value => '12:23:33'});
$obj = SOAP::WSDL::XSD::Typelib::Builtin::time->new({});
$obj = SOAP::WSDL::XSD::Typelib::Builtin::time->new();
$obj->set_value( '12:23:03' );
is $obj->get_value() , "12:23:03$timezone", 'conversion';
$obj->set_value( '12:23:03.12345+01:00' ), ;
is $obj->get_value() , '12:23:03.12345+01:00', 'no conversion';
# exit;
#~ use Benchmark;
#~ timethese 10000, {
#~ xml => sub { $obj->set_value('2037-12-31T00:00:00.0000000+01:00') },
#~ string => sub { $obj->set_value('2037-12-31') },
#~ }
t/SOAP/WSDL/XSD/Typelib/Builtin/token.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 5;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN;
my $NMTOKEN = SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN->new();
is $NMTOKEN->get_value(), undef;
$NMTOKEN = SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN->new({});
is $NMTOKEN->get_value(), undef;
ok $NMTOKEN = SOAP::WSDL::XSD::Typelib::Builtin::NMTOKEN->new({ value => 127 });
is "$NMTOKEN", "127", 'stringification';
ok $NMTOKEN->isa('SOAP::WSDL::XSD::Typelib::Builtin::token'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/unsignedByte.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte;
my $unsignedByte = SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte->new();
ok defined $unsignedByte;
ok $unsignedByte->set_value('127');
ok $unsignedByte = SOAP::WSDL::XSD::Typelib::Builtin::unsignedByte->new({ value => 127 });
is $unsignedByte * 1, 127, 'numerification';
is "$unsignedByte", "127", 'stringification';
ok $unsignedByte->isa('SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/unsignedInt.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt;
my $unsignedInt = SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt->new();
ok defined $unsignedInt;
ok $unsignedInt->set_value('127');
ok $unsignedInt = SOAP::WSDL::XSD::Typelib::Builtin::unsignedInt->new({ value => 127 });
is $unsignedInt * 1, 127, 'numerification';
is "$unsignedInt", "127", 'stringification';
ok $unsignedInt->isa('SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/unsignedLong.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong;
my $unsignedLong = SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong->new();
ok defined $unsignedLong;
ok $unsignedLong->set_value('127');
ok $unsignedLong = SOAP::WSDL::XSD::Typelib::Builtin::unsignedLong->new({ value => 127 });
is $unsignedLong * 1, 127, 'numerification';
is "$unsignedLong", "127", 'stringification';
ok $unsignedLong->isa('SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/Builtin/unsignedShort.t
-12
View File
@@ -1,12 +0,0 @@
use Test::More tests => 6;
use strict;
use warnings;
use SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort;
my $unsignedShort = SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort->new();
ok defined $unsignedShort;
ok $unsignedShort->set_value('127');
ok $unsignedShort = SOAP::WSDL::XSD::Typelib::Builtin::unsignedShort->new({ value => 127 });
is $unsignedShort * 1, 127, 'numerification';
is "$unsignedShort", "127", 'stringification';
ok $unsignedShort->isa('SOAP::WSDL::XSD::Typelib::Builtin::nonNegativeInteger'), 'inheritance';
t/SOAP/WSDL/XSD/Typelib/ComplexType.t
-273
View File
@@ -1,273 +0,0 @@
use strict;
use warnings;
package MyEmptyType;
use base qw(SOAP::WSDL::XSD::Typelib::ComplexType);
__PACKAGE__->_factory([],{},{});
package MyEmptyType2;
use base qw(SOAP::WSDL::XSD::Typelib::ComplexType);
__PACKAGE__->_factory();
package MyType;
use base qw(SOAP::WSDL::XSD::Typelib::ComplexType);
my %test_of :ATTR(:get<test>);
__PACKAGE__->_factory(
[ 'test' ],
{
test => \%test_of,
},
{
test => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
}
);
package MyType2;
use base qw(SOAP::WSDL::XSD::Typelib::ComplexType);
my %test2_of :ATTR(:get<test>);
__PACKAGE__->_factory(
[ 'test' ],
{
test => \%test2_of,
},
{
test => 'MyType',
}
);
package main;
use Test::More tests => 100;
use Storable;
my $have_warn = eval { require Test::Warn; import Test::Warn; 1; };
my $obj;
$obj = MyEmptyType->new();
is $obj->serialize, '';
is $obj->serialize({ name => 'test'}), '<test />';
$obj = MyEmptyType2->new();
is $obj->serialize, '';
is $obj->serialize({ name => 'test'}), '<test />';
$obj = MyType->new({});
isa_ok $obj, 'MyType';
is $obj->get_test, undef, 'undefined element content';
my $hash_of_ref = $obj->as_hash_ref();
is scalar keys %{ $hash_of_ref }, 0;
SKIP: {
skip 'Cannot test warnings without Test::Warn', 1 if not $have_warn;
warning_is( sub { $obj->add_test() }, 'attempting to add empty value to MyType' );
}
$obj = MyType->new({ test => 'Test1'});
isa_ok $obj, 'MyType';
isa_ok $obj->get_test, 'SOAP::WSDL::XSD::Typelib::Builtin::string';
is $obj->get_test, 'Test1', 'element content';
$obj = MyType->new({
test => SOAP::WSDL::XSD::Typelib::Builtin::string->new({
value => 'Test2'
})
});
isa_ok $obj, 'MyType';
isa_ok $obj->get_test, 'SOAP::WSDL::XSD::Typelib::Builtin::string';
is $obj->get_test, 'Test2', 'element content';
$obj = MyType->new({
test => { value => 'Test2' } # just a trick - pass it unaltered to new...
});
isa_ok $obj, 'MyType';
isa_ok $obj->get_test, 'SOAP::WSDL::XSD::Typelib::Builtin::string';
is $obj->get_test, 'Test2', 'element content';
$hash_of_ref = $obj->as_hash_ref();
is $hash_of_ref->{ test }, 'Test2';
$obj = MyType->new({
test => [
SOAP::WSDL::XSD::Typelib::Builtin::string->new({
value => 'Test'
}),
SOAP::WSDL::XSD::Typelib::Builtin::string->new({
value => 'Test2'
})
],
});
isa_ok $obj, 'MyType';
isa_ok $obj->get_test, 'ARRAY';
is $obj->get_test()->[0], 'Test', 'element content (list content [0])';
is $obj->get_test()->[1], 'Test2', 'element content (list content [1])';
$hash_of_ref = $obj->as_hash_ref();
is $hash_of_ref->{ test }->[0], 'Test';
is $hash_of_ref->{ test }->[1], 'Test2';
my $nested = MyType2->new({
test => $obj,
});
is $nested->get_test, $obj, 'getter';
$nested = MyType2->new({
test => [$obj, $obj],
});
is $nested->get_test->[0], $obj;
$nested = MyType2->new({
test => {
test => [
SOAP::WSDL::XSD::Typelib::Builtin::string->new({
value => 'Test'
}),
SOAP::WSDL::XSD::Typelib::Builtin::string->new({
value => 'Test2'
})
],
},
});
$hash_of_ref = $nested->as_hash_ref();
is $hash_of_ref->{ test }->{ test }->[1], 'Test2';
# isnt $nested->get_test->[0], $obj, 'element identity';
$obj = MyType->new();
isa_ok $obj, 'MyType';
is $obj->get_test, undef, 'undefined element content';
$obj->add_test(
SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => 'TestString0'})
);
is $obj->get_test, 'TestString0', 'added element content';
for my $count (1..5) {
$obj->add_test(
SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => "TestString$count" })
);
is ref $obj->get_test(), 'ARRAY', 'element content structure';
is @{ $obj->get_test() }, $count+1, "element list length: " . ($count + 1);
for my $index (0..$count-1) {
is $obj->get_test->[$index], "TestString$index", "element content [$index]";
}
}
# TODO - remove after *{ "$class\::$name"" } methods are gone
$obj = MyType->new();
isa_ok $obj, 'MyType';
is $obj->get_test, undef;
{
no warnings;
my $foo;
eval { $foo = @{ $obj->get_test() } };
if (! $@) {
is $foo, undef;
# like $warnings, qr{ uninitialized \s value \s in array \s dereference }x, 'undef warning';
}
else {
like $@ , qr{Can't \s use \s an \s undefined}x, 'get_ELEMENT still undef on ARRAYIFY';
# pass 'failed array dereference';
}
$obj->test(
SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => 'TestString0'})
);
}
is $obj->get_test, 'TestString0';
eval { is @{ $obj->get_test() }, 1, 'ARRAYIFY get_ELEMENT' };
fail 'cannot ARRAYIFY get_ELEMENT' if ($@);
my @serialized = (
'<test >TestString0</test ><test >TestString1</test >',
'<test >TestString0</test ><test >TestString1</test ><test >TestString2</test >',
'<test >TestString0</test ><test >TestString1</test ><test >TestString2</test ><test >TestString3</test >',
'<test >TestString0</test ><test >TestString1</test ><test >TestString2</test ><test >TestString3</test ><test >TestString4</test >',
'<test >TestString0</test ><test >TestString1</test ><test >TestString2</test ><test >TestString3</test ><test >TestString4</test ><test >TestString5</test >',
);
for my $count (1..5) {
$obj->test(
SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => "TestString$count" })
);
is ref $obj->get_test(), 'ARRAY';
is @{ $obj->get_test() }, $count+1;
for my $index (0..$count-1) {
is $obj->get_test->[$index], "TestString$index";
}
is $obj->serialize(), $serialized[$count -1];
}
eval {
$obj = MyType->new({
test => [
SOAP::WSDL::XSD::Typelib::Builtin::string->new({
value => 'Test'
}),
\&CORE::die,
],
});
};
like $@, qr{cannot \s use \s CODE}xms;
eval {
$obj = MyType->new({
test => \&CORE::die,
});
};
like $@, qr{cannot \s use \s CODE}xms;
eval {
$obj = MyType->new({
foobar => 'fubar'
});
};
like $@, qr{unknown \s field \s foobar \s in \s MyType }xms;
eval { $obj->set_FOO(42) };
like $@, qr{Can't \s locate \s object \s method}x;
eval { MyType->set_FOO(42) };
like $@, qr{Can't \s locate \s object \s method}x;
eval { MyType->new({ FOO => 42 }) };
like $@, qr{unknown \s field \s}xm;
my $clone = Storable::thaw( Storable::freeze( $obj ));
is $clone->get_test()->[0], 'TestString0';
eval { SOAP::WSDL::XSD::Typelib::ComplexType::AUTOMETHOD() };
like $@, qr{Cannot \s call}xm;
eval { SOAP::WSDL::XSD::Typelib::ComplexType->_factory([], { test => {} }, {}) };
like $@, qr{ No \s class \s given \s for \s }xms;
eval { SOAP::WSDL::XSD::Typelib::ComplexType->_factory([], { test => {} }, { test => 'HopeItDoesntExistOnYourSystem'}) };
like $@, qr{ Can't \s locate \s HopeItDoesntExistOnYourSystem.pm }xms;
t/SOAP/WSDL/XSD/Typelib/Element.t
-44
View File
@@ -1,44 +0,0 @@
use strict;
use warnings;
package MyElement;
use base qw(SOAP::WSDL::XSD::Typelib::Element
SOAP::WSDL::XSD::Typelib::Builtin::string
);
__PACKAGE__->__set_name('MyElement');
__PACKAGE__->__set_nillable(1);
package main;
use Test::More tests => 11;
my $obj;
# All constructor variants
$obj = MyElement->new();
$obj = MyElement->new({});
$obj = MyElement->new({ value => 'Test' });
is( MyElement->__get_nillable(), 1);
is $obj->__get_nillable, 1;
isa_ok $obj, 'MyElement';
is $obj->get_value(), 'Test';
$obj->set_value(undef);
is $obj->serialize_qualified, '<MyElement xsi:nil="true" xmlns="http://www.w3.org/2001/XMLSchema" />';
$obj->__set_nillable(0);
is $obj->__get_nillable(), 0;
eval { SOAP::WSDL::XSD::Typelib::Element::__get_nillable() };
like $@, qr{Cannot \s call}xms;
eval { SOAP::WSDL::XSD::Typelib::Element::__set_nillable() };
like $@, qr{Cannot \s call}xms;
is $obj->start_tag({empty => 1}), '<MyElement />';
is $obj->start_tag({nil => 1}), '', 'empty string with nil option and NILLABLE false';
$obj->set_value('Test');
eval { is @{ $obj }, 1, 'ARRAYIFY' };
fail 'ARRAYIFY' if ($@);
t/SOAP/WSDL_1.wsdl
-60
View File
@@ -1,60 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions name="WSDL_1"
targetNamespace="http://www.example.org/WSDL_1/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:tns="http://www.example.org/WSDL_1/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<wsdl:types>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.example.org/WSDL_1/">
<xsd:element name="NewOperation">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="in" type="xsd:string"></xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="NewOperationResponse">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="out" type="xsd:string"></xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
</wsdl:types>
<wsdl:message name="NewOperationRequest">
<wsdl:part name="parameters" element="tns:NewOperation"></wsdl:part>
</wsdl:message>
<wsdl:message name="NewOperationResponse">
<wsdl:part name="parameters"
element="tns:NewOperationResponse">
</wsdl:part>
</wsdl:message>
<wsdl:portType name="NewPortType">
<wsdl:operation name="NewOperation">
<wsdl:input message="tns:NewOperationRequest"></wsdl:input>
<wsdl:output message="tns:NewOperationResponse"></wsdl:output>
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="NewBinding" type="tns:NewPortType">
<soap:binding style="document"
transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="NewOperation">
<soap:operation
soapAction="http://www.example.org/WSDL_1/NewOperation" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="NewService">
<wsdl:port name="NewPort" binding="tns:NewBinding">
<soap:address location="http://www.example.org/"></soap:address>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
t/SOAP/WSDL_EMPTY_DEFINITIONS.wsdl
-2
View File
@@ -1,2 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?><wsdl:definitions name="WSDL_1" targetNamespace="http://www.example.org/WSDL_1/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:tns="http://www.example.org/WSDL_1/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
</wsdl:definitions>
t/SOAP/WSDL_NO_BINDING.wsdl
-60
View File
@@ -1,60 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions name="WSDL_1"
targetNamespace="http://www.example.org/WSDL_1/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:tns="http://www.example.org/WSDL_1/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<wsdl:types>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.example.org/WSDL_1/">
<xsd:element name="NewOperation">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="in" type="xsd:string"></xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="NewOperationResponse">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="out" type="xsd:string"></xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
</wsdl:types>
<wsdl:message name="NewOperationRequest">
<wsdl:part name="parameters" element="tns:NewOperation"></wsdl:part>
</wsdl:message>
<wsdl:message name="NewOperationResponse">
<wsdl:part name="parameters"
element="tns:NewOperationResponse">
</wsdl:part>
</wsdl:message>
<wsdl:portType name="NewPortType">
<wsdl:operation name="NewOperation">
<wsdl:input message="tns:NewOperationRequest"></wsdl:input>
<wsdl:output message="tns:NewOperationResponse"></wsdl:output>
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="NewBinding" type="tns:NewPortType">
<soap:binding style="document"
transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="NewOperation">
<soap:operation
soapAction="http://www.example.org/WSDL_1/NewOperation" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="NewService">
<wsdl:port name="NewPort" binding="tns:BadBinding">
<soap:address location="http://www.example.org/"></soap:address>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
t/SOAP/WSDL_NO_MESSAGE.wsdl
-60
View File
@@ -1,60 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions name="WSDL_1"
targetNamespace="http://www.example.org/WSDL_1/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:tns="http://www.example.org/WSDL_1/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<wsdl:types>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.example.org/WSDL_1/">
<xsd:element name="NewOperation">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="in" type="xsd:string"></xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="NewOperationResponse">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="out" type="xsd:string"></xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
</wsdl:types>
<wsdl:message name="BadOperationRequest">
<wsdl:part name="parameters" element="tns:NewOperation"></wsdl:part>
</wsdl:message>
<wsdl:message name="NewOperationResponse">
<wsdl:part name="parameters"
element="tns:NewOperationResponse">
</wsdl:part>
</wsdl:message>
<wsdl:portType name="NewPortType">
<wsdl:operation name="NewOperation">
<wsdl:input message="tns:NewOperationRequest"></wsdl:input>
<wsdl:output message="tns:NewOperationResponse"></wsdl:output>
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="NewBinding" type="tns:NewPortType">
<soap:binding style="document"
transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="NewOperation">
<soap:operation
soapAction="http://www.example.org/WSDL_1/NewOperation" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="NewService">
<wsdl:port name="NewPort" binding="tns:NewBinding">
<soap:address location="http://www.example.org/"></soap:address>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
t/SOAP/WSDL_NO_PORTTYPE.wsdl
-60
View File
@@ -1,60 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions name="WSDL_1"
targetNamespace="http://www.example.org/WSDL_1/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:tns="http://www.example.org/WSDL_1/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/">
<wsdl:types>
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.example.org/WSDL_1/">
<xsd:element name="NewOperation">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="in" type="xsd:string"></xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
<xsd:element name="NewOperationResponse">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="out" type="xsd:string"></xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
</xsd:schema>
</wsdl:types>
<wsdl:message name="NewOperationRequest">
<wsdl:part name="parameters" element="tns:NewOperation"></wsdl:part>
</wsdl:message>
<wsdl:message name="NewOperationResponse">
<wsdl:part name="parameters"
element="tns:NewOperationResponse">
</wsdl:part>
</wsdl:message>
<wsdl:portType name="NewPortType">
<wsdl:operation name="NewOperation">
<wsdl:input message="tns:NewOperationRequest"></wsdl:input>
<wsdl:output message="tns:NewOperationResponse"></wsdl:output>
</wsdl:operation>
</wsdl:portType>
<wsdl:binding name="NewBinding" type="tns:BadPortType">
<soap:binding style="document"
transport="http://schemas.xmlsoap.org/soap/http" />
<wsdl:operation name="NewOperation">
<soap:operation
soapAction="http://www.example.org/WSDL_1/NewOperation" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="NewService">
<wsdl:port name="NewPort" binding="tns:NewBinding">
<soap:address location="http://www.example.org/"></soap:address>
</wsdl:port>
</wsdl:service>
</wsdl:definitions>