1 ;;; GNU Guix --- Functional package management for GNU
2 ;;; Copyright © 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
4 ;;; This file is part of GNU Guix.
6 ;;; GNU Guix is free software; you can redistribute it and/or modify it
7 ;;; under the terms of the GNU General Public License as published by
8 ;;; the Free Software Foundation; either version 3 of the License, or (at
9 ;;; your option) any later version.
11 ;;; GNU Guix is distributed in the hope that it will be useful, but
12 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
13 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 ;;; GNU General Public License for more details.
16 ;;; You should have received a copy of the GNU General Public License
17 ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
19 (unsetenv "http_proxy")
21 (define-module (test-derivations)
22 #:use-module (guix derivations)
23 #:use-module (guix grafts)
24 #:use-module (guix store)
25 #:use-module (guix utils)
26 #:use-module (gcrypt hash)
27 #:use-module (guix base32)
28 #:use-module (guix tests)
29 #:use-module (guix tests http)
30 #:use-module ((guix packages) #:select (package-derivation base32))
31 #:use-module ((guix build utils) #:select (executable-file?))
32 #:use-module ((gnu packages) #:select (search-bootstrap-binary))
33 #:use-module (gnu packages bootstrap)
34 #:use-module ((gnu packages guile) #:select (guile-1.8))
35 #:use-module (srfi srfi-1)
36 #:use-module (srfi srfi-11)
37 #:use-module (srfi srfi-26)
38 #:use-module (srfi srfi-34)
39 #:use-module (srfi srfi-64)
40 #:use-module (rnrs io ports)
41 #:use-module (rnrs bytevectors)
42 #:use-module (web uri)
43 #:use-module (ice-9 rdelim)
44 #:use-module (ice-9 regex)
45 #:use-module (ice-9 ftw)
46 #:use-module (ice-9 match))
49 (open-connection-for-tests))
51 ;; Globally disable grafts because they can trigger early builds.
54 (define (bootstrap-binary name)
55 (let ((bin (search-bootstrap-binary name (%current-system))))
57 (add-to-store %store name #t "sha256" bin))))
60 (bootstrap-binary "bash"))
62 (bootstrap-binary "mkdir"))
64 (define* (directory-contents dir #:optional (slurp get-bytevector-all))
65 "Return an alist representing the contents of DIR."
66 (define prefix-len (string-length dir))
67 (sort (file-system-fold (const #t) ; enter?
68 (lambda (path stat result) ; leaf
69 (alist-cons (string-drop path prefix-len)
70 (call-with-input-file path slurp)
72 (lambda (path stat result) result) ; down
73 (lambda (path stat result) result) ; up
74 (lambda (path stat result) result) ; skip
75 (lambda (path stat errno result) result) ; error
79 (string<? (car e1) (car e2)))))
81 ;; Avoid collisions with other tests.
82 (%http-server-port 10500)
85 (test-begin "derivations")
87 (test-assert "parse & export"
88 (let* ((f (search-path %load-path "tests/test.drv"))
89 (b1 (call-with-input-file f get-bytevector-all))
90 (d1 (read-derivation (open-bytevector-input-port b1)))
91 (b2 (call-with-bytevector-output-port (cut write-derivation d1 <>)))
92 (d2 (read-derivation (open-bytevector-input-port b2))))
96 (test-skip (if %store 0 12))
98 (test-assert "add-to-store, flat"
99 ;; Use 'readlink*' in case spec.scm is a symlink, as is the case when Guile
100 ;; was installed with Stow.
101 (let* ((file (readlink*
102 (search-path %load-path "language/tree-il/spec.scm")))
103 (drv (add-to-store %store "flat-test" #f "sha256" file)))
104 (and (eq? 'regular (stat:type (stat drv)))
105 (valid-path? %store drv)
106 (equal? (call-with-input-file file get-bytevector-all)
107 (call-with-input-file drv get-bytevector-all)))))
109 (test-assert "add-to-store, recursive"
111 (readlink* (search-path %load-path
112 "language/tree-il/spec.scm"))))
113 (drv (add-to-store %store "dir-tree-test" #t "sha256" dir)))
114 (and (eq? 'directory (stat:type (stat drv)))
115 (valid-path? %store drv)
116 (equal? (directory-contents dir)
117 (directory-contents drv)))))
119 (test-assert "derivation with no inputs"
120 (let* ((builder (add-text-to-store %store "my-builder.sh"
121 "echo hello, world\n"
123 (drv (derivation %store "foo"
124 %bash `("-e" ,builder)
125 #:env-vars '(("HOME" . "/homeless")))))
126 (and (store-path? (derivation-file-name drv))
127 (valid-path? %store (derivation-file-name drv)))))
129 (test-assert "build derivation with 1 source"
130 (let* ((builder (add-text-to-store %store "my-builder.sh"
131 "echo hello, world > \"$out\"\n"
133 (drv (derivation %store "foo"
135 #:env-vars '(("HOME" . "/homeless")
138 #:inputs `((,%bash) (,builder))))
140 (build-derivations %store (list drv))))
142 (let ((path (derivation->output-path drv)))
143 (and (valid-path? %store path)
144 (string=? (call-with-input-file path read-line)
147 (test-assert "derivation with local file as input"
148 (let* ((builder (add-text-to-store
149 %store "my-builder.sh"
150 "(while read line ; do echo \"$line\" ; done) < $in > $out"
152 (input (search-path %load-path "ice-9/boot-9.scm"))
153 (input* (add-to-store %store (basename input)
155 (drv (derivation %store "derivation-with-input-file"
158 ;; Cheat to pass the actual file name to the
160 #:env-vars `(("in" . ,input*))
164 (,input))))) ; ← local file name
165 (and (build-derivations %store (list drv))
166 ;; Note: we can't compare the files because the above trick alters
168 (valid-path? %store (derivation->output-path drv)))))
170 (test-assert "derivation fails but keep going"
171 ;; In keep-going mode, 'build-derivations' should fail because of D1, but it
172 ;; must return only after D2 has succeeded.
174 (let* ((d1 (derivation %store "fails"
175 %bash `("-c" "false")
176 #:inputs `((,%bash))))
177 (d2 (build-expression->derivation %store "sleep-then-succeed"
180 ;; XXX: Hopefully that's long
181 ;; enough that D1 has already
185 (set-build-options %store
186 #:use-substitutes? #f
188 (guard (c ((store-protocol-error? c)
189 (and (= 100 (store-protocol-error-status c))
190 (string-contains (store-protocol-error-message c)
191 (derivation-file-name d1))
192 (not (valid-path? %store (derivation->output-path d1)))
193 (valid-path? %store (derivation->output-path d2)))))
194 (build-derivations %store (list d1 d2))
197 (test-assert "identical files are deduplicated"
198 (let* ((build1 (add-text-to-store %store "one.sh"
199 "echo hello, world > \"$out\"\n"
201 (build2 (add-text-to-store %store "two.sh"
202 "# Hey!\necho hello, world > \"$out\"\n"
204 (drv1 (derivation %store "foo"
206 #:inputs `((,%bash) (,build1))))
207 (drv2 (derivation %store "bar"
209 #:inputs `((,%bash) (,build2)))))
210 (and (build-derivations %store (list drv1 drv2))
211 (let ((file1 (derivation->output-path drv1))
212 (file2 (derivation->output-path drv2)))
213 (and (valid-path? %store file1) (valid-path? %store file2)
214 (string=? (call-with-input-file file1 get-string-all)
216 (= (stat:ino (lstat file1))
217 (stat:ino (lstat file2))))))))
219 (test-equal "built-in-builders"
221 (built-in-builders %store))
223 (test-assert "unknown built-in builder"
224 (let ((drv (derivation %store "ohoh" "builtin:does-not-exist" '())))
225 (guard (c ((store-protocol-error? c)
226 (string-contains (store-protocol-error-message c) "failed")))
227 (build-derivations %store (list drv))
230 (unless (http-server-can-listen?)
232 (test-assert "'download' built-in builder"
233 (let ((text (random-text)))
234 (with-http-server 200 text
235 (let* ((drv (derivation %store "world"
236 "builtin:download" '()
238 . ,(object->string (%local-url))))
240 #:hash (sha256 (string->utf8 text)))))
241 (and (build-derivations %store (list drv))
242 (string=? (call-with-input-file (derivation->output-path drv)
246 (unless (http-server-can-listen?)
248 (test-assert "'download' built-in builder, invalid hash"
249 (with-http-server 200 "hello, world!"
250 (let* ((drv (derivation %store "world"
251 "builtin:download" '()
253 . ,(object->string (%local-url))))
255 #:hash (sha256 (random-bytevector 100))))) ;wrong
256 (guard (c ((store-protocol-error? c)
257 (string-contains (store-protocol-error-message c) "failed")))
258 (build-derivations %store (list drv))
261 (unless (http-server-can-listen?)
263 (test-assert "'download' built-in builder, not found"
264 (with-http-server 404 "not found"
265 (let* ((drv (derivation %store "will-never-be-found"
266 "builtin:download" '()
268 . ,(object->string (%local-url))))
270 #:hash (sha256 (random-bytevector 100)))))
271 (guard (c ((store-protocol-error? c)
272 (string-contains (store-protocol-error-message (pk c)) "failed")))
273 (build-derivations %store (list drv))
276 (test-assert "'download' built-in builder, not fixed-output"
277 (let* ((source (add-text-to-store %store "hello" "hi!"))
278 (url (string-append "file://" source))
279 (drv (derivation %store "world"
280 "builtin:download" '()
281 #:env-vars `(("url" . ,(object->string url))))))
282 (guard (c ((store-protocol-error? c)
283 (string-contains (store-protocol-error-message c) "failed")))
284 (build-derivations %store (list drv))
287 (unless (http-server-can-listen?)
289 (test-assert "'download' built-in builder, check mode"
290 ;; Make sure rebuilding the 'builtin:download' derivation in check mode
291 ;; works. See <http://bugs.gnu.org/25089>.
292 (let* ((text (random-text))
293 (drv (derivation %store "world"
294 "builtin:download" '()
296 . ,(object->string (%local-url))))
298 #:hash (sha256 (string->utf8 text)))))
299 (and (with-http-server 200 text
300 (build-derivations %store (list drv)))
301 (with-http-server 200 text
302 (build-derivations %store (list drv)
304 (string=? (call-with-input-file (derivation->output-path drv)
308 (test-equal "derivation-name"
310 (let ((drv (derivation %store "foo-0.0" %bash '())))
311 (derivation-name drv)))
313 (test-equal "derivation-output-names"
314 '(("out") ("bar" "chbouib"))
315 (let ((drv1 (derivation %store "foo-0.0" %bash '()))
316 (drv2 (derivation %store "foo-0.0" %bash '()
317 #:outputs '("bar" "chbouib"))))
318 (list (derivation-output-names drv1)
319 (derivation-output-names drv2))))
321 (test-assert "offloadable-derivation?"
322 (and (offloadable-derivation? (derivation %store "foo" %bash '()))
323 (offloadable-derivation? ;see <http://bugs.gnu.org/18747>
324 (derivation %store "foo" %bash '()
325 #:substitutable? #f))
326 (not (offloadable-derivation?
327 (derivation %store "foo" %bash '()
328 #:local-build? #t)))))
330 (test-assert "substitutable-derivation?"
331 (and (substitutable-derivation? (derivation %store "foo" %bash '()))
332 (substitutable-derivation? ;see <http://bugs.gnu.org/18747>
333 (derivation %store "foo" %bash '()
335 (not (substitutable-derivation?
336 (derivation %store "foo" %bash '()
337 #:substitutable? #f)))))
339 (test-assert "fixed-output-derivation?"
340 (let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
341 "echo -n hello > $out" '()))
342 (hash (sha256 (string->utf8 "hello")))
343 (drv (derivation %store "fixed"
345 #:inputs `((,builder))
346 #:hash hash #:hash-algo 'sha256)))
347 (fixed-output-derivation? drv)))
349 (test-assert "fixed-output derivation"
350 (let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
351 "echo -n hello > $out" '()))
352 (hash (sha256 (string->utf8 "hello")))
353 (drv (derivation %store "fixed"
355 #:inputs `((,builder)) ; optional
356 #:hash hash #:hash-algo 'sha256))
357 (succeeded? (build-derivations %store (list drv))))
359 (let ((p (derivation->output-path drv)))
360 (and (equal? (string->utf8 "hello")
361 (call-with-input-file p get-bytevector-all))
362 (bytevector? (query-path-hash %store p)))))))
364 (test-assert "fixed-output derivation: output paths are equal"
365 (let* ((builder1 (add-text-to-store %store "fixed-builder1.sh"
366 "echo -n hello > $out" '()))
367 (builder2 (add-text-to-store %store "fixed-builder2.sh"
368 "echo hey; echo -n hello > $out" '()))
369 (hash (sha256 (string->utf8 "hello")))
370 (drv1 (derivation %store "fixed"
372 #:hash hash #:hash-algo 'sha256))
373 (drv2 (derivation %store "fixed"
375 #:hash hash #:hash-algo 'sha256))
376 (succeeded? (build-derivations %store (list drv1 drv2))))
378 (equal? (derivation->output-path drv1)
379 (derivation->output-path drv2)))))
381 (test-assert "fixed-output derivation, recursive"
382 (let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
383 "echo -n hello > $out" '()))
384 (hash (sha256 (string->utf8 "hello")))
385 (drv (derivation %store "fixed-rec"
387 #:inputs `((,builder))
388 #:hash (base32 "0sg9f58l1jj88w6pdrfdpj5x9b1zrwszk84j81zvby36q9whhhqa")
391 (succeeded? (build-derivations %store (list drv))))
393 (let ((p (derivation->output-path drv)))
394 (and (equal? (string->utf8 "hello")
395 (call-with-input-file p get-bytevector-all))
396 (bytevector? (query-path-hash %store p)))))))
398 (test-assert "derivation with a fixed-output input"
399 ;; A derivation D using a fixed-output derivation F doesn't has the same
400 ;; output path when passed F or F', as long as F and F' have the same output
402 (let* ((builder1 (add-text-to-store %store "fixed-builder1.sh"
403 "echo -n hello > $out" '()))
404 (builder2 (add-text-to-store %store "fixed-builder2.sh"
405 "echo hey; echo -n hello > $out" '()))
406 (hash (sha256 (string->utf8 "hello")))
407 (fixed1 (derivation %store "fixed"
409 #:hash hash #:hash-algo 'sha256))
410 (fixed2 (derivation %store "fixed"
412 #:hash hash #:hash-algo 'sha256))
413 (fixed-out (derivation->output-path fixed1))
414 (builder3 (add-text-to-store
415 %store "final-builder.sh"
416 ;; Use Bash hackery to avoid Coreutils.
417 "echo $in ; (read -u 3 c; echo $c) 3< $in > $out" '()))
418 (final1 (derivation %store "final"
420 #:env-vars `(("in" . ,fixed-out))
421 #:inputs `((,%bash) (,builder3) (,fixed1))))
422 (final2 (derivation %store "final"
424 #:env-vars `(("in" . ,fixed-out))
425 #:inputs `((,%bash) (,builder3) (,fixed2))))
426 (succeeded? (build-derivations %store
427 (list final1 final2))))
429 (equal? (derivation->output-path final1)
430 (derivation->output-path final2)))))
432 (test-assert "multiple-output derivation"
433 (let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
434 "echo one > $out ; echo two > $second"
436 (drv (derivation %store "fixed"
438 #:env-vars '(("HOME" . "/homeless")
441 #:inputs `((,%bash) (,builder))
442 #:outputs '("out" "second")))
443 (succeeded? (build-derivations %store (list drv))))
445 (let ((one (derivation->output-path drv "out"))
446 (two (derivation->output-path drv "second")))
448 (derivation->output-paths drv)
449 `(("out" . ,one) ("second" . ,two)))
450 (eq? 'one (call-with-input-file one read))
451 (eq? 'two (call-with-input-file two read)))))))
453 (test-assert "multiple-output derivation, non-alphabetic order"
454 ;; Here, the outputs are not listed in alphabetic order. Yet, the store
455 ;; path computation must reorder them first.
456 (let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
457 "echo one > $out ; echo two > $AAA"
459 (drv (derivation %store "fixed"
461 #:inputs `((,%bash) (,builder))
462 #:outputs '("out" "AAA")))
463 (succeeded? (build-derivations %store (list drv))))
465 (let ((one (derivation->output-path drv "out"))
466 (two (derivation->output-path drv "AAA")))
467 (and (eq? 'one (call-with-input-file one read))
468 (eq? 'two (call-with-input-file two read)))))))
470 (test-assert "read-derivation vs. derivation"
471 ;; Make sure 'derivation' and 'read-derivation' return objects that are
473 (let* ((sources (unfold (cut >= <> 10)
475 (add-text-to-store %store
476 (format #f "input~a" n)
480 (inputs (map (lambda (file)
481 (derivation %store "derivation-input"
483 #:inputs `((,%bash) (,file))))
485 (builder (add-text-to-store %store "builder.sh"
486 "echo one > $one ; echo two > $two"
488 (drv (derivation %store "derivation"
490 #:inputs `((,%bash) (,builder)
491 ,@(map list (append sources inputs)))
492 #:outputs '("two" "one")))
493 (drv* (call-with-input-file (derivation-file-name drv)
497 (test-assert "multiple-output derivation, derivation-path->output-path"
498 (let* ((builder (add-text-to-store %store "builder.sh"
499 "echo one > $out ; echo two > $second"
501 (drv (derivation %store "multiple"
503 #:outputs '("out" "second")))
504 (drv-file (derivation-file-name drv))
505 (one (derivation->output-path drv "out"))
506 (two (derivation->output-path drv "second"))
507 (first (derivation-path->output-path drv-file "out"))
508 (second (derivation-path->output-path drv-file "second")))
509 (and (not (string=? one two))
510 (string-suffix? "-second" two)
512 (string=? second two))))
514 (test-assert "user of multiple-output derivation"
515 ;; Check whether specifying several inputs coming from the same
516 ;; multiple-output derivation works.
517 (let* ((builder1 (add-text-to-store %store "my-mo-builder.sh"
518 "echo one > $out ; echo two > $two"
520 (mdrv (derivation %store "multiple-output"
522 #:inputs `((,%bash) (,builder1))
523 #:outputs '("out" "two")))
524 (builder2 (add-text-to-store %store "my-mo-user-builder.sh"
527 echo \"($x $y)\" > $out"
529 (udrv (derivation %store "multiple-output-user"
532 . ,(derivation->output-path
535 . ,(derivation->output-path
539 ;; two occurrences of MDRV:
542 (and (build-derivations %store (list (pk 'udrv udrv)))
543 (let ((p (derivation->output-path udrv)))
544 (and (valid-path? %store p)
545 (equal? '(one two) (call-with-input-file p read)))))))
547 (test-assert "derivation with #:references-graphs"
548 (let* ((input1 (add-text-to-store %store "foo" "hello"
550 (input2 (add-text-to-store %store "bar"
551 (number->string (random 7777))
553 (builder (add-text-to-store %store "build-graph"
556 (while read l ; do echo $l ; done) < bash > $out/bash
557 (while read l ; do echo $l ; done) < input1 > $out/input1
558 (while read l ; do echo $l ; done) < input2 > $out/input2"
561 (drv (derivation %store "closure-graphs"
566 ("input2" . ,input2))
567 #:inputs `((,%bash) (,builder))))
568 (out (derivation->output-path drv)))
569 (define (deps path . deps)
570 (let ((count (length deps)))
571 (string-append path "\n\n" (number->string count) "\n"
572 (string-join (sort deps string<?) "\n")
573 (if (zero? count) "" "\n"))))
575 (and (build-derivations %store (list drv))
576 (equal? (directory-contents out get-string-all)
577 `(("/bash" . ,(string-append %bash "\n\n0\n"))
578 ("/input1" . ,(if (string>? input1 %bash)
579 (string-append (deps %bash)
581 (string-append (deps input1 %bash)
583 ("/input2" . ,(string-concatenate
587 (cons p (apply deps p d)))
588 (list %bash input1 input2)
589 (list '() (list %bash) (list input1)))
595 (string<? p1 p2)))))))))))))))
597 (test-assert "derivation #:allowed-references, ok"
598 (let ((drv (derivation %store "allowed" %bash
599 '("-c" "echo hello > $out")
601 #:allowed-references '())))
602 (build-derivations %store (list drv))))
604 (test-assert "derivation #:allowed-references, not allowed"
605 (let* ((txt (add-text-to-store %store "foo" "Hello, world."))
606 (drv (derivation %store "disallowed" %bash
607 `("-c" ,(string-append "echo " txt "> $out"))
608 #:inputs `((,%bash) (,txt))
609 #:allowed-references '())))
610 (guard (c ((store-protocol-error? c)
611 ;; There's no specific error message to check for.
613 (build-derivations %store (list drv))
616 (test-assert "derivation #:allowed-references, self allowed"
617 (let ((drv (derivation %store "allowed" %bash
618 '("-c" "echo $out > $out")
620 #:allowed-references '("out"))))
621 (build-derivations %store (list drv))))
623 (test-assert "derivation #:allowed-references, self not allowed"
624 (let ((drv (derivation %store "disallowed" %bash
625 `("-c" ,"echo $out > $out")
627 #:allowed-references '())))
628 (guard (c ((store-protocol-error? c)
629 ;; There's no specific error message to check for.
631 (build-derivations %store (list drv))
634 (test-assert "derivation #:disallowed-references, ok"
635 (let ((drv (derivation %store "disallowed" %bash
636 '("-c" "echo hello > $out")
638 #:disallowed-references '("out"))))
639 (build-derivations %store (list drv))))
641 (test-assert "derivation #:disallowed-references, not ok"
642 (let* ((txt (add-text-to-store %store "foo" "Hello, world."))
643 (drv (derivation %store "disdisallowed" %bash
644 `("-c" ,(string-append "echo " txt "> $out"))
645 #:inputs `((,%bash) (,txt))
646 #:disallowed-references (list txt))))
647 (guard (c ((store-protocol-error? c)
648 ;; There's no specific error message to check for.
650 (build-derivations %store (list drv))
653 ;; Here we should get the value of $GUIX_STATE_DIRECTORY that the daemon sees,
654 ;; which is a unique value for each test process; this value is the same as
655 ;; the one we see in the process executing this file since it is set by
657 (test-equal "derivation #:leaked-env-vars"
658 (getenv "GUIX_STATE_DIRECTORY")
659 (let* ((value (getenv "GUIX_STATE_DIRECTORY"))
660 (drv (derivation %store "leaked-env-vars" %bash
661 '("-c" "echo -n $GUIX_STATE_DIRECTORY > $out")
662 #:hash (sha256 (string->utf8 value))
665 #:leaked-env-vars '("GUIX_STATE_DIRECTORY"))))
666 (and (build-derivations %store (list drv))
667 (call-with-input-file (derivation->output-path drv)
673 (and (network-reachable?)
674 (package-derivation %store %bootstrap-coreutils&co))))
676 (test-skip (if %coreutils 0 1))
678 (test-assert "build derivation with coreutils"
680 (add-text-to-store %store "build-with-coreutils.sh"
681 "echo $PATH ; mkdir --version ; mkdir $out ; touch $out/good"
684 (derivation %store "foo"
686 #:env-vars `(("PATH" .
688 (derivation->output-path %coreutils)
690 #:inputs `((,builder)
693 (build-derivations %store (list drv))))
695 (let ((p (derivation->output-path drv)))
696 (and (valid-path? %store p)
697 (file-exists? (string-append p "/good")))))))
699 (test-skip (if (%guile-for-build) 0 8))
701 (test-equal "build-expression->derivation and invalid module name"
702 '(file-search-error "guix/module/that/does/not/exist.scm")
703 (guard (c ((file-search-error? c)
704 (list 'file-search-error
705 (file-search-error-file-name c))))
706 (build-expression->derivation %store "foo" #t
707 #:modules '((guix module that
710 (test-equal "build-expression->derivation and builder encoding"
712 (let* ((exp '(λ (α) (+ α 1)))
713 (drv (build-expression->derivation %store "foo" exp)))
714 (match (derivation-builder-arguments drv)
716 (with-fluids ((%default-port-encoding "UTF-8"))
717 (call-with-input-file builder
719 (list (port-encoding port)
721 (string-contains (get-string-all port)
722 "(λ (α) (+ α 1))"))))))))))
724 (test-assert "build-expression->derivation and derivation-prerequisites"
725 (let ((drv (build-expression->derivation %store "fail" #f)))
727 (($ <derivation-input> path)
728 (string=? path (derivation-file-name (%guile-for-build)))))
729 (derivation-prerequisites drv))))
731 (test-assert "derivation-prerequisites and valid-derivation-input?"
732 (let* ((a (build-expression->derivation %store "a" '(mkdir %output)))
733 (b (build-expression->derivation %store "b" `(list ,(random-text))))
734 (c (build-expression->derivation %store "c" `(mkdir %output)
735 #:inputs `(("a" ,a) ("b" ,b)))))
736 ;; Make sure both A and %BOOTSTRAP-GUILE are built (the latter could have
737 ;; be removed by tests/guix-gc.sh.)
738 (build-derivations %store
739 (list a (package-derivation %store %bootstrap-guile)))
741 (match (derivation-prerequisites c
742 (cut valid-derivation-input? %store
744 ((($ <derivation-input> file ("out")))
745 (string=? file (derivation-file-name b)))
749 (test-assert "build-expression->derivation without inputs"
750 (let* ((builder '(begin
752 (call-with-output-file (string-append %output "/test")
754 (display '(hello guix) p)))))
755 (drv (build-expression->derivation %store "goo" builder))
756 (succeeded? (build-derivations %store (list drv))))
758 (let ((p (derivation->output-path drv)))
759 (equal? '(hello guix)
760 (call-with-input-file (string-append p "/test") read))))))
762 (test-assert "build-expression->derivation and max-silent-time"
763 (let* ((store (let ((s (open-connection)))
764 (set-build-options s #:max-silent-time 1)
766 (builder '(begin (sleep 100) (mkdir %output) #t))
767 (drv (build-expression->derivation store "silent" builder))
768 (out-path (derivation->output-path drv)))
769 (guard (c ((store-protocol-error? c)
770 (and (string-contains (store-protocol-error-message c)
772 (not (valid-path? store out-path)))))
773 (build-derivations store (list drv))
776 (test-assert "build-expression->derivation and timeout"
777 (let* ((store (let ((s (open-connection)))
778 (set-build-options s #:timeout 1)
780 (builder '(begin (sleep 100) (mkdir %output) #t))
781 (drv (build-expression->derivation store "slow" builder))
782 (out-path (derivation->output-path drv)))
783 (guard (c ((store-protocol-error? c)
784 (and (string-contains (store-protocol-error-message c)
786 (not (valid-path? store out-path)))))
787 (build-derivations store (list drv))
790 (test-assert "build-expression->derivation and derivation-prerequisites-to-build"
791 (let ((drv (build-expression->derivation %store "fail" #f)))
792 ;; The only direct dependency is (%guile-for-build) and it's already
794 (null? (derivation-prerequisites-to-build %store drv))))
796 (test-assert "derivation-prerequisites-to-build when outputs already present"
797 (let* ((builder '(begin (mkdir %output) #t))
798 (input-drv (build-expression->derivation %store "input" builder))
799 (input-path (derivation-output-path
800 (assoc-ref (derivation-outputs input-drv)
802 (drv (build-expression->derivation %store "something" builder
804 `(("i" ,input-drv))))
805 (output (derivation->output-path drv)))
806 ;; Make sure these things are not already built.
807 (when (valid-path? %store input-path)
808 (delete-paths %store (list input-path)))
809 (when (valid-path? %store output)
810 (delete-paths %store (list output)))
812 (and (equal? (map derivation-input-path
813 (derivation-prerequisites-to-build %store drv))
814 (list (derivation-file-name input-drv)))
816 ;; Build DRV and delete its input.
817 (build-derivations %store (list drv))
818 (delete-paths %store (list input-path))
819 (not (valid-path? %store input-path))
821 ;; Now INPUT-PATH is missing, yet it shouldn't be listed as a
822 ;; prerequisite to build because DRV itself is already built.
823 (null? (derivation-prerequisites-to-build %store drv)))))
825 (test-assert "derivation-prerequisites-to-build and substitutes"
826 (let* ((store (open-connection))
827 (drv (build-expression->derivation store "prereq-subst"
829 (output (derivation->output-path drv)))
831 ;; Make sure substitutes are usable.
832 (set-build-options store #:use-substitutes? #t
833 #:substitute-urls (%test-substitute-urls))
835 (with-derivation-narinfo drv
836 (let-values (((build download)
837 (derivation-prerequisites-to-build store drv))
839 (derivation-prerequisites-to-build store drv
843 (equal? (map substitutable-path download) (list output))
847 (test-assert "derivation-prerequisites-to-build and substitutes, non-substitutable build"
848 (let* ((store (open-connection))
849 (drv (build-expression->derivation store "prereq-no-subst"
851 #:substitutable? #f))
852 (output (derivation->output-path drv)))
854 ;; Make sure substitutes are usable.
855 (set-build-options store #:use-substitutes? #t
856 #:substitute-urls (%test-substitute-urls))
858 (with-derivation-narinfo drv
859 (let-values (((build download)
860 (derivation-prerequisites-to-build store drv)))
861 ;; Despite being available as a substitute, DRV will be built locally
862 ;; due to #:substitutable? #f.
863 (and (null? download)
865 (((? derivation-input? input))
866 (string=? (derivation-input-path input)
867 (derivation-file-name drv)))))))))
869 (test-assert "derivation-prerequisites-to-build and substitutes, local build"
871 (let* ((drv (build-expression->derivation store "prereq-subst-local"
874 (output (derivation->output-path drv)))
876 ;; Make sure substitutes are usable.
877 (set-build-options store #:use-substitutes? #t
878 #:substitute-urls (%test-substitute-urls))
880 (with-derivation-narinfo drv
881 (let-values (((build download)
882 (derivation-prerequisites-to-build store drv)))
883 ;; #:local-build? is *not* synonymous with #:substitutable?, so we
884 ;; must be able to substitute DRV's output.
885 ;; See <http://bugs.gnu.org/18747>.
888 (((= substitutable-path item))
889 (string=? item (derivation->output-path drv))))))))))
891 (test-assert "derivation-prerequisites-to-build in 'check' mode"
893 (let* ((dep (build-expression->derivation store "dep"
894 `(begin ,(random-text)
896 (drv (build-expression->derivation store "to-check"
898 #:inputs `(("dep" ,dep)))))
899 (build-derivations store (list drv))
900 (delete-paths store (list (derivation->output-path dep)))
902 ;; In 'check' mode, DEP must be rebuilt.
903 (and (null? (derivation-prerequisites-to-build store drv))
904 (match (derivation-prerequisites-to-build store drv
908 (string=? (derivation-input-path input)
909 (derivation-file-name dep))))))))
911 (test-assert "substitution-oracle and #:substitute? #f"
913 (let* ((dep (build-expression->derivation store "dep"
914 `(begin ,(random-text)
916 (drv (build-expression->derivation store "not-subst"
917 `(begin ,(random-text)
920 #:inputs `(("dep" ,dep))))
922 (define (record-substitutable-path-query store paths)
924 (error "already called!" query))
928 (mock ((guix store) substitutable-path-info
929 record-substitutable-path-query)
931 (let ((pred (substitution-oracle store (list drv))))
932 (pred (derivation->output-path drv))))
934 ;; Make sure the oracle didn't try to get substitute info for DRV since
935 ;; DRV is mark as non-substitutable. Assume that GUILE-FOR-BUILD is
936 ;; already in store and thus not part of QUERY.
937 (equal? (pk 'query query)
938 (list (derivation->output-path dep))))))
940 (test-assert "build-expression->derivation with expression returning #f"
941 (let* ((builder '(begin
944 (drv (build-expression->derivation %store "fail" builder))
945 (out-path (derivation->output-path drv)))
946 (guard (c ((store-protocol-error? c)
947 ;; Note that the output path may exist at this point, but it
949 (and (string-match "build .* failed"
950 (store-protocol-error-message c))
951 (not (valid-path? %store out-path)))))
952 (build-derivations %store (list drv))
955 (test-assert "build-expression->derivation with two outputs"
956 (let* ((builder '(begin
957 (call-with-output-file (assoc-ref %outputs "out")
959 (display '(hello) p)))
960 (call-with-output-file (assoc-ref %outputs "second")
962 (display '(world) p)))))
963 (drv (build-expression->derivation %store "double" builder
966 (succeeded? (build-derivations %store (list drv))))
968 (let ((one (derivation->output-path drv))
969 (two (derivation->output-path drv "second")))
970 (and (equal? '(hello) (call-with-input-file one read))
971 (equal? '(world) (call-with-input-file two read)))))))
973 (test-skip (if %coreutils 0 1))
974 (test-assert "build-expression->derivation with one input"
975 (let* ((builder '(call-with-output-file %output
977 (let ((cu (assoc-ref %build-inputs "cu")))
979 (dup2 (port->fdes p) 1)
980 (execl (string-append cu "/bin/uname")
982 (drv (build-expression->derivation %store "uname" builder
984 `(("cu" ,%coreutils))))
985 (succeeded? (build-derivations %store (list drv))))
987 (let ((p (derivation->output-path drv)))
988 (string-contains (call-with-input-file p read-line) "GNU")))))
990 (test-assert "build-expression->derivation with modules"
991 (let* ((builder `(begin
992 (use-modules (guix build utils))
993 (let ((out (assoc-ref %outputs "out")))
994 (mkdir-p (string-append out "/guile/guix/nix"))
996 (drv (build-expression->derivation %store "test-with-modules"
999 '((guix build utils)))))
1000 (and (build-derivations %store (list drv))
1001 (let* ((p (derivation->output-path drv))
1002 (s (stat (string-append p "/guile/guix/nix"))))
1003 (eq? (stat:type s) 'directory)))))
1005 (test-assert "build-expression->derivation: same fixed-output path"
1006 (let* ((builder1 '(call-with-output-file %output
1008 (write "hello" p))))
1009 (builder2 '(call-with-output-file (pk 'difference-here! %output)
1011 (write "hello" p))))
1012 (hash (sha256 (string->utf8 "hello")))
1013 (input1 (build-expression->derivation %store "fixed" builder1
1015 #:hash-algo 'sha256))
1016 (input2 (build-expression->derivation %store "fixed" builder2
1018 #:hash-algo 'sha256))
1019 (succeeded? (build-derivations %store (list input1 input2))))
1021 (not (string=? (derivation-file-name input1)
1022 (derivation-file-name input2)))
1023 (string=? (derivation->output-path input1)
1024 (derivation->output-path input2)))))
1026 (test-assert "build-expression->derivation with a fixed-output input"
1027 (let* ((builder1 '(call-with-output-file %output
1029 (write "hello" p))))
1030 (builder2 '(call-with-output-file (pk 'difference-here! %output)
1032 (write "hello" p))))
1033 (hash (sha256 (string->utf8 "hello")))
1034 (input1 (build-expression->derivation %store "fixed" builder1
1036 #:hash-algo 'sha256))
1037 (input2 (build-expression->derivation %store "fixed" builder2
1039 #:hash-algo 'sha256))
1040 (builder3 '(let ((input (assoc-ref %build-inputs "input")))
1041 (call-with-output-file %output
1043 (format #f "My input is ~a.~%" input)))))
1044 (final1 (build-expression->derivation %store "final" builder3
1046 `(("input" ,input1))))
1047 (final2 (build-expression->derivation %store "final" builder3
1049 `(("input" ,input2)))))
1050 (and (string=? (derivation->output-path final1)
1051 (derivation->output-path final2))
1052 (string=? (derivation->output-path final1)
1053 (derivation-path->output-path
1054 (derivation-file-name final1)))
1055 (build-derivations %store (list final1 final2)))))
1057 (test-assert "build-expression->derivation produces recursive fixed-output"
1058 (let* ((builder '(begin
1059 (use-modules (srfi srfi-26))
1062 (call-with-output-file "exe"
1063 (cut display "executable" <>))
1065 (symlink "exe" "symlink")
1067 (drv (build-expression->derivation %store "fixed-rec" builder
1070 "10k1lw41wyrjf9mxydi0is5nkpynlsvgslinics4ppir13g7d74p")
1072 (and (build-derivations %store (list drv))
1073 (let* ((dir (derivation->output-path drv))
1074 (exe (string-append dir "/exe"))
1075 (link (string-append dir "/symlink"))
1076 (subdir (string-append dir "/subdir")))
1077 (and (executable-file? exe)
1078 (string=? "executable"
1079 (call-with-input-file exe get-string-all))
1080 (string=? "exe" (readlink link))
1081 (file-is-directory? subdir))))))
1083 (test-assert "build-expression->derivation uses recursive fixed-output"
1084 (let* ((builder '(call-with-output-file %output
1086 (display "hello" port))))
1087 (fixed (build-expression->derivation %store "small-fixed-rec"
1091 "0sg9f58l1jj88w6pdrfdpj5x9b1zrwszk84j81zvby36q9whhhqa")
1093 (in (derivation->output-path fixed))
1097 (symlink ,in "symlink")))
1098 (drv (build-expression->derivation %store "fixed-rec-user"
1100 #:inputs `(("fixed" ,fixed)))))
1101 (and (build-derivations %store (list drv))
1102 (let ((out (derivation->output-path drv)))
1103 (string=? (readlink (string-append out "/symlink")) in)))))
1105 (test-assert "build-expression->derivation with #:references-graphs"
1106 (let* ((input (add-text-to-store %store "foo" "hello"
1107 (list %bash %mkdir)))
1108 (builder '(copy-file "input" %output))
1109 (drv (build-expression->derivation %store "references-graphs"
1112 `(("input" . ,input))))
1113 (out (derivation->output-path drv)))
1114 (define (deps path . deps)
1115 (let ((count (length deps)))
1116 (string-append path "\n\n" (number->string count) "\n"
1117 (string-join (sort deps string<?) "\n")
1118 (if (zero? count) "" "\n"))))
1120 (and (build-derivations %store (list drv))
1121 (equal? (call-with-input-file out get-string-all)
1124 (sort (map (lambda (p d)
1125 (cons p (apply deps p d)))
1126 (list input %bash %mkdir)
1127 (list (list %bash %mkdir)
1134 (string<? p1 p2)))))))))))))
1136 (test-equal "derivation-properties"
1137 (list '() '((type . test)))
1138 (let ((drv1 (build-expression->derivation %store "bar"
1140 (drv2 (build-expression->derivation %store "foo"
1142 #:properties '((type . test)))))
1143 (list (derivation-properties drv1)
1144 (derivation-properties drv2))))
1146 (test-equal "map-derivation"
1148 (let* ((joke (package-derivation %store guile-1.8))
1149 (good (package-derivation %store %bootstrap-guile))
1150 (drv1 (build-expression->derivation %store "original-drv1"
1151 #f ; systematically fail
1152 #:guile-for-build joke))
1153 (drv2 (build-expression->derivation %store "original-drv2"
1154 '(call-with-output-file %output
1156 (display "hello" p)))))
1157 (drv3 (build-expression->derivation %store "drv-to-remap"
1158 '(let ((in (assoc-ref
1159 %build-inputs "in")))
1160 (copy-file in %output))
1161 #:inputs `(("in" ,drv1))
1162 #:guile-for-build joke))
1163 (drv4 (map-derivation %store drv3 `((,drv1 . ,drv2)
1165 (out (derivation->output-path drv4)))
1166 (and (build-derivations %store (list (pk 'remapped drv4)))
1167 (call-with-input-file out get-string-all))))
1169 (test-equal "map-derivation, sources"
1171 (let* ((script1 (add-text-to-store %store "fail.sh" "exit 1"))
1172 (script2 (add-text-to-store %store "hi.sh" "echo -n hello > $out"))
1173 (bash-full (package-derivation %store (@ (gnu packages bash) bash)))
1174 (drv1 (derivation %store "drv-to-remap"
1176 ;; XXX: This wouldn't work in practice, but if
1177 ;; we append "/bin/bash" then we can't replace
1178 ;; it with the bootstrap bash, which is a
1180 (derivation->output-path bash-full)
1183 #:inputs `((,bash-full) (,script1))))
1184 (drv2 (map-derivation %store drv1
1185 `((,bash-full . ,%bash)
1186 (,script1 . ,script2))))
1187 (out (derivation->output-path drv2)))
1188 (and (build-derivations %store (list (pk 'remapped* drv2)))
1189 (call-with-input-file out get-string-all))))
1194 ;; eval: (put 'with-http-server 'scheme-indent-function 2)