Merge branch 'mh/fetch-filter-refs'
[git] / 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 }