t/Makefile: ensure that paths are valid on platforms we care
[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 # Some operations require multiple attempts to be successful. Define
10 # here the maximal retry timeout in seconds.
11 RETRY_TIMEOUT=60
12
13 # Sometimes p4d seems to hang. Terminate the p4d process automatically after
14 # the defined timeout in seconds.
15 P4D_TIMEOUT=300
16
17 . ./test-lib.sh
18
19 if ! test_have_prereq PYTHON
20 then
21         skip_all='skipping git p4 tests; python not available'
22         test_done
23 fi
24 ( p4 -h && p4d -h ) >/dev/null 2>&1 || {
25         skip_all='skipping git p4 tests; no p4 or p4d'
26         test_done
27 }
28
29 # On cygwin, the NT version of Perforce can be used.  When giving
30 # it paths, either on the command-line or in client specifications,
31 # be sure to use the native windows form.
32 #
33 # Older versions of perforce were available compiled natively for
34 # cygwin.  Those do not accept native windows paths, so make sure
35 # not to convert for them.
36 native_path () {
37         path="$1" &&
38         if test_have_prereq CYGWIN && ! p4 -V | grep -q CYGWIN
39         then
40                 path=$(cygpath --windows "$path")
41         else
42                 path=$(test-path-utils real_path "$path")
43         fi &&
44         echo "$path"
45 }
46
47 # On Solaris the 'date +%s' function is not supported and therefore we
48 # need this replacement.
49 # Attention: This function is not safe again against time offset updates
50 # at runtime (e.g. via NTP). The 'clock_gettime(CLOCK_MONOTONIC)'
51 # function could fix that but it is not in Python until 3.3.
52 time_in_seconds () {
53         (cd / && "$PYTHON_PATH" -c 'import time; print(int(time.time()))')
54 }
55
56 # Try to pick a unique port: guess a large number, then hope
57 # no more than one of each test is running.
58 #
59 # This does not handle the case where somebody else is running the
60 # same tests and has chosen the same ports.
61 testid=${this_test#t}
62 git_p4_test_start=9800
63 P4DPORT=$((10669 + ($testid - $git_p4_test_start)))
64
65 P4PORT=localhost:$P4DPORT
66 P4CLIENT=client
67 P4USER=author
68 P4EDITOR=true
69 unset P4CHARSET
70 export P4PORT P4CLIENT P4USER P4EDITOR P4CHARSET
71
72 db="$TRASH_DIRECTORY/db"
73 cli="$TRASH_DIRECTORY/cli"
74 git="$TRASH_DIRECTORY/git"
75 pidfile="$TRASH_DIRECTORY/p4d.pid"
76
77 # Sometimes "prove" seems to hang on exit because p4d is still running
78 cleanup () {
79         if test -f "$pidfile"
80         then
81                 kill -9 $(cat "$pidfile") 2>/dev/null && exit 255
82         fi
83 }
84 trap cleanup EXIT
85
86 # git p4 submit generates a temp file, which will
87 # not get cleaned up if the submission fails.  Don't
88 # clutter up /tmp on the test machine.
89 TMPDIR="$TRASH_DIRECTORY"
90 export TMPDIR
91
92 start_p4d () {
93         mkdir -p "$db" "$cli" "$git" &&
94         rm -f "$pidfile" &&
95         (
96                 cd "$db" &&
97                 {
98                         p4d -q -p $P4DPORT "$@" &
99                         echo $! >"$pidfile"
100                 }
101         ) &&
102
103         # This gives p4d a long time to start up, as it can be
104         # quite slow depending on the machine.  Set this environment
105         # variable to something smaller to fail faster in, say,
106         # an automated test setup.  If the p4d process dies, that
107         # will be caught with the "kill -0" check below.
108         i=${P4D_START_PATIENCE:-300}
109         pid=$(cat "$pidfile")
110
111         timeout=$(($(time_in_seconds) + $P4D_TIMEOUT))
112         while true
113         do
114                 if test $(time_in_seconds) -gt $timeout
115                 then
116                         kill -9 $pid
117                         exit 1
118                 fi
119                 sleep 1
120         done &
121         watchdog_pid=$!
122
123         ready=
124         while test $i -gt 0
125         do
126                 # succeed when p4 client commands start to work
127                 if p4 info >/dev/null 2>&1
128                 then
129                         ready=true
130                         break
131                 fi
132                 # fail if p4d died
133                 kill -0 $pid 2>/dev/null || break
134                 echo waiting for p4d to start
135                 sleep 1
136                 i=$(( $i - 1 ))
137         done
138
139         if test -z "$ready"
140         then
141                 # p4d failed to start
142                 return 1
143         fi
144
145         # build a p4 user so author@example.com has an entry
146         p4_add_user author
147
148         # build a client
149         client_view "//depot/... //client/..." &&
150
151         return 0
152 }
153
154 p4_add_user () {
155         name=$1 &&
156         p4 user -f -i <<-EOF
157         User: $name
158         Email: $name@example.com
159         FullName: Dr. $name
160         EOF
161 }
162
163 p4_add_job () {
164         p4 job -f -i <<-EOF
165         Job: $1
166         Status: open
167         User: dummy
168         Description:
169         EOF
170 }
171
172 retry_until_success () {
173         timeout=$(($(time_in_seconds) + $RETRY_TIMEOUT))
174         until "$@" 2>/dev/null || test $(time_in_seconds) -gt $timeout
175         do
176                 sleep 1
177         done
178 }
179
180 retry_until_fail () {
181         timeout=$(($(time_in_seconds) + $RETRY_TIMEOUT))
182         until ! "$@" 2>/dev/null || test $(time_in_seconds) -gt $timeout
183         do
184                 sleep 1
185         done
186 }
187
188 kill_p4d () {
189         pid=$(cat "$pidfile")
190         retry_until_fail kill $pid
191         retry_until_fail kill -9 $pid
192         # complain if it would not die
193         test_must_fail kill $pid >/dev/null 2>&1 &&
194         rm -rf "$db" "$cli" "$pidfile" &&
195         retry_until_fail kill -9 $watchdog_pid
196 }
197
198 cleanup_git () {
199         retry_until_success rm -r "$git"
200         test_must_fail test -d "$git" &&
201         retry_until_success mkdir "$git"
202 }
203
204 marshal_dump () {
205         what=$1 &&
206         line=${2:-1} &&
207         cat >"$TRASH_DIRECTORY/marshal-dump.py" <<-EOF &&
208         import marshal
209         import sys
210         instream = getattr(sys.stdin, 'buffer', sys.stdin)
211         for i in range($line):
212             d = marshal.load(instream)
213         print(d[b'$what'].decode('utf-8'))
214         EOF
215         "$PYTHON_PATH" "$TRASH_DIRECTORY/marshal-dump.py"
216 }
217
218 #
219 # Construct a client with this list of View lines
220 #
221 client_view () {
222         (
223                 cat <<-EOF &&
224                 Client: $P4CLIENT
225                 Description: $P4CLIENT
226                 Root: $cli
227                 AltRoots: $(native_path "$cli")
228                 LineEnd: unix
229                 View:
230                 EOF
231                 printf "\t%s\n" "$@"
232         ) | p4 client -i
233 }
234
235 is_cli_file_writeable () {
236         # cygwin version of p4 does not set read-only attr,
237         # will be marked 444 but -w is true
238         file="$1" &&
239         if test_have_prereq CYGWIN && p4 -V | grep -q CYGWIN
240         then
241                 stat=$(stat --format=%a "$file") &&
242                 test $stat = 644
243         else
244                 test -w "$file"
245         fi
246 }