summaryrefslogtreecommitdiff
path: root/tests/lib-build-modes
blob: dbceb42e8089eb28e2cb0810f39565d8d27e3c20 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
bm-prep-ownpackage-branches () {
	cat <<'END' >$tmp/stunt-git
#!/bin/sh -e
case "$*" in
*clean*) echo >&2 "BUILD-MODES PROGRAM git $*" ;;
esac
exec git "$@"
END
	chmod +x $tmp/stunt-git

	bm_branches="$1"
}

bm-prep () {
	t-tstunt-parsechangelog
	t-tstunt dpkg-deb

	t-prep-newpackage example 1.0

	cd $p

	git checkout -b bad-build-deps indep-arch
	perl -pe 's/Build-Depends.*/$&, x-dgit-no-such-package/' \
		-i debian/control
	git commit -a -m bad-build-deps

	bm-prep-ownpackage-branches 'indep-arch bad-build-deps'

	if zgrep 'dpkg-buildpackage: Make dependency checks fatal for -S' \
		/usr/share/doc/dpkg-dev/changelog.gz; then
			dpkgbuildpackage_deps_for_clean=true
	else
			dpkgbuildpackage_deps_for_clean=false
	fi

	cleanmodes_default="git none dpkg-source dpkg-source-d"
	cleanmodes_all="$cleanmodes_default git-ff check"
	cleanmodes="$cleanmodes_default"
}

bm-gbp-example-acts () {
	t-gbp-example-prep

	git checkout -b for-build-modes qc/quilt-tip-2
	# build-modes cannot cope with branches containing /

	bm-prep-ownpackage-branches for-build-modes

	cleanmodes='git dpkg-source'

	for act in "$@"; do
		bm-guess-e-source-e-targets "$act"
		real_act="--quilt=gbp $act"
		case "$act" in
		sbuild*)    bm_quirk_after_act=bm-quirk-sbuild-after-act ;;
		gbp-*)	    real_act="$real_act --git-ignore-branch" ;;
		*)	    bm_quirk_after_act='' ;;
		esac
		bm-act-iterate
	done
}

bm-guess-e-source-e-targets () {
	local some_act=$1
	case "$some_act" in
	sbuild*" --no-arch-all"*)
		e_source=true;	e_targets='build-arch binary-arch'	;;
	build-source)
		e_source=true;	e_targets=''				;;
	*" -b")	e_source=false;	e_targets='build binary'		;;
	*" -B")	e_source=false;	e_targets='build-arch binary-arch'	;;
	*" -A")	e_source=false;	e_targets='build-indep binary-indep'	;;
	*" -S")	e_source=true;	e_targets=' '				;;
	*" -F")	e_source=true;	e_targets='build binary'		;;
	*" -G")	e_source=true;	e_targets='build-arch binary-arch'	;;
	*" -g")	e_source=true;	e_targets='build-indep binary-indep'	;;
	*)	e_source=true;	e_targets='build binary'		;;
	esac
}

bm-quirk-sbuild-after-act () {
	# sbuild likes to run the package clean target in the chroot,
	# which isn't necessary in our case.  We don't disable it in
	# dgit because we want to do what sbuild does, in case there
	# are packages which don't build unless their clean target was
	# run.  We know it must be running it in the chroot because we
	# provide sbuild with the dsc, not the tree, so we simply
	# ignore all executions of the clean target by schroot.
	local arch; arch=$(dpkg-architecture -qDEB_BUILD_ARCH)
	local sblog=$bpd/example_${v}_$arch.build
	if [ -e $sblog ]; then
		sed '
			s/^EXAMPLE RULES TARGET clean/HOOK SUPPRESSED &/;
		' <$sblog >>$bmlog
	else
		echo "SBUILD LOG FILE ($sblog) MISSING"
	fi
}

bm-report-test () {
	local desc=$1; shift
	if "$@"; then
		echo >&4 "$desc EXISTS"
	else
		echo >&4 "$desc MISSING"
	fi
}

bm-build-deps-ok () {
	case "$branch" in
	*bad-build-deps*)	return 1	;;
	*)			return 0	;;
	esac
}

bm-compute-expected () {
	require_fail=unexpect # or required
	tolerate_fail=unexpect # or tolerate

	exec 4>$bmexp
	echo >&4 "$heading"

	local eff_cleanmode=$cleanmode

	case "$e_targets" in
	*[^\ ]*)
		;;
	*)
		# dgit won't bother cleaning the tree
		# if no build is going to be run
		eff_cleanmode=none
		;;
	esac

	case "$act" in
	sbuild*)
		# dgit sbuild won't bother cleaning the tree
		# because it doesn't need to to make a .dsc for sbuild
		eff_cleanmode=none
		;;
	esac

	# we are running the builder in-tree ?
	# when we have --include-dirty, we will want to check
	# that too and reset eff_cleanmode to $cleanmode

	case $eff_cleanmode in
	git)		echo >&4 'BUILD-MODES PROGRAM git clean -xdf' ;;
	git-ff)		echo >&4 'BUILD-MODES PROGRAM git clean -xdff' ;;
	check)		echo >&4 'BUILD-MODES PROGRAM git clean -xdn' ;;
	dpkg-source-d)	echo >&4 "EXAMPLE RULES TARGET clean" ;;
	dpkg-source)	bm-build-deps-ok || tolerate_fail=tolerate
			echo >&4 "EXAMPLE RULES TARGET clean"
			;;
	none)		;;
	*)		fail "t-compute-expected-run $cleanmode ??" ;;
	esac

	if [ "x$e_targets" != x ]; then
		# e_targets can be " " to mean `/may/ fail due to b-d'
		bm-build-deps-ok || tolerate_fail=tolerate
	fi

	for t in $e_targets; do
		bm-build-deps-ok || require_fail=required
		echo >&4 "EXAMPLE RULES TARGET $t"
	done

	bm-report-test "SOURCE FILE" $e_source
	bm-report-test "SOURCE IN CHANGES" $e_source
	bm-report-test "DEBS IN CHANGES" expr "$e_targets" : '.*binary.*'

	exec 4>&-
}

bm-run-one () {
	local args="$DGIT_TEST_BM_BASEARGS --clean=$cleanmode $real_act"

	bmid="$act,$cleanmode,$branch"
	bmid=${bmid// /_}

	rm -f $bpd/${p}_{v}_*.changes

	heading="===== [$bmid] dgit $args ====="

	bmlog=$tmp/run.$bmid.output
	bmexp=$tmp/run.$bmid.expected
	bmgot=$tmp/run.$bmid.results

	bm-compute-expected

	git checkout $branch
	git clean -xdf # since we might not do any actual cleaning

	dsc="$bpd/example_$v.dsc"
	rm -f $dsc

	set +o pipefail
	t-dgit --rm-old-changes --git=$tmp/stunt-git $args 2>&1 | tee $bmlog
	local ps="${PIPESTATUS[*]}"
	set -o pipefail

	$bm_quirk_after_act

	exec 4>$bmgot
	echo >&4 "$heading"

	case $ps in
	"0 0")	actual_status=success ;;
	*" 0")	actual_status=failure; echo >&4 "OPERATION FAILED"; ;;
	*)	fail "tee failed" ;;
	esac

	case "$require_fail-$tolerate_fail-$actual_status" in
	required-********-failure) echo >>$bmexp "REQUIRED FAILURE" ;;
	********-tolerate-failure) echo >>$bmexp "TOLERATED FAILURE" ;;
	unexpect-********-success) ;;
	*)	fail "RF=$require_fail TF=$tolerate_fail AS=$actual_status" ;;
	esac

	egrep >&4 '^EXAMPLE RULES TARGET|^BUILD-MODES' $bmlog || [ $? = 1 ]

	bm-report-test "SOURCE FILE" [ -e $dsc ]

	if [ $actual_status = success ]; then
		local changes; changes=$(echo $bpd/example_${v}_*.changes)
		case "$changes" in
		*' '*)	fail "build generated ambiguous .changes: $changes" ;;
		esac

		perl -ne 'print if m/^files:/i ... m/^\S/' \
			<$changes >$changes.files

		bm-report-test "SOURCE IN CHANGES" grep '\.dsc$' $changes.files
		bm-report-test "DEBS IN CHANGES" grep '\.deb$' $changes.files
	fi

	exec 4>&-

	$bm_quirk_before_diff

	[ $actual_status = failure ] || diff -U10 $bmexp $bmgot
}

bm-act-iterate () {
	for cleanmode in $cleanmodes; do
		for branch in $bm_branches; do
			bm-run-one
		done
	done
	: bm-act-iterate done.
}

bm-buildproductsdir-nonworking () {
	t-git-config dgit.default.build-products-dir ../bpd-dummy
}