HTTP-DAV

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

    *   bug fixes

          - Fixed RT #59674 (http://rt.cpan.org/Public/Bug/Display.html?id=59674),
                When SSL support is needed but not installed, a more specific
            error messages is now displayed, instead of "not DAV enabled or not accessible".

  v0.40 (released 2010/01/27):
    *   bug fixes

          - Fixed RT #47500 (http://rt.cpan.org/Public/Bug/Display.html?id=47500),
                HTTP::DAV::Comms->credentials() method erroneously autovivified
                basic authentication internal values, causing wrong or undefined
                credentials to be sent out, or credentials to be "forgot" by HTTP::DAV.

  v0.39 (released 2009/12/12):
    *   bug fixes

          - Fixed RT #52665 (http://rt.cpan.org/Public/Bug/Display.html?id=52665),
                Using dave or propfind() on URLs containing escaped chars (%xx) could fail,
                due to upper/lower case differences. Thanks to cebjyre for the patch
                and the test case.

  v0.38 (released 2009/06/09):

Changes  view on Meta::CPAN

                in the "SCALAR(0x12345678)" being logged instead of the real scalar.

  v0.36 (released 2009/02/25):
    *   bug fixes

          - Fixed RT #19616 (http://rt.cpan.org/Public/Bug/Display.html?id=19616),
            LWP::UserAgent::redirect_ok() is not changed anymore. We're subclassing
            it from HTTP::DAV::UserAgent and overriding redirect_ok() there.

          - Fixed RT #42877 (http://rt.cpan.org/Public/Bug/Display.html?id=42877),
            HTTP::DAV::UserAgent::credentials() has been modified to behave like
            LWP::UserAgent::credentials(), otherwise basic authentication breakages
            can occur.

          - Fixed a problem with C<-depth> argument to C<HTTP::DAV::propfind()> that
            could lead to massive performance degradation, especially when running
                C<propfind()> against large folders.
                C<-depth> was set to 1 even when passed as zero.

  v0.35 (released 2008/11/03):
    *   bug fixes

bin/dave  view on Meta::CPAN

   pod2usage( -message => "$0: You must only specify one URL.\n")
}

print $OUT <<END;

dave -- DAV Explorer (v$VERSION)
Try "help", or "open http://host.com/dav_enabled_dir/"

END

# Put the credentials into HTTP::DAV for $url
my $url=shift @ARGV;
if ($user && $url) {
   $gdc->credentials( -user=>$user, -pass=>$pass, -url=>$url );
}
&command_open($url) if ($url );

######################################################################
# WHILE dave> command
my $line;
while ( defined ($line = $term->readline($prompt)) ) {

   # Hack. Put a space between the ! shellout command and the next arg
   $line =~ s/^([!])/$1 /g;

bin/dave  view on Meta::CPAN

       return $self;
    }

    sub request {
       my($self) = shift;
       my $resp = $self->SUPER::request(@_);

       # Only if we did not get a 401 back from the server
       # do we go and 
       # commit the user's details to memory.
       $self->_commit_credentials() if ($resp->code() != 401);
       return $resp;
    }

    sub _set_credentials {shift->{_temp_credentials} = \@_; }
    sub _commit_credentials {
       my ($self)=@_;
       if (defined $self->{_temp_credentials} ) {
          $self->credentials(@{$self->{_temp_credentials}});
          $self->{_temp_credentials} = undef;
       }
    }

    sub get_basic_credentials {
       my($self, $realm, $url) = @_;
       my $userpass;

       # First, try to get the details from our memory.
       my @mem_userpass = $self->SUPER::get_basic_credentials($realm,$url);
       return @mem_userpass if @mem_userpass;

       if (-t) {

          my $netloc = $url->host_port;
          if ($self->{_failed_logins}->{$realm . $netloc}++ > 3) {
             return (undef,undef) 
          }

          print "\nEnter username for $realm at $netloc: ";
          my $user = <STDIN>;
          chomp($user);
          return (undef, undef) unless length $user;
          print "Password: ";
          system("stty -echo");
          my $password = <STDIN>;
          system("stty echo");
          print "\n";  # because we disabled echo
          chomp($password);

          $self->_set_credentials($netloc, $realm,$user,$password);
          #print "Returning $user, $password\n";
          return ($user, $password);
      } else {
          return (undef, undef)
      }
   }
}

######################################################################
# Setup our help system with this nifty Pod::Parser from the 

doc/html/Changes.html  view on Meta::CPAN

</li>
</ul>

<h2 id="v0.40-released-2010-01-27">v0.40 (released 2010/01/27):</h2>

<ul>

<li><p><b>bug fixes</b></p>

<pre><code>- Fixed RT #47500 (http://rt.cpan.org/Public/Bug/Display.html?id=47500),
      HTTP::DAV::Comms-&gt;credentials() method erroneously autovivified
      basic authentication internal values, causing wrong or undefined
      credentials to be sent out, or credentials to be &quot;forgot&quot; by HTTP::DAV.</code></pre>

</li>
</ul>

<h2 id="v0.39-released-2009-12-12">v0.39 (released 2009/12/12):</h2>

<ul>

<li><p><b>bug fixes</b></p>

doc/html/Changes.html  view on Meta::CPAN


<ul>

<li><p><b>bug fixes</b></p>

<pre><code>- Fixed RT #19616 (http://rt.cpan.org/Public/Bug/Display.html?id=19616),
  LWP::UserAgent::redirect_ok() is not changed anymore. We&#39;re subclassing
  it from HTTP::DAV::UserAgent and overriding redirect_ok() there.

- Fixed RT #42877 (http://rt.cpan.org/Public/Bug/Display.html?id=42877),
  HTTP::DAV::UserAgent::credentials() has been modified to behave like
  LWP::UserAgent::credentials(), otherwise basic authentication breakages
  can occur.

- Fixed a problem with C&lt;-depth&gt; argument to C&lt;HTTP::DAV::propfind()&gt; that
  could lead to massive performance degradation, especially when running
      C&lt;propfind()&gt; against large folders.
      C&lt;-depth&gt; was set to 1 even when passed as zero.</code></pre>

</li>
</ul>

doc/html/HTTP-DAV.html  view on Meta::CPAN


<pre><code>   # DAV script that connects to a webserver, safely makes 
   # a new directory and uploads all html files in 
   # the /tmp directory.

   use HTTP::DAV;
  
   $d = HTTP::DAV-&gt;new();
   $url = &quot;http://host.org:8080/dav/&quot;;
 
   $d-&gt;credentials(
      -user  =&gt; &quot;pcollins&quot;,
      -pass  =&gt; &quot;mypass&quot;, 
      -url   =&gt; $url,
      -realm =&gt; &quot;DAV Realm&quot;
   );
 
   $d-&gt;open( -url =&gt; $url )
      or die(&quot;Couldn&#39;t open $url: &quot; .$d-&gt;message . &quot;\n&quot;);
 
   # Make a null lock on newdir

doc/html/HTTP-DAV.html  view on Meta::CPAN


<p>The <code>-useragent</code> parameter allows you to pass your own <b>user agent object</b> and expects an <code>HTTP::DAV::UserAgent</code> object. See the <code>dave</code> program for an advanced example of a custom UserAgent that interactively ...

<p>The <code>-headers</code> parameter allows you to specify a list of headers to be sent along with all requests. This can be either a hashref like:</p>

<pre><code>{ &quot;X-My-Header&quot; =&gt; &quot;value&quot;, ... }</code></pre>

<p>or a <a>HTTP::Headers</a> object.</p>

</dd>
<dt id="credentials-USER-PASS-URL-REALM"><b>credentials(USER,PASS,[URL],[REALM])</b></dt>
<dd>

<p>sets authorization credentials for a <code>URL</code> and/or <code>REALM</code>.</p>

<p>When the client hits a protected resource it will check these credentials to see if either the <code>URL</code> or <code>REALM</code> match the authorization response.</p>

<p>Either <code>URL</code> or <code>REALM</code> must be provided.</p>

<p>returns no value</p>

<p>Example:</p>

<pre><code>$d-&gt;credentials( -url=&gt;&#39;myhost.org:8080/test/&#39;,
                 -user=&gt;&#39;pcollins&#39;,
                 -pass=&gt;&#39;mypass&#39;);</code></pre>

</dd>
<dt id="DebugLevel-val"><b>DebugLevel($val)</b></dt>
<dd>

<p>sets the debug level to <code>$val</code>. 0=off 3=noisy.</p>

<p><code>$val</code> default is 0.</p>

lib/HTTP/DAV.pm  view on Meta::CPAN

sub get_workingresource { $_[0]->{_workingresource} }

sub get_workingurl {
    $_[0]->{_workingresource}->get_uri()
        if defined $_[0]->{_workingresource};
}
sub get_lockedresourcelist { $_[0]->{_lockedresourcelist} }

# SET
sub set_workingresource { $_[0]->{_workingresource} = $_[1]; }
sub credentials { shift->{_comms}->credentials(@_); }

######################################################################
# Error handling

## Error conditions
my %err = (
    'ERR_WRONG_ARGS'    => 'Wrong number of arguments supplied.',
    'ERR_UNAUTHORIZED'  => 'Unauthorized. ',
    'ERR_NULL_RESOURCE' => 'Not connected. Do an open first. ',
    'ERR_RESP_FAIL'     => 'Server response: ',

lib/HTTP/DAV.pm  view on Meta::CPAN


   # DAV script that connects to a webserver, safely makes 
   # a new directory and uploads all html files in 
   # the /tmp directory.

   use HTTP::DAV;
  
   $d = HTTP::DAV->new();
   $url = "http://host.org:8080/dav/";
 
   $d->credentials(
      -user  => "pcollins",
      -pass  => "mypass", 
      -url   => $url,
      -realm => "DAV Realm"
   );
 
   $d->open( -url => $url )
      or die("Couldn't open $url: " .$d->message . "\n");
 
   # Make a null lock on newdir

lib/HTTP/DAV.pm  view on Meta::CPAN

 $d = HTTP::DAV->new();

The C<-useragent> parameter allows you to pass your own B<user agent object> and expects an C<HTTP::DAV::UserAgent> object. See the C<dave> program for an advanced example of a custom UserAgent that interactively prompts the user for their username a...

The C<-headers> parameter allows you to specify a list of headers to be sent along with all requests. This can be either a hashref like:

  { "X-My-Header" => "value", ... }

or a L<HTTP::Headers> object.

=item B<credentials(USER,PASS,[URL],[REALM])>

sets authorization credentials for a C<URL> and/or C<REALM>.

When the client hits a protected resource it will check these credentials to see if either the C<URL> or C<REALM> match the authorization response.

Either C<URL> or C<REALM> must be provided.

returns no value

Example:

 $d->credentials( -url=>'myhost.org:8080/test/',
                  -user=>'pcollins',
                  -pass=>'mypass');

=item B<DebugLevel($val)>

sets the debug level to C<$val>. 0=off 3=noisy.

C<$val> default is 0. 

returns no value.

lib/HTTP/DAV/Changes.pod  view on Meta::CPAN


=back

=head2 v0.40 (released 2010/01/27):

=over 4

=item * B<bug fixes>

  - Fixed RT #47500 (http://rt.cpan.org/Public/Bug/Display.html?id=47500),
	HTTP::DAV::Comms->credentials() method erroneously autovivified
	basic authentication internal values, causing wrong or undefined
	credentials to be sent out, or credentials to be "forgot" by HTTP::DAV.

=back

=head2 v0.39 (released 2009/12/12):

=over 4

=item * B<bug fixes>

  - Fixed RT #52665 (http://rt.cpan.org/Public/Bug/Display.html?id=52665),

lib/HTTP/DAV/Changes.pod  view on Meta::CPAN


=over 4

=item * B<bug fixes>

  - Fixed RT #19616 (http://rt.cpan.org/Public/Bug/Display.html?id=19616),
    LWP::UserAgent::redirect_ok() is not changed anymore. We're subclassing
    it from HTTP::DAV::UserAgent and overriding redirect_ok() there.

  - Fixed RT #42877 (http://rt.cpan.org/Public/Bug/Display.html?id=42877),
    HTTP::DAV::UserAgent::credentials() has been modified to behave like
    LWP::UserAgent::credentials(), otherwise basic authentication breakages
    can occur.

  - Fixed a problem with C<-depth> argument to C<HTTP::DAV::propfind()> that
    could lead to massive performance degradation, especially when running
	C<propfind()> against large folders.
	C<-depth> was set to 1 even when passed as zero.

=back

=head2 v0.35 (released 2008/11/03):

lib/HTTP/DAV/Comms.pm  view on Meta::CPAN

    # URL management
    my $url_obj;
    $url_obj = ( ref($url) =~ /URI/ ) ? $url : URI->new($url);

    die "Comms: Bad HTTP Url: \"$url_obj\"\n"
        if ( $url_obj->scheme !~ /^http/ );

    # If you see user:pass detail embedded in the URL. Then get it out.
    if ( $url_obj->userinfo ) {
        $self->{_user_agent}
            ->credentials( $url, undef, split( ':', $url_obj->userinfo ) );
    }

    # Header management
    if ( $newheaders && ref($newheaders) !~ /Headers/ ) {
        die "Bad headers object: "
            . Data::Dumper->Dump( [$newheaders], ['$newheaders'] );
    }

    my $headers = HTTP::DAV::Headers->new();
    $headers->add_headers( $self->{_headers} );

lib/HTTP/DAV/Comms.pm  view on Meta::CPAN

    my $length = ($content) ? length($content) : 0;
    $headers->header( "Content-Length", $length );

    #print "HTTP HEADERS\n" . $self->get_headers->as_string . "\n\n";

    # It would be good if, at this stage, we could prefill the
    # username and password values to prevent the client having
    # to submit 2 requests, submit->401, submit->200
    # This is the same kind of username, password remembering
    # functionality that a browser performs.
    #@userpass = $self->{_user_agent}->get_basic_credentials(undef, $url);

    # Add a Content-type of text/xml if the body has <?xml in it
    if ( $content && $content =~ /<\?xml/i ) {
        $headers->header( "Content-Type", "text/xml" );
    }

    ####
    # Do the HTTP call
    my $req
        = HTTP::Request->new( $method, $url_obj, $headers->to_http_headers,

lib/HTTP/DAV/Comms.pm  view on Meta::CPAN

    # Save the req and resp objects as the "last used"
    $self->_set_last_request($req);
    $self->_set_last_response($dav_resp);

    $self->_set_server_type( $url_obj->host_port,
        $dav_resp->headers->header("Server") );

    return $dav_resp;
}

sub credentials {
    my ( $self, @p ) = @_;
    my ( $user, $pass, $url, $realm )
        = HTTP::DAV::Utils::rearrange( [ 'USER', 'PASS', 'URL', 'REALM' ],
        @p );
    $self->{_user_agent}->credentials( $url, $realm, $user, $pass );
}

###########################################################################
# We make our own specialization of LWP::UserAgent
# called HTTP::DAV::UserAgent.
# The variations allow us to have various levels of protection.
# Where the user hasn't specified what Realm to use we pass the
# userpass combo to all realms of that host
# Also this UserAgent remembers a user on the next request.
# The standard UserAgent doesn't.

lib/HTTP/DAV/Comms.pm  view on Meta::CPAN

    @ISA = qw(LWP::UserAgent);

    #require LWP::UserAgent;

    sub new {
        my $self = LWP::UserAgent::new(@_);
        $self->agent("lwp-request/$HTTP::DAV::VERSION");
        $self;
    }

    sub credentials {
        my ( $self, $netloc, $realm, $user, $pass ) = @_;

        $realm = 'default' unless $realm;

        if ($netloc) {
            $netloc = "http://$netloc" unless $netloc =~ m{^http};
            my $uri = URI->new($netloc);
            $netloc = $uri->host_port;
        }
        else {

lib/HTTP/DAV/Comms.pm  view on Meta::CPAN

		my $cred;
		if (
			exists $self->{basic_authentication}->{$netloc} &&
			exists $self->{basic_authentication}->{$netloc}->{$realm}) {
			$cred = $self->{basic_authentication}->{$netloc}->{$realm};
		}
		else {
			$cred = [];
		}

        # Replace with new credentials (if any)
        if (defined $user) {
            $self->{basic_authentication}->{$netloc}->{$realm}->[0] = $user;
            $self->{basic_authentication}->{$netloc}->{$realm}->[1] = $pass;
			$cred = $self->{basic_authentication}->{$netloc}->{$realm};
        }

        # Return current values
		if (! @{$cred}) {
			return wantarray ? () : undef;
		}

        # User/password pair
        if (wantarray) { return @{$cred} }

        # As string: 'user:password'
        return join( ':', @{$cred} );
    }

    sub get_basic_credentials {
        my ( $self, $realm, $uri ) = @_;

        $uri = HTTP::DAV::Utils::make_uri($uri);
        my $netloc = $uri->host_port;

        my $userpass;
        {
            no warnings;    # SHUTUP with your silly warnings.
            $userpass 
                = $self->{'basic_authentication'}{$netloc}{$realm}

lib/HTTP/DAV/Resource.pm  view on Meta::CPAN

}

sub get_options { $_[0]->{_options}; }

sub get_content     { $_[0]->{_content}; }
sub get_content_ref { \$_[0]->{_content}; }

sub get_username {
    my ($self) = @_;
    my $ra = $self->{_comms}->get_user_agent();
    my @userpass = $ra->get_basic_credentials(undef, $self->get_uri());
    return $userpass[0];
}

#sub get_lockpolicy { $_[0]->{_lockpolicy}; }
sub get_client              { $_[0]->{_dav_client}; }
sub get_resourcelist        { $_[0]->{_resource_list}; }
sub get_lockedresourcelist  { $_[0]->{_lockedresourcelist}; }
sub get_comms               { $_[0]->{_comms}; }
sub get_property            { $_[0]->{_properties}{ $_[1] } || ""; }
sub get_uri                 { $_[0]->{_uri}; }

t/2_options.t  view on Meta::CPAN

use TestDetails qw($test_user $test_pass $test_url do_test fail_tests test_callback);

my $TESTS;
$TESTS = 6;
plan tests => $TESTS; 
fail_tests($TESTS) unless $test_url =~ /http/;

my $dav = HTTP::DAV->new;
$dav->DebugLevel(3);

$dav->credentials( $test_user, $test_pass, $test_url );

my $resource = $dav->new_resource( -uri => $test_url );
my $response = $resource->options();
if ( ! ok($response->is_success) ) {
   print $response->message() ."\n";
}

print "DAV compliancy: ". $resource->is_dav_compliant(). "\n";
ok($resource->is_dav_compliant());

t/3_put_get_delete.t  view on Meta::CPAN

my $TESTS;
$TESTS = 6;
plan tests => $TESTS;
fail_tests($TESTS) unless $test_url =~ /http/;



my $dav = HTTP::DAV->new;
HTTP::DAV::DebugLevel(3);

$dav->credentials( $test_user,$test_pass,$test_url );

my $collection = $test_url;
$collection=~ s#/$##g; # Remove trailing slash. We'll put it on.
my $new_file = "$collection/dav_test_file.txt";
print "File: $new_file\n";
my $resource = $dav->new_resource( -uri => $new_file );

my $response;

$response = $resource->put("DAV.pm test content ");

t/5_propfind.t  view on Meta::CPAN

# module.

my $TESTS;
$TESTS=9;
plan tests => $TESTS;
fail_tests($TESTS) unless $test_url =~ /http/;

my $dav = HTTP::DAV->new;
HTTP::DAV::DebugLevel(3);

$dav->credentials( $test_user,$test_pass,$test_url );

my $response;
my $resource = $dav->new_resource( -uri => $test_url );

######################################################################
# RUN THE TESTS

ok($resource->set_property('testing','123'));
ok($resource->get_property('testing'),'123');
ok($resource->is_collection(),0);

t/5_proppatch.t  view on Meta::CPAN

Test 3. Then lock perldav_test and do a proppatch. No namespace
   3a. LOCK perldav_test
   3a. PROPPATCH perldav_test (set test_prop=test_val)
   3b. PROPPATCH perldav_test (remove DAV:test_prop)
   3b. UNLOCK perldav_test

=cut 

# Setup
my $dav1 = HTTP::DAV->new();
$dav1->credentials( $user, $pass, $url );
do_test $dav1, $dav1->open  ( $url ),  1,"OPEN $url";

# Determine server's willingness to proppatching and locking
# IIS5 currently does not support pp on files or colls.
my $options =$dav1->options();
my $coll_proppatch=( $options=~/\bPROPPATCH\b/)?1:0;
my $coll_lock=     ( $options=~/\bLOCK\b/     )?1:0;
my $cps = ($coll_proppatch)?"supports":"does not support";
my $cls = ($coll_lock     )?"supports":"does not support";
print "$options\n";

t/6_dav_copy_move.t  view on Meta::CPAN

my $sourceuri = "perldav_test" .$$ . "_".time;
my $sourceurl = "$url/$sourceuri";
my $targeturi = ${sourceuri} . "_copy";
my $targeturl = "$url/$targeturi";
print "sourceuri: $sourceuri\n";
print "sourceurl: $sourceurl\n";
print "targeturi: $targeturi\n";
print "targeturl: $targeturl\n";

my $dav1 = HTTP::DAV->new();
$dav1->credentials( $user, $pass, $url );
do_test $dav1, $dav1->open ($url),    1,"OPEN $url";
do_test $dav1, $dav1->mkcol($sourceuri),    1,"MKCOL $sourceuri";
do_test $dav1, $dav1->mkcol("$sourceuri/subdir"), 1,"MKCOL $sourceuri/subdir";
do_test $dav1, $dav1->cwd  ($sourceuri),    1,"CWD $sourceuri";

print "COPY\n" . "----\n";
my $resource1 = $dav1->get_workingresource();
my $resource2 = $dav1->new_resource( -uri => $targeturl );
my $resource3 = $dav1->new_resource( -uri =>"$targeturl/subdir" );

t/6_dav_get_callback.t  view on Meta::CPAN

my $user = $test_user;
my $pass = $test_pass;
my $url = $test_url;
my $cwd = $test_cwd;

HTTP::DAV::DebugLevel(0);
my $dav;

# Test get_workingurl on empty client
$dav = HTTP::DAV->new( );
$dav->credentials( $user, $pass, $url );
do_test $dav, $dav->open( $url ), 1, "OPEN $url";

# Make a directory with our process id after it 
# so that it is somewhat random
my $newdir = "perldav_test$$";
do_test $dav, $dav->mkcol($newdir), 1, "MKCOL $newdir";
do_test $dav, $dav->cwd($newdir), 1, "CWD to $newdir";

# Make a big temporary file
print "CREATING temporary 1Mb file\n";

t/6_dav_globs.t  view on Meta::CPAN


my $targeturi = "perldav_test" .$$ . "_".time;
my $shorturi = "perldav_test" .$$;
my $targeturl = URI->new_abs($targeturi,$test_url);
my $localdir = "/tmp/$targeturi";

print "targeturi: $targeturi\n";
print "targeturl: $targeturl\n";

my $dav1 = HTTP::DAV->new();
$dav1->credentials( $test_user, $test_pass, $test_url );

# SETUP
# make URL/perldav_12341234/test_data/*
do_test $dav1, $dav1->open ($test_url),     1,"OPEN $test_url";
do_test $dav1, $dav1->mkcol($targeturl),    1,"MKCOL $targeturl";
do_test $dav1, mkdir($localdir), 1, "system mkdir $localdir";

# TEST 1
# Test that working directory =~ /$shorturi/
do_test $dav1, $dav1->cwd("$shorturi*"),    1,"CWD $shorturi*";

t/6_dav_lock.t  view on Meta::CPAN


Test 6. Then a delete/unlock sequence (should fail resource was delete)
   Client 1: UNLOCK perldav_test (should fail in client as no locks held after the delete).


=cut 

# Setup
my $dav1 = HTTP::DAV->new();
my $dav2 = HTTP::DAV->new();
$dav1->credentials( $user, $pass, $url );
$dav2->credentials( $user, $pass, $url );
do_test $dav1, $dav1->open( $url ), 1, "dav1->OPEN $url";
do_test $dav2, $dav2->open( $url ), 1, "dav2->OPEN $url";
do_test $dav1, $dav1->mkcol ($newdir),          1,"dav1->MKCOL $newdir";
do_test $dav1, $dav1->mkcol ("$newdir/subdir"), 1,"dav1->MKCOL $newdir/subdir";

# Test 1
do_test $dav1, $dav1->lock  ($newdir),          1,"dav1->LOCK $newdir";
do_test $dav1, $dav1->unlock($newdir),          1,"dav1->UNLOCK $newdir";

# Test 2

t/6_dav_lock2.t  view on Meta::CPAN

   Client 1: UNLOCK perldav_test with timeout=10m

Test 1. Test 2 shared locks
   Client 1: LOCK perldav_test with scope=shared
   Client 2: LOCK perldav_test with scope=shared
=cut 

# Setup
my $dav1 = HTTP::DAV->new();
my $dav2 = HTTP::DAV->new();
$dav1->credentials( $user, $pass, $url );
$dav2->credentials( $user, $pass, $url );
do_test $dav1, $dav1->open( $url ), 1, "dav1->OPEN $url";
do_test $dav2, $dav2->open( $url ), 1, "dav2->OPEN $url";
do_test $dav1, $dav1->mkcol ($newdir),          1,"dav1->MKCOL $newdir";
do_test $dav1, $dav1->mkcol ("$newdir/subdir"), 1,"dav1->MKCOL $newdir/subdir";

# Test 1
do_test $dav1, $dav1->lock(-url=>$newdir,-timeout=>"10m"), 1,"dav1->LOCK $newdir timeout=10mins";
my $u = $url; $u =~ s/\/$//g;
my $r1 = $dav1->new_resource("$u/$newdir");
my $r2 = $dav2->new_resource("$u/$newdir");

t/6_dav_open_put_get.t  view on Meta::CPAN


# Test get_workingurl on empty client
$dav = HTTP::DAV->new( );
do_test $dav, $dav->get_workingurl(), "", "Empty get_workingurl";

# Test an empty open. Should fail.
do_test $dav, $dav->open(), 0, "OPEN nothing";

$dav = HTTP::DAV->new();
# Set some creds and then open the URL
$dav->credentials( $user, $pass, $url );

do_test $dav, $dav->open( $url ), 1, "OPEN $url";

do_test $dav, $dav->open( -url => $url ), 1, "OPEN $url";

# Try opening a non-collection. It should fail.
#do_test $dav, $dav->open( -url => $geturl ), 0, "OPEN $geturl";

# Test various ways of getting the working url
my $working_url1 = $dav->get_workingresource()->get_uri();

t/6_dav_options.t  view on Meta::CPAN


=cut 

# Setup
# Make a directory with our process id after it 
# so that it is somewhat random
my $perldav_test_uri = "perldav_test" .$$;
my $perldav_test_url = "$url/$perldav_test_uri/";

my $dav = HTTP::DAV->new();
$dav->credentials( $user, $pass, $url );
do_test $dav, $dav->open ($url),          1,"OPEN $url";
do_test $dav, $dav->mkcol($perldav_test_uri),    1,"MKCOL $perldav_test_uri";

print "OPTIONS\n" . "----\n";
do_test $dav, $dav->options( "$url" ),              '/PROPFIND/', "OPTIONS $url (looking for PROPFIND)";
do_test $dav, $dav->options( "$perldav_test_uri" ), '/PROPFIND/', "OPTIONS $perldav_test_uri (looking for PROPFIND)";
do_test $dav, $dav->options( "$perldav_test_url" ), '/PROPFIND/', "OPTIONS $perldav_test_url (looking for PROPFIND)";

# Cleanup
do_test $dav, $dav->delete("$perldav_test_url"),1,"DELETE $perldav_test_url";

t/9_RT_42877.t  view on Meta::CPAN


$HTTP::DAV::DEBUG =
$HTTP::DAV::DEBUG = 3;

my $netloc = 'mylocation';
my $realm = 'myrealm';
my $user = 'randomuser';
my $pass = '12345';

my $ua = HTTP::DAV::UserAgent->new();
my $existing_credentials = $ua->credentials($netloc, $realm);

is ($existing_credentials, undef, 'No credentials defined at start');
$ua->credentials($netloc, $realm, $user, $pass);

$existing_credentials = $ua->credentials($netloc, $realm);
is ($existing_credentials, "$user:$pass", 'credentials() called in scalar context');

my @cred = $ua->credentials($netloc, $realm);

is(scalar @cred, 2, 'credentials() called in list context');
is($cred[0], $user, 'credentials() called in list context');
is($cred[1], $pass, 'credentials() called in list context');

t/9_RT_47500.t  view on Meta::CPAN

#$HTTP::DAV::DEBUG = 0;

# Normalize netloc with port (:80)
# or we might miss the hash key
my $netloc = 'mylocation:80';
my $realm = 'myrealm';
my $user = 'randomuser';
my $pass = '12345';

my $ua = HTTP::DAV::UserAgent->new();
my $existing_credentials = $ua->credentials($netloc, $realm);

ok (
	! exists $ua->{basic_authentication}->{$netloc}->{$realm},
	"Shouldn't autovivify the $netloc/$realm hash key when accessing it"
);

$ua->credentials($netloc, $realm, $user, $pass);

is_deeply (
	$ua->{basic_authentication}->{$netloc}->{$realm},
	[ $user, $pass ],
	'Credentials are correctly set',
);

my @cred = $ua->credentials($netloc, $realm);

is(scalar @cred, 2, 'credentials() has 2 elements');
is($cred[0], $user, 'credentials() stored correctly');
is($cred[1], $pass, 'credentials() stored correctly');

t/9_RT_60457.t  view on Meta::CPAN

#    if ($test_url !~ m{http}) {
#        skip("no test server", 4);
#    }

    use_ok('HTTP::DAV');
    use_ok('HTTP::DAV::Comms');

    my $dav = HTTP::DAV->new();
    HTTP::DAV::DebugLevel(3);

    $dav->credentials($test_user,$test_pass,$test_url);

    my $collection = $test_url;
    $collection =~ s{/$}{}g;
    my $new_file = "$collection/dav_test_file.txt";
    diag("File: $new_file");

    my $resource = $dav->new_resource( -uri => $new_file );
    my $response = $resource->put("DAV.pm test content ", {"X-DAV-Test" => "12345"});

    if (! ok($response->is_success)) {

t/TestDetails.pm  view on Meta::CPAN

use Test;
use Exporter;
use Cwd;

use vars qw(@EXPORT @EXPORT_OK $VERSION @ISA);
@ISA=qw(Exporter);
@EXPORT=qw(do_test fail_tests test_callback $test_user $test_pass $test_url $test_cwd);

# This package is designed to simplify testing.
# It allows you to enter multiple URL's (and 
# credentials) for the different tests.

# You need to manually edit the %details hash below.

# A test script may tell us that it is about to do a propfind.
# It would do this by calling TestDetails::method('PROPFIND');
# Then when the test script calls TestDetails::url() you will 
# get the URL specificed in the PROPFIND hash below.
# But, if you haven't specified any details in the hash below 
# specific for PROPFIND it will use the DEFAULT entries instead.



( run in 1.247 second using v1.01-cache-2.11-cpan-4d50c553e7e )