import SOAP-WSDL 2.00_31 from CPAN

git-cpan-module:   SOAP-WSDL
git-cpan-version:  2.00_31
git-cpan-authorid: MKUTTER
git-cpan-file:     authors/id/M/MK/MKUTTER/SOAP-WSDL-2.00_31.tar.gz

t/SOAP/WSDL.t

@@ -2,11 +2,11 @@ use strict;
 use warnings;
 use Test::More tests => 12;
 use File::Spec;
-use File::Basename;
+use File::Basename qw(dirname);
 use_ok qw(SOAP::WSDL);
 
 my $path = File::Spec->rel2abs(dirname( __FILE__ ) );
-
+$path =~s{\\}{/}xmsg;   # fix for windows
 my $soap = SOAP::WSDL->new();
 $soap->wsdl("file://$path/WSDL_NOT_FOUND.wsdl");
 

t/SOAP/WSDL/02_port.t

@@ -1,4 +1,4 @@
-use Test::More tests => 7;
+use Test::More tests => 10;
 use strict;
 use warnings;
 use diagnostics;
@@ -28,4 +28,13 @@ ok( $soap->wsdlinit(), 'parsed WSDL' );
 
 ok( $soap->wsdlinit( servicename => 'testService', portname => 'testPort'), 'parsed WSDL' );
 
-ok( ($soap->portname() eq 'testPort' ), 'found port passed to wsdlinit');
+ok( ($soap->portname() eq 'testPort' ), 'found port passed to wsdlinit');
+
+ok( $soap = SOAP::WSDL->new(
+    wsdl => 'file://' . $url . '/../../acceptance/wsdl/02_port.wsdl'
+), 'Instantiated object' );
+
+ok( $soap->wsdlinit() );
+$soap->outputxml(1);
+eval { $soap->call('test') };
+like $@, qr{type \s tns:testSimpleType1 \s , \s urn:simpleType \s not \s found}xms;

t/SOAP/WSDL/04_element.t

@@ -1,4 +1,4 @@
-use Test::More tests => 8;
+use Test::More tests => 9;
 use strict;
 use warnings;
 use lib '../lib';
@@ -28,7 +28,11 @@ ok( $soap = SOAP::WSDL->new(
 ), 'Instantiated object' );
 
 #3
-$soap->readable(1);
+SKIP: {
+    skip 'Cannot test warning without Test::Warn', 1 if not (eval "require Test::Warn");
+    Test::Warn::warning_like( sub { $soap->readable(1) },
+        qr{\A 'readable' \s has \s no \s effect \s any \s more}xms);
+}
 $soap->outputxml(1);
 
 ok( $soap->wsdlinit(
@@ -36,15 +40,15 @@ ok( $soap->wsdlinit(
 ), 'parsed WSDL' );
 $soap->no_dispatch(1);
 
-ok ($xml = $soap->call('test', 
+ok ($xml = $soap->call('test',
 	testElement1 => 'Test'
 ), 'Serialized (simple) element' );
 
-ok ($xml = $soap->call('testRef', 
+ok ($xml = $soap->call('testRef',
 	testElementRef => 'Test'
 ), 'Serialized (simple) element' );
 
-like $xml 
+like $xml
     , qr{<testElementRef\s\sxmlns="urn:Test">Test</testElementRef></SOAP-ENV:Body></SOAP-ENV:Envelope>}
     , 'element ref serialization result'
 ;
@@ -52,10 +56,10 @@ like $xml
 TODO: {
     local $TODO="implement min/maxOccurs checks";
 
-    eval { 
-	$xml = 	$soap->call('test', 
+    eval {
+	$xml = 	$soap->call('test',
 			testAll => [ 'Test 2', 'Test 3' ]
-		); 
+		);
     };
 
     ok( ($@ =~m/illegal\snumber\sof\selements/),
@@ -63,7 +67,7 @@ TODO: {
     );
 
     eval {
-	$xml = $soap->call('test', testAll => undef ); 
+	$xml = $soap->call('test', testAll => undef );
     };
     ok($@, 'Died on illegal number of elements (not enough)');
 }

t/SOAP/WSDL/Client.t

@@ -1,6 +1,6 @@
 use strict;
 use warnings;
-use Test::More tests => 4; #qw(no_plan);
+use Test::More tests => 8; #qw(no_plan);
 
 use_ok qw(SOAP::WSDL::Client);
 
@@ -10,4 +10,28 @@ ok $client = SOAP::WSDL::Client->new({
     proxy => 'http://localhost',
 });
 
-is $client->get_endpoint(), 'http://localhost';
+is $client->get_endpoint(), 'http://localhost';
+
+$client->no_dispatch(1);
+$client->set_serializer('main');
+my $serialize = $client->call({
+    operation => 'testMethod'
+}, { foo => 'bar'}, { bar => 'baz'});
+is $serialize->{ body }->{ foo }, 'bar';
+is $serialize->{ header }->{ bar }, 'baz';
+
+# Old calling style compatibility test - foo => bar is body...
+$serialize = $client->call({
+    operation => 'testMethod'
+}, foo => 'bar');
+is $serialize->{ body }->{ foo }, 'bar';
+
+# Old calling style compatibility test - foo => bar is body...
+$serialize = $client->call('testMethod', foo => 'bar');
+is $serialize->{ body }->{ foo }, 'bar';
+
+
+sub serialize {
+    my $self = shift;
+    return shift;
+}

t/SOAP/WSDL/Client/Base.t

@@ -4,11 +4,9 @@ use Class::Std::Fast;
 package main;
 use strict;
 use warnings;
-use Test::More tests => 9;
+use Test::More tests => 21;
 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';
@@ -16,35 +14,41 @@ my $client = SOAP::WSDL::Client::Base->new();
     };
 }
 
+my $client = SOAP::WSDL::Client::Base->new();
+
 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 )],
+            parts => [qw( SOAP::WSDL::XSD::Typelib::Builtin::string
+                SOAP::WSDL::XSD::Typelib::Builtin::string
+            )],
         },
         header => {
-            parts => [qw( SOAP::WSDL::XSD::Typelib::Builtin::string )],
+            parts => [qw( SOAP::WSDL::XSD::Typelib::Builtin::string
+
+            )],
         },
         headerfault => {
-            
+
         }
     }, { value => 'Body' }, { value => 'Header' });
 
-is $result[0], 'Body';
+is $result[0]->[0], 'Body';
 is $result[1], 'Header';
-isa_ok $result[0], 'SOAP::WSDL::XSD::Typelib::Builtin::string';
+isa_ok $result[0]->[0], 'SOAP::WSDL::XSD::Typelib::Builtin::string';
 
 @result = $client->call({
         operation => 'sayHello',
         soap_action => 'urn:HelloWorld#sayHello',
         style => 'document',
         body => {
-            
+
            'use' => 'literal',
             namespace => '',
             encodingStyle => '',
@@ -54,9 +58,9 @@ isa_ok $result[0], 'SOAP::WSDL::XSD::Typelib::Builtin::string';
             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 => 'Body2' }),
        SOAP::WSDL::XSD::Typelib::Builtin::string->new({ value => 'Header2' })
     );
 
@@ -64,3 +68,97 @@ is $result[0], 'Body2';
 is $result[1], 'Header2';
 isa_ok $result[1], 'SOAP::WSDL::XSD::Typelib::Builtin::string';
 
+# Call with more body parts than parameters. Body parts are empty
+@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 => 'Header2' })
+    );
+
+isa_ok $result[0], 'SOAP::WSDL::XSD::Typelib::Builtin::string';
+is $result[0], undef;
+is $result[1], 'Header2';
+isa_ok $result[1], 'SOAP::WSDL::XSD::Typelib::Builtin::string';
+
+# Call with more body parts than parameters. Body parts are empty
+# No header
+@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 => {
+        },
+        headerfault => {
+
+        }
+    });
+
+isa_ok $result[0], 'SOAP::WSDL::XSD::Typelib::Builtin::string';
+is $result[0], undef;
+
+eval { $client->call({
+        operation => 'sayHello',
+        soap_action => 'urn:HelloWorld#sayHello',
+        style => 'document',
+        body => {
+
+           'use' => 'literal',
+            namespace => '',
+            encodingStyle => '',
+            parts => [qw( SomeStupidClassYouProbablyDontHaveOnYourSystem )],
+        },
+        header => {
+        },
+        headerfault => {
+
+        }
+    })
+};
+like $@, qr{ Can't \s locate }xms;
+
+isa_ok $result[0], 'SOAP::WSDL::XSD::Typelib::Builtin::string';
+is $result[0], undef;
+
+eval { $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( SomeOtherStupidClassYouProbablyDontHaveOnYourSystem )],
+        },
+        headerfault => {
+
+        }
+    })
+};
+# die $@;
+like $@, qr{ Can't \s locate }xms;

t/SOAP/WSDL/Definitions.t

@@ -0,0 +1,32 @@
+use strict;
+use warnings;
+use Test::More tests => 4;
+
+use SOAP::WSDL::PortType;
+use_ok qw(SOAP::WSDL::Definitions);
+
+my $obj = SOAP::WSDL::Definitions->new({
+    portType => [
+        SOAP::WSDL::PortType->new({
+            name => 'foo',
+            targetNamespace => 'bar',
+        }),
+        SOAP::WSDL::PortType->new({
+            name => 'foo',
+            targetNamespace => 'baz',
+        }),
+        SOAP::WSDL::PortType->new({
+            name => 'foobar',
+            targetNamespace => 'bar',
+        }),
+    ]
+});
+
+
+my $found= $obj->find_portType('bar', 'foobar');
+is $found->get_name(), 'foobar', 'found PortType';
+$found = $obj->find_portType('baz', 'foo');
+is $found->get_name(), 'foo', 'found PortType';
+
+$found = $obj->find_portType('baz', 'foobar');
+is $found, undef, 'find_PortType returns undef on unknown PortType';

t/SOAP/WSDL/Deserializer/XSD.t

@@ -4,7 +4,7 @@ package TestResolver;
 sub get_typemap { {} };
 
 package main;
-use Test::More tests => 8;
+use Test::More tests => 9;
 
 use SOAP::WSDL::Deserializer::XSD;
 
@@ -24,4 +24,7 @@ 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';
+isa_ok $obj->deserialize('<Envelope xmlns="huchmampf"></Envelope>'), 'SOAP::WSDL::SOAP::Typelib::Fault11';
+is $obj->deserialize('<SOAP-ENV:Envelope
+        xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >
+    <SOAP-ENV:Body ></SOAP-ENV:Body></SOAP-ENV:Envelope>'), undef, 'Deserialize empty envelope';

t/SOAP/WSDL/Expat/Base.t

@@ -1,6 +1,6 @@
 use strict;
 use warnings;
-use Test::More tests => 3;
+use Test::More tests => 5;
 use_ok qw(SOAP::WSDL::Expat::Base);
 
 my $parser = SOAP::WSDL::Expat::Base->new();
@@ -9,4 +9,13 @@ eval { $parser->parse('Foobar')};
 ok $@;
 
 eval { $parser->parsefile('Foobar')};
-ok $@;
+ok $@;
+
+
+$parser = SOAP::WSDL::Expat::Base->new({
+    user_agent => 'foo',
+});
+
+is $parser->get_user_agent(), 'foo';
+$parser->set_user_agent('bar');
+is $parser->get_user_agent(), 'bar';

t/SOAP/WSDL/Expat/MessageParser.t

@@ -36,20 +36,20 @@ my $xml_attr = q{<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-
     xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >
     <SOAP-ENV:Body><MyElementAttrs xmlns="urn:Test" test="Test" test2="Test2">
     <test>Test</test>
-    <test2 >Test2</test2>
+    <test2 >    </test2>
     </MyElementAttrs></SOAP-ENV:Body></SOAP-ENV:Envelope>};
 
 $parser->parse($xml_attr);
 
 is $parser->get_data(),
-    q{<MyElementAttrs xmlns="urn:Test" test="Test" test2="Test2"><test>Test</test><test2>Test2</test2></MyElementAttrs>},
+    q{<MyElementAttrs xmlns="urn:Test" test="Test" test2="Test2"><test>Test</test></MyElementAttrs>},
     'Content with attributes';
 
 my $xml_error = q{<SOAP-ENV:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >
     <SOAP-ENV:Body><MyElementAttrs xmlns="urn:Test" test="Test" test2="Test2">
     <test>Test</test>
-    <test2 >Test2</test2>
+    <test2 ></test2>
     <foo>Bar</foo>
     </MyElementAttrs></SOAP-ENV:Body></SOAP-ENV:Envelope>};
 

t/SOAP/WSDL/Expat/WSDLParser.t

@@ -1,6 +1,6 @@
 use strict;
 use warnings;
-use Test::More tests => 4; #qw(no_plan);
+use Test::More tests => 10; #qw(no_plan);
 use File::Spec;
 use File::Basename;
 
@@ -10,7 +10,7 @@ use_ok qw( SOAP::WSDL::Expat::WSDLParser);
 
 my $parser =  SOAP::WSDL::Expat::WSDLParser->new();
 
-my $definitions = $parser->parse_file( 
+my $definitions = $parser->parse_file(
      "$path/../../../acceptance/wsdl/WSDLParser.wsdl"
 );
 
@@ -30,16 +30,27 @@ my $generator = SOAP::WSDL::Generator::Template::XSD->new({
     OUTPUT_PATH => "$path/testlib",
 });
 
-my $code = "";
-$generator->set_output(\$code);  
-$generator->generate_typelib();
-{
-    eval $code;
-    ok !$@;
-    print $@ if $@;
-}
+#my $code = "";
+#$generator->set_output(\$code);
+#$generator->generate_typelib();
+#{
+#    eval $code;
+#    ok !$@;
+#    print $@ if $@;
+#}
 
-# print $code;
+$definitions = $parser->parse_uri(
+     "file://$path/../../../acceptance/wsdl/WSDLParser-import.wsdl"
+);
+
+ok my $service = $definitions->first_service();
+is $service->get_name(), 'Service1', 'wsdl:import service name';
+is $definitions->first_binding()->get_name(), 'Service1Soap', 'wsdl:import binding name';
+
+ok my $schema_from_ref = $definitions->first_types()->get_schema();
+is @{ $schema_from_ref }, 2, 'got builtin and imported schema';
+ok @{ $schema_from_ref->[1]->get_element } > 0;
+is $schema_from_ref->[1]->get_element->[0]->get_name(), 'sayHello';
 
 __END__
 

t/SOAP/WSDL/Factory/Transport.t

@@ -1,9 +1,13 @@
 use strict;
 use warnings;
-use Test::More tests => 5;
+use Test::More tests => 6;
 use Scalar::Util qw(blessed);
 use SOAP::WSDL::Factory::Transport;
 
+eval { SOAP::WSDL::Factory::Transport->get_transport('') };
+like $@, qr{^no transport};
+
+
 eval { SOAP::WSDL::Factory::Transport->get_transport('zumsl') };
 like $@, qr{^no transport};
 
@@ -12,7 +16,7 @@ ok blessed $obj;
 
 SOAP::WSDL::Factory::Transport->register('zumsl', 'Hope_You_Have_No_Such_Package_Installed');
 
-eval { SOAP::WSDL::Factory::Transport->get_transport('zumsl') };
+eval { SOAP::WSDL::Factory::Transport->get_transport('zumsl:foo') };
 like $@, qr{^Cannot load};
 
 eval { SOAP::WSDL::Factory::Transport->register( \'zumsl', 'Foo') };

t/SOAP/WSDL/Generator/Template.t

@@ -44,7 +44,7 @@ print $@ if $@;
 # print $output;
 __END__
 
-my $tt = Template->new( 
+my $tt = Template->new(
     DEBUG => 1,
     EVAL_PERL => 1,
     RECURSION => 1,
@@ -53,7 +53,7 @@ my $tt = Template->new(
 
 foreach my $service (@{ $definitions->get_service }) {
     my $output;
-    $tt->process( 'Interface.tt', { 
+    $tt->process( 'Interface.tt', {
         definitions => $definitions,
         service => $service,
         interface_prefix => 'MyInterface',
@@ -62,8 +62,8 @@ foreach my $service (@{ $definitions->get_service }) {
         element_prefix => 'MyElement',
     }, \$output);
     die $tt->error if $tt->error();
-    
+
     ok eval $output, 'eval output';
-    
+
     print $output;
 };

t/SOAP/WSDL/Generator/XSD.t

@@ -1,4 +1,4 @@
-use Test::More tests => 38;
+use Test::More tests => 41;
 use File::Basename qw(dirname);
 use File::Spec;
 use File::Path;
@@ -149,5 +149,12 @@ is $ct_east->get_testAtomicSimpleTypeElement2->get_value(), 23;
 isa_ok($ct_east->get_testAtomicSimpleTypeElement2, 
     'MyTypes::testComplexTypeElementAtomicSimpleType::_testAtomicSimpleTypeElement2');
 
+ok eval { require MyElements::testElementCompletelyEmptyComplex; }
+    , 'load MyElements::testElementCompletelyEmptyComplex';
+ok my $empty = MyElements::testElementCompletelyEmptyComplex->new();
+
+is $empty->serialize_qualified(), '<testElementCompletelyEmptyComplex xmlns="urn:Test"/>'
+    , 'serialize empty';
+    
 
 rmtree "$path/testlib";

t/SOAP/WSDL/PortType.t

@@ -0,0 +1,32 @@
+use strict;
+use warnings;
+use Test::More tests => 4;
+
+use SOAP::WSDL::Operation;
+use_ok qw(SOAP::WSDL::PortType);
+
+my $portType = SOAP::WSDL::PortType->new({
+    operation => [
+        SOAP::WSDL::Operation->new({
+            name => 'foo',
+            targetNamespace => 'bar',
+        }),
+        SOAP::WSDL::Operation->new({
+            name => 'foo',
+            targetNamespace => 'baz',
+        }),
+        SOAP::WSDL::Operation->new({
+            name => 'foobar',
+            targetNamespace => 'bar',
+        }),
+    ]
+});
+
+
+my $operation = $portType->find_operation('bar', 'foobar');
+is $operation->get_name(), 'foobar', 'found operation';
+$operation = $portType->find_operation('baz', 'foo');
+is $operation->get_name(), 'foo', 'found operation';
+
+$operation = $portType->find_operation('baz', 'foobar');
+is $operation, undef, 'find_operation returns undef on unknown operation';

t/SOAP/WSDL/Server.t

@@ -55,8 +55,13 @@ eval { $server->handle($request) };
 like $@, qr{\A Not \s implemented:}x, 'Not implemented fault caught';
 
 
+$server->set_action_map_ref({ Test => 'test'});
+ok $server->handle($request);
 
 $server->set_deserializer('MyDeserializer2');
 eval { $server->handle(HTTP::Request->new()) };
 like $@, qr{\A Error \s deserializing}x, 'Error deserializing caught';
 
+sub test {
+    return;
+}

t/SOAP/WSDL/Server/CGI.t

@@ -11,7 +11,7 @@ use Test::More;
 eval "require IO::Scalar"
     or plan skip_all => 'IO::Scalar required for testing...';
 
-plan tests => 8;
+plan tests => 12;
 
 use_ok(SOAP::WSDL::Server);
 use_ok(SOAP::WSDL::Server::CGI);
@@ -30,51 +30,113 @@ $server->set_action_map_ref({
 my $output = q{};
 my $fh = IO::Scalar->new(\$output);
 my $stdout = *STDOUT;
+my $stdin = *STDIN;
 
 *STDOUT = $fh;
+{
+    local %ENV;
+    $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{};
+    
+    delete $ENV{EXPECT};
+    
+    my $input = 'Foobar';
+    my $ih = IO::Scalar->new(\$input);
+    $ih->seek(0);
+    *STDIN = $ih;
+    
+#    my $buffer;
+#    read(*STDIN, $buffer, 6);
+#    die $buffer;
+    $ENV{HTTP_SOAPAction} = 'bar';
+    $ENV{CONTENT_LENGTH} = 6;
+    $server->handle();
+    like $output, qr{ Error \s deserializing \s message}xms;
+    $output = q{};
+    $ih->seek(0);
 
-$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{};
+    $input = q{<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >
+    <SOAP-ENV:Body></SOAP-ENV:Body></SOAP-ENV:Envelope>};
+    $ENV{HTTP_SOAPAction} = 'bar';
+    $ENV{CONTENT_LENGTH} = length $input;
+    $server->handle();
+#    die $output;
+    like $output, qr{ Not \s found:}xms;
+    $output = q{};
+    $ih->seek(0);
 
 
+    $server->set_dispatch_to( 'HandlerClass' );
+    $server->set_action_map_ref({
+        'bar' => 'bar',
+    });
+    $input = q{<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >
+    <SOAP-ENV:Body></SOAP-ENV:Body></SOAP-ENV:Envelope>};
+    $ENV{HTTP_SOAPAction} = q{"bar"};
+    $ENV{CONTENT_LENGTH} = length $input;
+    $server->handle();
+    use Data::Dumper;
+    like $output, qr{ \A Status: \s 200 \s OK}xms;
+    $output = q{};
+    $ih->seek(0);
+
+
+    $server->set_dispatch_to( 'HandlerClass' );
+    $server->set_action_map_ref({
+        'bar' => 'bar',
+    });
+    $input = q{<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" >
+    <SOAP-ENV:Body></SOAP-ENV:Body></SOAP-ENV:Envelope>};
+    $ENV{SERVER_SOFTWARE} ='IIS Foobar';
+    $ENV{HTTP_SOAPAction} = q{"bar"};
+    $ENV{CONTENT_LENGTH} = length $input;
+    $server->handle();
+    use Data::Dumper;
+    like $output, qr{ \A HTTP/1.0 \s 200 \s OK}xms;
+    $output = q{};
+    $ih->seek(0);
+
+}
+
+# restore handles
 *STDOUT = $stdout;
-
+*STDIN = $stdin;
 # print $output;

t/SOAP/WSDL/XSD/Attribute.t

@@ -0,0 +1,40 @@
+use strict;
+use warnings;
+use Test::More tests => 2; #qw(no_plan);
+
+use_ok qw(SOAP::WSDL::XSD::Attribute);
+
+use SOAP::WSDL::Expat::WSDLParser;
+my $parser = SOAP::WSDL::Expat::WSDLParser->new();
+
+my $xml = q{<s:schema elementFormDefault="qualified"
+            targetNamespace="urn:HelloWorld" xmlns:s="http://www.w3.org/2001/XMLSchema">
+            <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:sequence>
+                    <s:attribute name="testAttr" type="s:string" use="optional"></s:attribute>
+                </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:schema>
+};
+
+my $schema = $parser->parse($xml);
+
+is $schema->find_element('urn:HelloWorld', 'sayHello')
+    ->first_complexType()
+    ->first_attribute()->get_name(),
+    'testAttr', 'found attribute';

t/SOAP/WSDL/XSD/Element.t

@@ -1,11 +1,11 @@
 package Foo;
 sub serialize {
-    return "serialized $_[1] $_[2]";
+    return "serialized $_[1] $_[2]" . join ' ', @{$_[3]->{ attributes } || [] } if $_[3];
 }
 package main;
 use strict;
 use warnings;
-use Test::More tests => 12;
+use Test::More tests => 16;
 
 use_ok qw(SOAP::WSDL::XSD::Element);
 
@@ -16,6 +16,9 @@ is $element->first_simpleType(), undef;
 $element->set_simpleType('Foo');
 is $element->first_simpleType(), 'Foo';
 
+is $element->serialize('Foobar', 'Bar', { namespace => {} } ), 'serialized Foobar Bar';
+is $element->serialize('Foobar', undef, { namespace => {} } ), 'serialized Foobar ';
+
 $element->set_simpleType( [ 'Foo', 'Bar' ]);
 is $element->first_simpleType(), 'Foo';
 
@@ -30,6 +33,13 @@ is $element->first_complexType(), 'Foo';
 $element->set_default('Foo');
 is $element->serialize('Foobar', undef, { namespace => {} } ), 'serialized Foobar Foo';
 
+$element->set_targetNamespace('urn:foobar');
+is $element->serialize('Foobar', undef, { namespace => {}, qualify => 1 } ), 'serialized Foobar Foo xmlns="urn:foobar"';
+
+$element->set_targetNamespace('urn:foobar');
+is $element->serialize('Foobar', 'Bar', { namespace => {}, qualify => 1 } ), 'serialized Foobar Bar xmlns="urn:foobar"';
+
+
 $element->set_name('Bar');
 is $element->serialize(undef, undef, { namespace => {} } ), 'serialized Bar Foo';
 

t/SOAP/WSDL/XSD/Schema.t

@@ -0,0 +1,32 @@
+use strict;
+use warnings;
+use Test::More tests => 4;
+
+use SOAP::WSDL::XSD::Element;
+use_ok qw(SOAP::WSDL::XSD::Schema);
+
+my $obj = SOAP::WSDL::XSD::Schema->new({
+    element => [
+        SOAP::WSDL::XSD::Element->new({
+            name => 'foo',
+            targetNamespace => 'bar',
+        }),
+        SOAP::WSDL::XSD::Element->new({
+            name => 'foo',
+            targetNamespace => 'baz',
+        }),
+        SOAP::WSDL::XSD::Element->new({
+            name => 'foobar',
+            targetNamespace => 'bar',
+        }),
+    ]
+});
+
+
+my $found= $obj->find_element('bar', 'foobar');
+is $found->get_name(), 'foobar', 'found Element';
+$found = $obj->find_element('baz', 'foo');
+is $found->get_name(), 'foo', 'found Element';
+
+$found = $obj->find_element('baz', 'foobar');
+is $found, undef, 'find_Element returns undef on unknown Element';

t/SOAP/WSDL/XSD/Typelib/ComplexType.t

@@ -18,7 +18,7 @@ package MyType;
 use base qw(SOAP::WSDL::XSD::Typelib::ComplexType);
 {
     my %test_of :ATTR(:get<test>);
-    
+
     __PACKAGE__->_factory(
         [ 'test' ],
         { test => \%test_of, },
@@ -41,11 +41,11 @@ use base qw(SOAP::WSDL::XSD::Typelib::AttributeSet);
     my %test2_of    :ATTR(:get<test2>);
     __PACKAGE__->_factory(
         [ 'test', 'test2' ],
-        { 
+        {
             test => \%test_of,
             test2 => \%test2_of,
         },
-        { 
+        {
             test => 'SOAP::WSDL::XSD::Typelib::Builtin::string',
             test2 => 'MyAttribute',
         }
@@ -68,21 +68,18 @@ __PACKAGE__->_factory(
 );
 
 package main;
-use Test::More tests => 106;
+use Test::More tests => 109;
 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/>';
-
+for my $class (qw{MyEmptyType MyEmptyType2}) {
+    $obj = $class->new();
+    is $obj->serialize, '', "$class object serializes to q{}";
+    is $obj->serialize({ name => 'test'}), '<test/>', "$class object serializes to <test/> with name=test";
+}
 
 $obj = MyType->new({});
 isa_ok $obj, 'MyType';
@@ -101,16 +98,17 @@ 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({ 
+$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({ 
+$obj = MyType->new({
     test => { value => 'Test2' } # just a trick - pass it unaltered to new...
 });
 isa_ok $obj, 'MyType';
@@ -120,17 +118,18 @@ is $obj->get_test, 'Test2', 'element content';
 $hash_of_ref = $obj->as_hash_ref();
 is $hash_of_ref->{ test }, 'Test2';
 
-$obj = MyType->new({ 
+$obj = MyType->new({
     test => [
-        SOAP::WSDL::XSD::Typelib::Builtin::string->new({ 
+        SOAP::WSDL::XSD::Typelib::Builtin::string->new({
             value => 'Test'
         }),
 
-        SOAP::WSDL::XSD::Typelib::Builtin::string->new({ 
+        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])';
@@ -154,24 +153,21 @@ is $nested->get_test->[0], $obj;
 $nested = MyType2->new({
     test => {
         test => [
-            SOAP::WSDL::XSD::Typelib::Builtin::string->new({ 
+            SOAP::WSDL::XSD::Typelib::Builtin::string->new({
                 value => 'Test'
             }),
-    
-            SOAP::WSDL::XSD::Typelib::Builtin::string->new({ 
+
+            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';
@@ -197,6 +193,11 @@ for my $count (1..5) {
 $obj->set_test();
 is $obj->get_test, (), 'removed element content';
 
+$obj = MyEmptyType->new();
+eval {
+    isa_ok $obj->attr() , 'SOAP::WSDL::XSD::Typelib::AttributeSet';
+};
+like $@, qr{\s has \s no \s attributes}x;
 
 $obj = MyElement->new();
 isa_ok $obj->attr() , 'SOAP::WSDL::XSD::Typelib::AttributeSet';
@@ -212,7 +213,7 @@ is $obj->serialize(),
     'Serialization with attributes';
 
 $obj->attr()->set_test2('test');
-is $obj->serialize(), 
+is $obj->serialize(),
     q{<MyElement test="TestAttribute" test2="test"/>},
     'Serialization with attributes';
 
@@ -227,7 +228,7 @@ is $obj->get_test, undef;
     eval { $foo = @{ $obj->get_test() } };
     if (! $@) {
         is $foo, undef;
-    } 
+    }
     else {
         like $@ , qr{Can't \s use \s an \s undefined}x, 'get_ELEMENT still undef on ARRAYIFY';
     }
@@ -260,13 +261,18 @@ for my $count (1..5) {
         is $obj->get_test->[$index], "TestString$index";
     }
     is $obj->serialize(), $serialized[$count -1];
-    
+
 }
 
+my $clone = Storable::thaw( Storable::freeze( $obj ));
+is $clone->get_test()->[0], 'TestString0';
+
+## failure tests
+
 eval {
-    $obj = MyType->new({ 
+    $obj = MyType->new({
     test => [
-            SOAP::WSDL::XSD::Typelib::Builtin::string->new({ 
+            SOAP::WSDL::XSD::Typelib::Builtin::string->new({
                 value => 'Test'
             }),
 
@@ -277,14 +283,22 @@ eval {
 like $@, qr{cannot \s use \s CODE}xms;
 
 eval {
-    $obj = MyType->new({ 
+    $obj = MyType->new({
     test => \&CORE::die,
     });
 };
 like $@, qr{cannot \s use \s CODE}xms;
 
+# TODO ignore XMLNS (for now)
+$obj = MyType->new({ xmlns => 'fubar'});
+ok defined $obj;
+TODO: {
+    local $TODO = "Support XML namespaces";
+    is $obj->get_xmlns(), 'fubar';
+}
+
 eval {
-    $obj = MyType->new({ 
+    $obj = MyType->new({
         foobar => 'fubar'
     });
 };
@@ -300,16 +314,13 @@ 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;
 
+# print Dumper