91p42revml.t #5

#!/usr/local/bin/perl -w

=head1 NAME

p4.t - testing of vcp p4 i/o

=cut

use strict ;

use Carp ;
use File::Spec ;
use POSIX ':sys_wait_h' ;
use Test ;
use VCP::TestUtils ;

# use eq_or_diff from Test::Differences if available,
# else just use ok.
eval "use Test::Differences";
sub ok_or_diff {
   if( defined &eq_or_diff ) {
      # $_[3] = { context => 3 }; # arg to eq_or_diff
      goto &eq_or_diff;
   }
   goto &Test::ok;
}


my $t = -d 't' ? 't/' : '' ;

my $p4_options ;
my $p4_spec_base ;
my $p4_rev_root ;
my $p4_spec ;

# what change number to start incremental export at
my $first_import_1_change; # was called $incr_change

sub clean_p4_branch_spec {  ## mutates ( $in, $out ) in place
  $_[0] =~ s{(<p4_branch_spec.*?>)(.*)(</p4_branch_spec>)}{  ## $in
     my ( $stag, $etag ) = ( $1, $3 );
     local $_ = $2;
     s{//ignored/}{//depot/foo/}g;
     s{^Options:.*}{}m;
     "$stag$_$etag";
  }sge;

  $_[1] =~ s{(<p4_branch_spec.*?>)(.*)(</p4_branch_spec>)}{  ## $out
     my ( $stag, $etag ) = ( $1, $3 );
     local $_ = $2;
     s/^#.*\r?\n\r?\n?//mg;
     s/^Access:.*\r?\n\r?\n//mg;
     s{^Options:.*}{}m;
     "$stag$_$etag";
  }sge;

}



my @tests = (

###
# start p4d in existing p4root_0
sub {
   $ENV{P4USER}   = "foobar_user" ;
   $ENV{P4PORT}   = "foobar_port" ;
   $ENV{P4CLIENT} = "foobar_client" ;
   $ENV{P4PASSWD} = "foobar_passwd" ;

   $p4_options = launch_p4d "p4_", { 
      repo_dir    => "${t}p4root_0",
   } ;
   $p4_spec_base = "p4:$p4_options->{user}:\@$p4_options->{port}:" ;
   $p4_rev_root = "//depot/foo/" ;
   $p4_spec = "$p4_spec_base$p4_rev_root" ;
   ok 1 ;
},

## revml -> p4 -> revml, bootstrap export
sub {
   my $infile  = $t . "test-p4-in-0.revml" ;
   ##
   ## Idempotency test
   ##
   ## These depend on the "test-foo-in-0.revml" files built in the makefile.
   ## See MakeMaker.PL for how those are generated.
   ##
   ## We are also testing to see if we can re-root the files under foo/...
   ##

   my $in  = slurp $infile ;
   my $out = get_vcp_output "$p4_spec..." ;

   s_content  qw( rep_desc time user_id p4_info ), \$in, \$out ;
   s_content  qw( rev_root ),                      \$in, "depot/foo" ;
#      rm_elts    qw( label ), qr/r_\w+|ch_\w+/,       \$in, \$out ;

   $in =~ s{(id="|_id>)/+ignored}{$1//depot/foo}g;
   $in =~ s{(id="|_id>)ignored}{$1depot/foo}g;

   clean_p4_branch_spec $in, $out;

   ok_or_diff $out, $in;
},


## Test a single file extraction from a p4 repo.  This file exists in
## change 1.
sub {
   ok(
      get_vcp_output( "${p4_spec}main/add/f1" ),
      qr{<rev_root>depot/foo/main/add</.+<name>f1<.+<rev_id>1<.+<rev_id>2<.+</revml>}s
   ) ;
},

## Test a single file extraction from a p4 repo.  This file does not exist
## in change 1.
sub {
   ok(
      get_vcp_output( "${p4_spec}main/add/f2" ),
      qr{<rev_root>depot/foo/main/add</.+<name>f2<.+<change_id>2<.+<change_id>3<.+</revml>}s
   ) ;

},


             
##-------------------------

##
## p4->revml, re-rooting a dir tree 
## copies //depot/foo/main/a/deeply/ as if it was a whole repo
## into a target dir as if it were a complete repository.             
##
sub {
   ## Hide global $p4_spec for the nonce
   my $p4_spec = "$p4_spec_base//depot/foo/main/a/deeply/" ;
   
   my $infile  = $t . "test-p4-in-0.revml" ;
   my $in  = slurp $infile ;
   my $out = get_vcp_output "${p4_spec}..." ;
   
   s_content qw( rep_desc time user_id       ), \$in, \$out ;
   s_content qw( rev_root ),                    \$in, "depot/foo/main/a/deeply" ;
   rm_elts   qw( mod_time change_id p4_info ),  \$in, \$out ;
   #      rm_elts   qw( label ), qr/r_\w+|ch_\w+/,           \$out ;
   
   
   ## Strip out all files from $in that shouldn't be there
   rm_elts    qw( rev ), qr{(?:(?!a/deeply).)*?}s, \$in ;
   
   ## Adjust the $in paths to look like the result paths.  $in is
   ## now the "expected" output.
   $in =~ s{<(name|source_name)>main/a/deeply/}{<$1>}g ;
   $in =~ s{(id="|_id>)/+ignored}{$1//depot/foo}g;
   $in =~ s{(id="|_id>)ignored}{$1depot/foo}g;
   
   rm_elts qw( branches ), \$in;
   
   ok_or_diff $out, $in;
},


##-------------------------

# determine next change number that p4d will use this will become the
# change number of the first change in t/test-p4-in-1.revml when it is
# imported.
sub {
   # get counter change
   run_p4 [ qw( counter change ) ],
      \undef,
      \$first_import_1_change,
      $p4_options ;

   chomp $first_import_1_change ;
   die "Invalid change counter value: '$first_import_1_change'"
      unless $first_import_1_change =~ /^\d+$/ ;

   ++$first_import_1_change ;

   ok 1;
},


# shut down the p4root_0 p4d
sub {
   $p4_options->{p4d_handle}->kill_kill;
   ok 1;
},


###
# start p4d in existing p4root_1
sub {
   $ENV{P4USER}   = "foobar_user" ;
   $ENV{P4PORT}   = "foobar_port" ;
   $ENV{P4CLIENT} = "foobar_client" ;
   $ENV{P4PASSWD} = "foobar_passwd" ;

   $p4_options = launch_p4d "p4_", { 
      repo_dir      => "${t}p4root_1",
   } ;
   $p4_spec_base = "p4:$p4_options->{user}:\@$p4_options->{port}:" ;
   $p4_spec = "$p4_spec_base//depot/foo/" ;
   ok 1 ;
},


##
## revml -> p4 -> revml, incremental export
##

sub {
   my $infile  = $t . "test-p4-in-1.revml" ;

   # see if got the right # of files, changes
   # p42revml will do detailed checking (the following code)
   my $in  = slurp $infile ;
   my $out = get_vcp_output "${p4_spec}...\@$first_import_1_change,#head" ;

   warn "--- in  > $1 <---\n"
      if $in =~ m/<source_filebranch_id>([^<]*)</ ;
   warn "--- out > $1 <---\n"
      if $out =~ m/<source_filebranch_id>([^<]*)</ ;

   $in =~ s{</rev_root>}{/foo</rev_root>} ;
   s_content  qw( rep_desc time user_id p4_info ), \$in, \$out ;
   s_content  qw( rev_root ),                      \$in, "depot/foo" ;
   #      rm_elts    qw( label ), qr/r_\w+|ch_\w+/,       \$in, \$out ;

   rm_elts    qw( branches ),                      \$in ;

   ## TODO: This is an incremental export and perforce does not give us
   ## a trivial way to figure out what branch a file is on (since
   ## multiple branch views can cover the same file), so we bail
   ## on that for now.
   rm_elts    qw( branch_id source_branch_id ),                     \$in ;

   $in =~ s{(id="|_id>)/+ignored}{$1//depot/foo}g;
   $in =~ s{(id="|_id>)ignored}{$1depot/foo}g;
   #$in =~ s{(<source_filebranch_id>)}{$1depot/foo}g;

   ok_or_diff $out, $in;
},

##-------------------------


##
## p4 -> revml, incremental export in bootstrap mode
##

sub {
      my $infile  = $t . "test-p4-in-1-bootstrap.revml" ;
      my $in  = slurp $infile ;
      my $out = get_vcp_output
         "${p4_spec}...\@$first_import_1_change,#head", "--bootstrap=**" ;

      $in =~ s{</rev_root>}{/foo</rev_root>} ;
      s_content  qw( rep_desc time user_id p4_info ), \$in, \$out ;
      s_content  qw( rev_root ),                      \$in, "depot/foo" ;
#      rm_elts    qw( label ), qr/r_\w+|ch_\w+/,       \$in, \$out ;

      $in =~ s{(id="|_id>)/+ignored}{$1//depot/foo}g;
      $in =~ s{(id="|_id>)ignored}{$1depot/foo}g;

      rm_elts    qw( branches ),                      \$in ;

      ## TODO: This is an incremental export and perforce does not give us
      ## a trivial way to figure out what branch a file is on (since
      ## multiple branch views can cover the same file), so we bail
      ## on that for now.
      rm_elts    qw( branch_id source_branch_id ),    \$in ;

      ok_or_diff $out, $in;
},

# shut down the p4root_1 p4d
sub {
   $p4_options->{p4d_handle}->kill_kill;
   ok 1;
},

) ;

plan tests => scalar @tests ;

my $p4d_borken = p4d_borken ;

my $why_skip ;
$why_skip .= "p4 command not found\n"  unless ( `p4 -V`  || 0 ) =~ /^Perforce/ ;
$why_skip .= "$p4d_borken\n"           if $p4d_borken ;

$why_skip ? skip( $why_skip, '' ) : $_->() for @tests ;