t/lib-git-p4.sh

   1 #
   2 # Library code for git p4 tests
   3 #
   4
   5 # p4 tests never use the top-level repo; always build/clone into
   6 # a subdirectory called "$git"
   7 TEST_NO_CREATE_REPO=NoThanks
   8
   9 . ./test-lib.sh
  10
  11 if ! test_have_prereq PYTHON; then
  12         skip_all='skipping git p4 tests; python not available'
  13         test_done
  14 fi
  15 ( p4 -h && p4d -h ) >/dev/null 2>&1 || {
  16         skip_all='skipping git p4 tests; no p4 or p4d'
  17         test_done
  18 }
  19
  20 # Try to pick a unique port: guess a large number, then hope
  21 # no more than one of each test is running.
  22 #
  23 # This does not handle the case where somebody else is running the
  24 # same tests and has chosen the same ports.
  25 testid=${this_test#t}
  26 git_p4_test_start=9800
  27 P4DPORT=$((10669 + ($testid - $git_p4_test_start)))
  28
  29 P4PORT=localhost:$P4DPORT
  30 P4CLIENT=client
  31 P4EDITOR=:
  32 export P4PORT P4CLIENT P4EDITOR
  33
  34 db="$TRASH_DIRECTORY/db"
  35 cli=$(test-path-utils real_path "$TRASH_DIRECTORY/cli")
  36 git="$TRASH_DIRECTORY/git"
  37 pidfile="$TRASH_DIRECTORY/p4d.pid"
  38
  39 start_p4d() {
  40         mkdir -p "$db" "$cli" "$git" &&
  41         rm -f "$pidfile" &&
  42         (
  43                 p4d -q -r "$db" -p $P4DPORT &
  44                 echo $! >"$pidfile"
  45         ) &&
  46
  47         # This gives p4d a long time to start up, as it can be
  48         # quite slow depending on the machine.  Set this environment
  49         # variable to something smaller to fail faster in, say,
  50         # an automated test setup.  If the p4d process dies, that
  51         # will be caught with the "kill -0" check below.
  52         i=${P4D_START_PATIENCE:-300}
  53         pid=$(cat "$pidfile")
  54         ready=
  55         while test $i -gt 0
  56         do
  57                 # succeed when p4 client commands start to work
  58                 if p4 info >/dev/null 2>&1
  59                 then
  60                         ready=true
  61                         break
  62                 fi
  63                 # fail if p4d died
  64                 kill -0 $pid 2>/dev/null || break
  65                 echo waiting for p4d to start
  66                 sleep 1
  67                 i=$(( $i - 1 ))
  68         done
  69
  70         if test -z "$ready"
  71         then
  72                 # p4d failed to start
  73                 return 1
  74         fi
  75
  76         # build a client
  77         (
  78                 cd "$cli" &&
  79                 p4 client -i <<-EOF
  80                 Client: client
  81                 Description: client
  82                 Root: $cli
  83                 View: //depot/... //client/...
  84                 EOF
  85         )
  86         return 0
  87 }
  88
  89 kill_p4d() {
  90         pid=$(cat "$pidfile")
  91         # it had better exist for the first kill
  92         kill $pid &&
  93         for i in 1 2 3 4 5 ; do
  94                 kill $pid >/dev/null 2>&1 || break
  95                 sleep 1
  96         done &&
  97         # complain if it would not die
  98         test_must_fail kill $pid >/dev/null 2>&1 &&
  99         rm -rf "$db" "$cli" "$pidfile"
 100 }
 101
 102 cleanup_git() {
 103         rm -rf "$git" &&
 104         mkdir "$git"
 105 }
 106
 107 marshal_dump() {
 108         what=$1 &&
 109         line=${2:-1} &&
 110         cat >"$TRASH_DIRECTORY/marshal-dump.py" <<-EOF &&
 111         import marshal
 112         import sys
 113         for i in range($line):
 114             d = marshal.load(sys.stdin)
 115         print d['$what']
 116         EOF
 117         "$PYTHON_PATH" "$TRASH_DIRECTORY/marshal-dump.py"
 118 }
 119
 120 #
 121 # Construct a client with this list of View lines
 122 #
 123 client_view() {
 124         (
 125                 cat <<-EOF &&
 126                 Client: client
 127                 Description: client
 128                 Root: $cli
 129                 View:
 130                 EOF
 131                 for arg ; do
 132                         printf "\t$arg\n"
 133                 done
 134         ) | p4 client -i
 135 }