-;;; Guix --- Nix package management from Guile. -*- coding: utf-8 -*-
-;;; Copyright (C) 2012 Ludovic Courtès <ludo@gnu.org>
+;;; GNU Guix --- Functional package management for GNU
+;;; Copyright © 2012, 2013, 2014, 2015 Ludovic Courtès <ludo@gnu.org>
;;;
-;;; This file is part of Guix.
+;;; This file is part of GNU Guix.
;;;
-;;; Guix is free software; you can redistribute it and/or modify it
+;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
-;;; Guix is distributed in the hope that it will be useful, but
+;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
-;;; along with Guix. If not, see <http://www.gnu.org/licenses/>.
-
+;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
(define-module (test-derivations)
#:use-module (guix derivations)
#:use-module (guix store)
#:use-module (guix utils)
+ #:use-module (guix hash)
#:use-module (guix base32)
- #:use-module ((guix packages) #:select (package-derivation))
- #:use-module (distro packages bootstrap)
+ #:use-module (guix tests)
+ #:use-module ((guix packages) #:select (package-derivation base32))
+ #:use-module ((guix build utils) #:select (executable-file?))
+ #:use-module ((gnu packages) #:select (search-bootstrap-binary))
+ #:use-module (gnu packages bootstrap)
+ #:use-module ((gnu packages guile) #:select (guile-1.8))
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-11)
#:use-module (srfi srfi-26)
#:use-module (srfi srfi-64)
#:use-module (rnrs io ports)
#:use-module (rnrs bytevectors)
+ #:use-module (web uri)
#:use-module (ice-9 rdelim)
#:use-module (ice-9 regex)
#:use-module (ice-9 ftw)
#:use-module (ice-9 match))
(define %store
- (false-if-exception (open-connection)))
+ (open-connection-for-tests))
-(when %store
- ;; Make sure we build everything by ourselves.
- (set-build-options %store #:use-substitutes? #f)
+(define (bootstrap-binary name)
+ (let ((bin (search-bootstrap-binary name (%current-system))))
+ (and %store
+ (add-to-store %store name #t "sha256" bin))))
- ;; By default, use %BOOTSTRAP-GUILE for the current system.
- (let ((drv (package-derivation %store %bootstrap-guile)))
- (%guile-for-build drv)))
+(define %bash
+ (bootstrap-binary "bash"))
+(define %mkdir
+ (bootstrap-binary "mkdir"))
-(define (directory-contents dir)
+(define* (directory-contents dir #:optional (slurp get-bytevector-all))
"Return an alist representing the contents of DIR."
(define prefix-len (string-length dir))
(sort (file-system-fold (const #t) ; enter?
(lambda (path stat result) ; leaf
(alist-cons (string-drop path prefix-len)
- (call-with-input-file path
- get-bytevector-all)
+ (call-with-input-file path slurp)
result))
(lambda (path stat result) result) ; down
(lambda (path stat result) result) ; up
(and (equal? b1 b2)
(equal? d1 d2))))
-(test-skip (if %store 0 4))
+(test-skip (if %store 0 12))
(test-assert "add-to-store, flat"
(let* ((file (search-path %load-path "language/tree-il/spec.scm"))
- (drv (add-to-store %store "flat-test" #t #f "sha256" file)))
+ (drv (add-to-store %store "flat-test" #f "sha256" file)))
(and (eq? 'regular (stat:type (stat drv)))
(valid-path? %store drv)
(equal? (call-with-input-file file get-bytevector-all)
(test-assert "add-to-store, recursive"
(let* ((dir (dirname (search-path %load-path "language/tree-il/spec.scm")))
- (drv (add-to-store %store "dir-tree-test" #t #t "sha256" dir)))
+ (drv (add-to-store %store "dir-tree-test" #t "sha256" dir)))
(and (eq? 'directory (stat:type (stat drv)))
(valid-path? %store drv)
(equal? (directory-contents dir)
(test-assert "derivation with no inputs"
(let* ((builder (add-text-to-store %store "my-builder.sh"
- "#!/bin/sh\necho hello, world\n"
+ "echo hello, world\n"
'()))
- (drv-path (derivation %store "foo" (%current-system) builder
- '() '(("HOME" . "/homeless")) '())))
- (and (store-path? drv-path)
- (valid-path? %store drv-path))))
+ (drv (derivation %store "foo"
+ %bash `("-e" ,builder)
+ #:env-vars '(("HOME" . "/homeless")))))
+ (and (store-path? (derivation-file-name drv))
+ (valid-path? %store (derivation-file-name drv)))))
(test-assert "build derivation with 1 source"
- (let*-values (((builder)
- (add-text-to-store %store "my-builder.sh"
- "echo hello, world > \"$out\"\n"
- '()))
- ((drv-path drv)
- (derivation %store "foo" (%current-system)
- "/bin/sh" `(,builder)
- '(("HOME" . "/homeless")
- ("zzz" . "Z!")
- ("AAA" . "A!"))
- `((,builder))))
- ((succeeded?)
- (build-derivations %store (list drv-path))))
+ (let* ((builder (add-text-to-store %store "my-builder.sh"
+ "echo hello, world > \"$out\"\n"
+ '()))
+ (drv (derivation %store "foo"
+ %bash `(,builder)
+ #:env-vars '(("HOME" . "/homeless")
+ ("zzz" . "Z!")
+ ("AAA" . "A!"))
+ #:inputs `((,%bash) (,builder))))
+ (succeeded?
+ (build-derivations %store (list drv))))
(and succeeded?
- (let ((path (derivation-output-path
- (assoc-ref (derivation-outputs drv) "out"))))
+ (let ((path (derivation->output-path drv)))
(and (valid-path? %store path)
(string=? (call-with-input-file path read-line)
"hello, world"))))))
+(test-assert "derivation with local file as input"
+ (let* ((builder (add-text-to-store
+ %store "my-builder.sh"
+ "(while read line ; do echo \"$line\" ; done) < $in > $out"
+ '()))
+ (input (search-path %load-path "ice-9/boot-9.scm"))
+ (input* (add-to-store %store (basename input)
+ #t "sha256" input))
+ (drv (derivation %store "derivation-with-input-file"
+ %bash `(,builder)
+
+ ;; Cheat to pass the actual file name to the
+ ;; builder.
+ #:env-vars `(("in" . ,input*))
+
+ #:inputs `((,%bash)
+ (,builder)
+ (,input))))) ; ← local file name
+ (and (build-derivations %store (list drv))
+ ;; Note: we can't compare the files because the above trick alters
+ ;; the contents.
+ (valid-path? %store (derivation->output-path drv)))))
+
+(test-assert "identical files are deduplicated"
+ (let* ((build1 (add-text-to-store %store "one.sh"
+ "echo hello, world > \"$out\"\n"
+ '()))
+ (build2 (add-text-to-store %store "two.sh"
+ "# Hey!\necho hello, world > \"$out\"\n"
+ '()))
+ (drv1 (derivation %store "foo"
+ %bash `(,build1)
+ #:inputs `((,%bash) (,build1))))
+ (drv2 (derivation %store "bar"
+ %bash `(,build2)
+ #:inputs `((,%bash) (,build2)))))
+ (and (build-derivations %store (list drv1 drv2))
+ (let ((file1 (derivation->output-path drv1))
+ (file2 (derivation->output-path drv2)))
+ (and (valid-path? %store file1) (valid-path? %store file2)
+ (string=? (call-with-input-file file1 get-string-all)
+ "hello, world\n")
+ (= (stat:ino (lstat file1))
+ (stat:ino (lstat file2))))))))
+
+(test-equal "derivation-name"
+ "foo-0.0"
+ (let ((drv (derivation %store "foo-0.0" %bash '())))
+ (derivation-name drv)))
+
+(test-equal "derivation-output-names"
+ '(("out") ("bar" "chbouib"))
+ (let ((drv1 (derivation %store "foo-0.0" %bash '()))
+ (drv2 (derivation %store "foo-0.0" %bash '()
+ #:outputs '("bar" "chbouib"))))
+ (list (derivation-output-names drv1)
+ (derivation-output-names drv2))))
+
+(test-assert "offloadable-derivation?"
+ (and (offloadable-derivation? (derivation %store "foo" %bash '()))
+ (not (offloadable-derivation?
+ (derivation %store "foo" %bash '()
+ #:local-build? #t)))))
+
+(test-assert "fixed-output-derivation?"
+ (let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
+ "echo -n hello > $out" '()))
+ (hash (sha256 (string->utf8 "hello")))
+ (drv (derivation %store "fixed"
+ %bash `(,builder)
+ #:inputs `((,builder))
+ #:hash hash #:hash-algo 'sha256)))
+ (fixed-output-derivation? drv)))
+
(test-assert "fixed-output derivation"
(let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
"echo -n hello > $out" '()))
(hash (sha256 (string->utf8 "hello")))
- (drv-path (derivation %store "fixed" (%current-system)
- "/bin/sh" `(,builder)
- '()
- `((,builder)) ; optional
+ (drv (derivation %store "fixed"
+ %bash `(,builder)
+ #:inputs `((,builder)) ; optional
#:hash hash #:hash-algo 'sha256))
- (succeeded? (build-derivations %store (list drv-path))))
+ (succeeded? (build-derivations %store (list drv))))
(and succeeded?
- (let ((p (derivation-path->output-path drv-path)))
+ (let ((p (derivation->output-path drv)))
(and (equal? (string->utf8 "hello")
(call-with-input-file p get-bytevector-all))
(bytevector? (query-path-hash %store p)))))))
(builder2 (add-text-to-store %store "fixed-builder2.sh"
"echo hey; echo -n hello > $out" '()))
(hash (sha256 (string->utf8 "hello")))
- (drv-path1 (derivation %store "fixed" (%current-system)
- "/bin/sh" `(,builder1)
- '() `()
+ (drv1 (derivation %store "fixed"
+ %bash `(,builder1)
#:hash hash #:hash-algo 'sha256))
- (drv-path2 (derivation %store "fixed" (%current-system)
- "/bin/sh" `(,builder2)
- '() `()
+ (drv2 (derivation %store "fixed"
+ %bash `(,builder2)
#:hash hash #:hash-algo 'sha256))
- (succeeded? (build-derivations %store
- (list drv-path1 drv-path2))))
+ (succeeded? (build-derivations %store (list drv1 drv2))))
(and succeeded?
- (equal? (derivation-path->output-path drv-path1)
- (derivation-path->output-path drv-path2)))))
+ (equal? (derivation->output-path drv1)
+ (derivation->output-path drv2)))))
+
+(test-assert "fixed-output derivation, recursive"
+ (let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
+ "echo -n hello > $out" '()))
+ (hash (sha256 (string->utf8 "hello")))
+ (drv (derivation %store "fixed-rec"
+ %bash `(,builder)
+ #:inputs `((,builder))
+ #:hash (base32 "0sg9f58l1jj88w6pdrfdpj5x9b1zrwszk84j81zvby36q9whhhqa")
+ #:hash-algo 'sha256
+ #:recursive? #t))
+ (succeeded? (build-derivations %store (list drv))))
+ (and succeeded?
+ (let ((p (derivation->output-path drv)))
+ (and (equal? (string->utf8 "hello")
+ (call-with-input-file p get-bytevector-all))
+ (bytevector? (query-path-hash %store p)))))))
(test-assert "derivation with a fixed-output input"
;; A derivation D using a fixed-output derivation F doesn't has the same
(builder2 (add-text-to-store %store "fixed-builder2.sh"
"echo hey; echo -n hello > $out" '()))
(hash (sha256 (string->utf8 "hello")))
- (fixed1 (derivation %store "fixed" (%current-system)
- "/bin/sh" `(,builder1)
- '() `()
+ (fixed1 (derivation %store "fixed"
+ %bash `(,builder1)
#:hash hash #:hash-algo 'sha256))
- (fixed2 (derivation %store "fixed" (%current-system)
- "/bin/sh" `(,builder2)
- '() `()
+ (fixed2 (derivation %store "fixed"
+ %bash `(,builder2)
#:hash hash #:hash-algo 'sha256))
- (fixed-out (derivation-path->output-path fixed1))
+ (fixed-out (derivation->output-path fixed1))
(builder3 (add-text-to-store
%store "final-builder.sh"
;; Use Bash hackery to avoid Coreutils.
"echo $in ; (read -u 3 c; echo $c) 3< $in > $out" '()))
- (final1 (derivation %store "final" (%current-system)
- "/bin/sh" `(,builder3)
- `(("in" . ,fixed-out))
- `((,builder3) (,fixed1))))
- (final2 (derivation %store "final" (%current-system)
- "/bin/sh" `(,builder3)
- `(("in" . ,fixed-out))
- `((,builder3) (,fixed2))))
+ (final1 (derivation %store "final"
+ %bash `(,builder3)
+ #:env-vars `(("in" . ,fixed-out))
+ #:inputs `((,%bash) (,builder3) (,fixed1))))
+ (final2 (derivation %store "final"
+ %bash `(,builder3)
+ #:env-vars `(("in" . ,fixed-out))
+ #:inputs `((,%bash) (,builder3) (,fixed2))))
(succeeded? (build-derivations %store
(list final1 final2))))
(and succeeded?
- (equal? (derivation-path->output-path final1)
- (derivation-path->output-path final2)))))
+ (equal? (derivation->output-path final1)
+ (derivation->output-path final2)))))
(test-assert "multiple-output derivation"
(let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
"echo one > $out ; echo two > $second"
'()))
- (drv-path (derivation %store "fixed" (%current-system)
- "/bin/sh" `(,builder)
- '(("HOME" . "/homeless")
- ("zzz" . "Z!")
- ("AAA" . "A!"))
- `((,builder))
+ (drv (derivation %store "fixed"
+ %bash `(,builder)
+ #:env-vars '(("HOME" . "/homeless")
+ ("zzz" . "Z!")
+ ("AAA" . "A!"))
+ #:inputs `((,%bash) (,builder))
#:outputs '("out" "second")))
- (succeeded? (build-derivations %store (list drv-path))))
+ (succeeded? (build-derivations %store (list drv))))
(and succeeded?
- (let ((one (derivation-path->output-path drv-path "out"))
- (two (derivation-path->output-path drv-path "second")))
- (and (eq? 'one (call-with-input-file one read))
+ (let ((one (derivation->output-path drv "out"))
+ (two (derivation->output-path drv "second")))
+ (and (lset= equal?
+ (derivation->output-paths drv)
+ `(("out" . ,one) ("second" . ,two)))
+ (eq? 'one (call-with-input-file one read))
(eq? 'two (call-with-input-file two read)))))))
(test-assert "multiple-output derivation, non-alphabetic order"
(let* ((builder (add-text-to-store %store "my-fixed-builder.sh"
"echo one > $out ; echo two > $AAA"
'()))
- (drv-path (derivation %store "fixed" (%current-system)
- "/bin/sh" `(,builder)
- '()
- `((,builder))
+ (drv (derivation %store "fixed"
+ %bash `(,builder)
+ #:inputs `((,%bash) (,builder))
#:outputs '("out" "AAA")))
- (succeeded? (build-derivations %store (list drv-path))))
+ (succeeded? (build-derivations %store (list drv))))
(and succeeded?
- (let ((one (derivation-path->output-path drv-path "out"))
- (two (derivation-path->output-path drv-path "AAA")))
+ (let ((one (derivation->output-path drv "out"))
+ (two (derivation->output-path drv "AAA")))
(and (eq? 'one (call-with-input-file one read))
(eq? 'two (call-with-input-file two read)))))))
+(test-assert "multiple-output derivation, derivation-path->output-path"
+ (let* ((builder (add-text-to-store %store "builder.sh"
+ "echo one > $out ; echo two > $second"
+ '()))
+ (drv (derivation %store "multiple"
+ %bash `(,builder)
+ #:outputs '("out" "second")))
+ (drv-file (derivation-file-name drv))
+ (one (derivation->output-path drv "out"))
+ (two (derivation->output-path drv "second"))
+ (first (derivation-path->output-path drv-file "out"))
+ (second (derivation-path->output-path drv-file "second")))
+ (and (not (string=? one two))
+ (string-suffix? "-second" two)
+ (string=? first one)
+ (string=? second two))))
+
(test-assert "user of multiple-output derivation"
;; Check whether specifying several inputs coming from the same
;; multiple-output derivation works.
(let* ((builder1 (add-text-to-store %store "my-mo-builder.sh"
"echo one > $out ; echo two > $two"
'()))
- (mdrv (derivation %store "multiple-output" (%current-system)
- "/bin/sh" `(,builder1)
- '()
- `((,builder1))
+ (mdrv (derivation %store "multiple-output"
+ %bash `(,builder1)
+ #:inputs `((,%bash) (,builder1))
#:outputs '("out" "two")))
(builder2 (add-text-to-store %store "my-mo-user-builder.sh"
"read x < $one;
echo \"($x $y)\" > $out"
'()))
(udrv (derivation %store "multiple-output-user"
- (%current-system)
- "/bin/sh" `(,builder2)
- `(("one" . ,(derivation-path->output-path
- mdrv "out"))
- ("two" . ,(derivation-path->output-path
- mdrv "two")))
- `((,builder2)
- ;; two occurrences of MDRV:
- (,mdrv)
- (,mdrv "two")))))
+ %bash `(,builder2)
+ #:env-vars `(("one"
+ . ,(derivation->output-path
+ mdrv "out"))
+ ("two"
+ . ,(derivation->output-path
+ mdrv "two")))
+ #:inputs `((,%bash)
+ (,builder2)
+ ;; two occurrences of MDRV:
+ (,mdrv)
+ (,mdrv "two")))))
(and (build-derivations %store (list (pk 'udrv udrv)))
- (let ((p (derivation-path->output-path udrv)))
+ (let ((p (derivation->output-path udrv)))
(and (valid-path? %store p)
(equal? '(one two) (call-with-input-file p read)))))))
+(test-assert "derivation with #:references-graphs"
+ (let* ((input1 (add-text-to-store %store "foo" "hello"
+ (list %bash)))
+ (input2 (add-text-to-store %store "bar"
+ (number->string (random 7777))
+ (list input1)))
+ (builder (add-text-to-store %store "build-graph"
+ (format #f "
+~a $out
+ (while read l ; do echo $l ; done) < bash > $out/bash
+ (while read l ; do echo $l ; done) < input1 > $out/input1
+ (while read l ; do echo $l ; done) < input2 > $out/input2"
+ %mkdir)
+ (list %mkdir)))
+ (drv (derivation %store "closure-graphs"
+ %bash `(,builder)
+ #:references-graphs
+ `(("bash" . ,%bash)
+ ("input1" . ,input1)
+ ("input2" . ,input2))
+ #:inputs `((,%bash) (,builder))))
+ (out (derivation->output-path drv)))
+ (define (deps path . deps)
+ (let ((count (length deps)))
+ (string-append path "\n\n" (number->string count) "\n"
+ (string-join (sort deps string<?) "\n")
+ (if (zero? count) "" "\n"))))
+
+ (and (build-derivations %store (list drv))
+ (equal? (directory-contents out get-string-all)
+ `(("/bash" . ,(string-append %bash "\n\n0\n"))
+ ("/input1" . ,(if (string>? input1 %bash)
+ (string-append (deps %bash)
+ (deps input1 %bash))
+ (string-append (deps input1 %bash)
+ (deps %bash))))
+ ("/input2" . ,(string-concatenate
+ (map cdr
+ (sort
+ (map (lambda (p d)
+ (cons p (apply deps p d)))
+ (list %bash input1 input2)
+ (list '() (list %bash) (list input1)))
+ (lambda (x y)
+ (match x
+ ((p1 . _)
+ (match y
+ ((p2 . _)
+ (string<? p1 p2)))))))))))))))
+
+(test-assert "derivation #:allowed-references, ok"
+ (let ((drv (derivation %store "allowed" %bash
+ '("-c" "echo hello > $out")
+ #:inputs `((,%bash))
+ #:allowed-references '())))
+ (build-derivations %store (list drv))))
+
+(test-assert "derivation #:allowed-references, not allowed"
+ (let* ((txt (add-text-to-store %store "foo" "Hello, world."))
+ (drv (derivation %store "disallowed" %bash
+ `("-c" ,(string-append "echo " txt "> $out"))
+ #:inputs `((,%bash) (,txt))
+ #:allowed-references '())))
+ (guard (c ((nix-protocol-error? c)
+ ;; There's no specific error message to check for.
+ #t))
+ (build-derivations %store (list drv))
+ #f)))
+
+(test-assert "derivation #:allowed-references, self allowed"
+ (let ((drv (derivation %store "allowed" %bash
+ '("-c" "echo $out > $out")
+ #:inputs `((,%bash))
+ #:allowed-references '("out"))))
+ (build-derivations %store (list drv))))
+
+(test-assert "derivation #:allowed-references, self not allowed"
+ (let ((drv (derivation %store "disallowed" %bash
+ `("-c" ,"echo $out > $out")
+ #:inputs `((,%bash))
+ #:allowed-references '())))
+ (guard (c ((nix-protocol-error? c)
+ ;; There's no specific error message to check for.
+ #t))
+ (build-derivations %store (list drv))
+ #f)))
+
\f
(define %coreutils
(false-if-exception
- (or (package-derivation %store %bootstrap-coreutils&co)
- (nixpkgs-derivation "coreutils"))))
+ (and (network-reachable?)
+ (or (package-derivation %store %bootstrap-coreutils&co)
+ (nixpkgs-derivation "coreutils")))))
(test-skip (if %coreutils 0 1))
(add-text-to-store %store "build-with-coreutils.sh"
"echo $PATH ; mkdir --version ; mkdir $out ; touch $out/good"
'()))
- (drv-path
- (derivation %store "foo" (%current-system)
- "/bin/sh" `(,builder)
- `(("PATH" .
- ,(string-append
- (derivation-path->output-path %coreutils)
- "/bin")))
- `((,builder)
- (,%coreutils))))
+ (drv
+ (derivation %store "foo"
+ %bash `(,builder)
+ #:env-vars `(("PATH" .
+ ,(string-append
+ (derivation->output-path %coreutils)
+ "/bin")))
+ #:inputs `((,builder)
+ (,%coreutils))))
(succeeded?
- (build-derivations %store (list drv-path))))
+ (build-derivations %store (list drv))))
(and succeeded?
- (let ((p (derivation-path->output-path drv-path)))
+ (let ((p (derivation->output-path drv)))
(and (valid-path? %store p)
(file-exists? (string-append p "/good")))))))
-(test-skip (if (%guile-for-build) 0 7))
+(test-skip (if (%guile-for-build) 0 8))
(test-assert "build-expression->derivation and derivation-prerequisites"
- (let-values (((drv-path drv)
- (build-expression->derivation %store "fail" (%current-system)
- #f '())))
+ (let ((drv (build-expression->derivation %store "fail" #f)))
(any (match-lambda
(($ <derivation-input> path)
- (string=? path (%guile-for-build))))
+ (string=? path (derivation-file-name (%guile-for-build)))))
(derivation-prerequisites drv))))
(test-assert "build-expression->derivation without inputs"
(call-with-output-file (string-append %output "/test")
(lambda (p)
(display '(hello guix) p)))))
- (drv-path (build-expression->derivation %store "goo" (%current-system)
- builder '()))
- (succeeded? (build-derivations %store (list drv-path))))
+ (drv (build-expression->derivation %store "goo" builder))
+ (succeeded? (build-derivations %store (list drv))))
(and succeeded?
- (let ((p (derivation-path->output-path drv-path)))
+ (let ((p (derivation->output-path drv)))
(equal? '(hello guix)
(call-with-input-file (string-append p "/test") read))))))
+(test-assert "build-expression->derivation and max-silent-time"
+ (let* ((store (let ((s (open-connection)))
+ (set-build-options s #:max-silent-time 1)
+ s))
+ (builder '(begin (sleep 100) (mkdir %output) #t))
+ (drv (build-expression->derivation store "silent" builder))
+ (out-path (derivation->output-path drv)))
+ (guard (c ((nix-protocol-error? c)
+ (and (string-contains (nix-protocol-error-message c)
+ "failed")
+ (not (valid-path? store out-path)))))
+ (build-derivations store (list drv))
+ #f)))
+
+(test-assert "build-expression->derivation and timeout"
+ (let* ((store (let ((s (open-connection)))
+ (set-build-options s #:timeout 1)
+ s))
+ (builder '(begin (sleep 100) (mkdir %output) #t))
+ (drv (build-expression->derivation store "slow" builder))
+ (out-path (derivation->output-path drv)))
+ (guard (c ((nix-protocol-error? c)
+ (and (string-contains (nix-protocol-error-message c)
+ "failed")
+ (not (valid-path? store out-path)))))
+ (build-derivations store (list drv))
+ #f)))
+
(test-assert "build-expression->derivation and derivation-prerequisites-to-build"
- (let-values (((drv-path drv)
- (build-expression->derivation %store "fail" (%current-system)
- #f '())))
+ (let ((drv (build-expression->derivation %store "fail" #f)))
;; The only direct dependency is (%guile-for-build) and it's already
;; built.
(null? (derivation-prerequisites-to-build %store drv))))
+(test-assert "derivation-prerequisites-to-build when outputs already present"
+ (let* ((builder '(begin (mkdir %output) #t))
+ (input-drv (build-expression->derivation %store "input" builder))
+ (input-path (derivation-output-path
+ (assoc-ref (derivation-outputs input-drv)
+ "out")))
+ (drv (build-expression->derivation %store "something" builder
+ #:inputs
+ `(("i" ,input-drv))))
+ (output (derivation->output-path drv)))
+ ;; Make sure these things are not already built.
+ (when (valid-path? %store input-path)
+ (delete-paths %store (list input-path)))
+ (when (valid-path? %store output)
+ (delete-paths %store (list output)))
+
+ (and (equal? (map derivation-input-path
+ (derivation-prerequisites-to-build %store drv))
+ (list (derivation-file-name input-drv)))
+
+ ;; Build DRV and delete its input.
+ (build-derivations %store (list drv))
+ (delete-paths %store (list input-path))
+ (not (valid-path? %store input-path))
+
+ ;; Now INPUT-PATH is missing, yet it shouldn't be listed as a
+ ;; prerequisite to build because DRV itself is already built.
+ (null? (derivation-prerequisites-to-build %store drv)))))
+
+(test-assert "derivation-prerequisites-to-build and substitutes"
+ (let* ((store (open-connection))
+ (drv (build-expression->derivation store "prereq-subst"
+ (random 1000)))
+ (output (derivation->output-path drv)))
+
+ ;; Make sure substitutes are usable.
+ (set-build-options store #:use-substitutes? #t)
+
+ (with-derivation-narinfo drv
+ (let-values (((build download)
+ (derivation-prerequisites-to-build store drv))
+ ((build* download*)
+ (derivation-prerequisites-to-build store drv
+ #:substitutable?
+ (const #f))))
+ (and (null? build)
+ (equal? download (list output))
+ (null? download*)
+ (null? build*))))))
+
+(test-assert "derivation-prerequisites-to-build and substitutes, local build"
+ (let* ((store (open-connection))
+ (drv (build-expression->derivation store "prereq-subst-local"
+ (random 1000)
+ ;; XXX: Adjust once
+ ;; <http://bugs.gnu.org/18747>
+ ;; is fixed.
+ #:local-build? #t))
+ (output (derivation->output-path drv)))
+
+ ;; Make sure substitutes are usable.
+ (set-build-options store #:use-substitutes? #t)
+
+ (with-derivation-narinfo drv
+ (let-values (((build download)
+ (derivation-prerequisites-to-build store drv)))
+ ;; Despite being available as a substitute, DRV will be built locally
+ ;; due to #:local-build?.
+ (and (null? download)
+ (match build
+ (((? derivation-input? input))
+ (string=? (derivation-input-path input)
+ (derivation-file-name drv)))))))))
+
(test-assert "build-expression->derivation with expression returning #f"
(let* ((builder '(begin
(mkdir %output)
#f)) ; fail!
- (drv-path (build-expression->derivation %store "fail" (%current-system)
- builder '()))
- (out-path (derivation-path->output-path drv-path)))
+ (drv (build-expression->derivation %store "fail" builder))
+ (out-path (derivation->output-path drv)))
(guard (c ((nix-protocol-error? c)
;; Note that the output path may exist at this point, but it
;; is invalid.
(and (string-match "build .* failed"
(nix-protocol-error-message c))
(not (valid-path? %store out-path)))))
- (build-derivations %store (list drv-path))
+ (build-derivations %store (list drv))
#f)))
(test-assert "build-expression->derivation with two outputs"
(call-with-output-file (assoc-ref %outputs "second")
(lambda (p)
(display '(world) p)))))
- (drv-path (build-expression->derivation %store "double"
- (%current-system)
- builder '()
+ (drv (build-expression->derivation %store "double" builder
#:outputs '("out"
"second")))
- (succeeded? (build-derivations %store (list drv-path))))
+ (succeeded? (build-derivations %store (list drv))))
(and succeeded?
- (let ((one (derivation-path->output-path drv-path))
- (two (derivation-path->output-path drv-path "second")))
+ (let ((one (derivation->output-path drv))
+ (two (derivation->output-path drv "second")))
(and (equal? '(hello) (call-with-input-file one read))
(equal? '(world) (call-with-input-file two read)))))))
+(test-skip (if %coreutils 0 1))
(test-assert "build-expression->derivation with one input"
(let* ((builder '(call-with-output-file %output
(lambda (p)
(dup2 (port->fdes p) 1)
(execl (string-append cu "/bin/uname")
"uname" "-a")))))
- (drv-path (build-expression->derivation %store "uname" (%current-system)
- builder
+ (drv (build-expression->derivation %store "uname" builder
+ #:inputs
`(("cu" ,%coreutils))))
- (succeeded? (build-derivations %store (list drv-path))))
+ (succeeded? (build-derivations %store (list drv))))
(and succeeded?
- (let ((p (derivation-path->output-path drv-path)))
+ (let ((p (derivation->output-path drv)))
(string-contains (call-with-input-file p read-line) "GNU")))))
-(test-assert "imported-files"
- (let* ((files `(("x" . ,(search-path %load-path "ice-9/q.scm"))
- ("a/b/c" . ,(search-path %load-path
- "guix/derivations.scm"))
- ("p/q" . ,(search-path %load-path "guix.scm"))
- ("p/z" . ,(search-path %load-path "guix/store.scm"))))
- (drv-path (imported-files %store files)))
- (and (build-derivations %store (list drv-path))
- (let ((dir (derivation-path->output-path drv-path)))
- (every (match-lambda
- ((path . source)
- (equal? (call-with-input-file (string-append dir "/" path)
- get-bytevector-all)
- (call-with-input-file source
- get-bytevector-all))))
- files)))))
-
(test-assert "build-expression->derivation with modules"
(let* ((builder `(begin
(use-modules (guix build utils))
(let ((out (assoc-ref %outputs "out")))
(mkdir-p (string-append out "/guile/guix/nix"))
#t)))
- (drv-path (build-expression->derivation %store
- "test-with-modules"
- (%current-system)
- builder '()
+ (drv (build-expression->derivation %store "test-with-modules"
+ builder
#:modules
'((guix build utils)))))
- (and (build-derivations %store (list drv-path))
- (let* ((p (derivation-path->output-path drv-path))
+ (and (build-derivations %store (list drv))
+ (let* ((p (derivation->output-path drv))
(s (stat (string-append p "/guile/guix/nix"))))
(eq? (stat:type s) 'directory)))))
(lambda (p)
(write "hello" p))))
(hash (sha256 (string->utf8 "hello")))
- (input1 (build-expression->derivation %store "fixed"
- (%current-system)
- builder1 '()
+ (input1 (build-expression->derivation %store "fixed" builder1
#:hash hash
#:hash-algo 'sha256))
- (input2 (build-expression->derivation %store "fixed"
- (%current-system)
- builder2 '()
+ (input2 (build-expression->derivation %store "fixed" builder2
#:hash hash
#:hash-algo 'sha256))
(succeeded? (build-derivations %store (list input1 input2))))
(and succeeded?
- (not (string=? input1 input2))
- (string=? (derivation-path->output-path input1)
- (derivation-path->output-path input2)))))
+ (not (string=? (derivation-file-name input1)
+ (derivation-file-name input2)))
+ (string=? (derivation->output-path input1)
+ (derivation->output-path input2)))))
(test-assert "build-expression->derivation with a fixed-output input"
(let* ((builder1 '(call-with-output-file %output
(lambda (p)
(write "hello" p))))
(hash (sha256 (string->utf8 "hello")))
- (input1 (build-expression->derivation %store "fixed"
- (%current-system)
- builder1 '()
+ (input1 (build-expression->derivation %store "fixed" builder1
#:hash hash
#:hash-algo 'sha256))
- (input2 (build-expression->derivation %store "fixed"
- (%current-system)
- builder2 '()
+ (input2 (build-expression->derivation %store "fixed" builder2
#:hash hash
#:hash-algo 'sha256))
(builder3 '(let ((input (assoc-ref %build-inputs "input")))
(call-with-output-file %output
(lambda (out)
(format #f "My input is ~a.~%" input)))))
- (final1 (build-expression->derivation %store "final"
- (%current-system)
- builder3
+ (final1 (build-expression->derivation %store "final" builder3
+ #:inputs
`(("input" ,input1))))
- (final2 (build-expression->derivation %store "final"
- (%current-system)
- builder3
+ (final2 (build-expression->derivation %store "final" builder3
+ #:inputs
`(("input" ,input2)))))
- (and (string=? (derivation-path->output-path final1)
- (derivation-path->output-path final2))
+ (and (string=? (derivation->output-path final1)
+ (derivation->output-path final2))
+ (string=? (derivation->output-path final1)
+ (derivation-path->output-path
+ (derivation-file-name final1)))
(build-derivations %store (list final1 final2)))))
+(test-assert "build-expression->derivation produces recursive fixed-output"
+ (let* ((builder '(begin
+ (use-modules (srfi srfi-26))
+ (mkdir %output)
+ (chdir %output)
+ (call-with-output-file "exe"
+ (cut display "executable" <>))
+ (chmod "exe" #o777)
+ (symlink "exe" "symlink")
+ (mkdir "subdir")))
+ (drv (build-expression->derivation %store "fixed-rec" builder
+ #:hash-algo 'sha256
+ #:hash (base32
+ "10k1lw41wyrjf9mxydi0is5nkpynlsvgslinics4ppir13g7d74p")
+ #:recursive? #t)))
+ (and (build-derivations %store (list drv))
+ (let* ((dir (derivation->output-path drv))
+ (exe (string-append dir "/exe"))
+ (link (string-append dir "/symlink"))
+ (subdir (string-append dir "/subdir")))
+ (and (executable-file? exe)
+ (string=? "executable"
+ (call-with-input-file exe get-string-all))
+ (string=? "exe" (readlink link))
+ (file-is-directory? subdir))))))
+
+(test-assert "build-expression->derivation uses recursive fixed-output"
+ (let* ((builder '(call-with-output-file %output
+ (lambda (port)
+ (display "hello" port))))
+ (fixed (build-expression->derivation %store "small-fixed-rec"
+ builder
+ #:hash-algo 'sha256
+ #:hash (base32
+ "0sg9f58l1jj88w6pdrfdpj5x9b1zrwszk84j81zvby36q9whhhqa")
+ #:recursive? #t))
+ (in (derivation->output-path fixed))
+ (builder `(begin
+ (mkdir %output)
+ (chdir %output)
+ (symlink ,in "symlink")))
+ (drv (build-expression->derivation %store "fixed-rec-user"
+ builder
+ #:inputs `(("fixed" ,fixed)))))
+ (and (build-derivations %store (list drv))
+ (let ((out (derivation->output-path drv)))
+ (string=? (readlink (string-append out "/symlink")) in)))))
+
+(test-assert "build-expression->derivation with #:references-graphs"
+ (let* ((input (add-text-to-store %store "foo" "hello"
+ (list %bash %mkdir)))
+ (builder '(copy-file "input" %output))
+ (drv (build-expression->derivation %store "references-graphs"
+ builder
+ #:references-graphs
+ `(("input" . ,input))))
+ (out (derivation->output-path drv)))
+ (define (deps path . deps)
+ (let ((count (length deps)))
+ (string-append path "\n\n" (number->string count) "\n"
+ (string-join (sort deps string<?) "\n")
+ (if (zero? count) "" "\n"))))
+
+ (and (build-derivations %store (list drv))
+ (equal? (call-with-input-file out get-string-all)
+ (string-concatenate
+ (map cdr
+ (sort (map (lambda (p d)
+ (cons p (apply deps p d)))
+ (list input %bash %mkdir)
+ (list (list %bash %mkdir)
+ '() '()))
+ (lambda (x y)
+ (match x
+ ((p1 . _)
+ (match y
+ ((p2 . _)
+ (string<? p1 p2)))))))))))))
+
+
+(test-assert "graft-derivation"
+ (let* ((build `(begin
+ (mkdir %output)
+ (chdir %output)
+ (symlink %output "self")
+ (call-with-output-file "text"
+ (lambda (output)
+ (format output "foo/~a/bar" ,%mkdir)))
+ (symlink ,%bash "sh")))
+ (orig (build-expression->derivation %store "graft" build
+ #:inputs `(("a" ,%bash)
+ ("b" ,%mkdir))))
+ (one (add-text-to-store %store "bash" "fake bash"))
+ (two (build-expression->derivation %store "mkdir"
+ '(call-with-output-file %output
+ (lambda (port)
+ (display "fake mkdir" port)))))
+ (graft (graft-derivation %store "graft" orig
+ (list (graft
+ (origin %bash)
+ (replacement one))
+ (graft
+ (origin %mkdir)
+ (replacement two))))))
+ (and (build-derivations %store (list graft))
+ (let ((two (derivation->output-path two))
+ (graft (derivation->output-path graft)))
+ (and (string=? (format #f "foo/~a/bar" two)
+ (call-with-input-file (string-append graft "/text")
+ get-string-all))
+ (string=? (readlink (string-append graft "/sh")) one)
+ (string=? (readlink (string-append graft "/self")) graft))))))
+
+(test-equal "map-derivation"
+ "hello"
+ (let* ((joke (package-derivation %store guile-1.8))
+ (good (package-derivation %store %bootstrap-guile))
+ (drv1 (build-expression->derivation %store "original-drv1"
+ #f ; systematically fail
+ #:guile-for-build joke))
+ (drv2 (build-expression->derivation %store "original-drv2"
+ '(call-with-output-file %output
+ (lambda (p)
+ (display "hello" p)))))
+ (drv3 (build-expression->derivation %store "drv-to-remap"
+ '(let ((in (assoc-ref
+ %build-inputs "in")))
+ (copy-file in %output))
+ #:inputs `(("in" ,drv1))
+ #:guile-for-build joke))
+ (drv4 (map-derivation %store drv3 `((,drv1 . ,drv2)
+ (,joke . ,good))))
+ (out (derivation->output-path drv4)))
+ (and (build-derivations %store (list (pk 'remapped drv4)))
+ (call-with-input-file out get-string-all))))
+
+(test-equal "map-derivation, sources"
+ "hello"
+ (let* ((script1 (add-text-to-store %store "fail.sh" "exit 1"))
+ (script2 (add-text-to-store %store "hi.sh" "echo -n hello > $out"))
+ (bash-full (package-derivation %store (@ (gnu packages bash) bash)))
+ (drv1 (derivation %store "drv-to-remap"
+
+ ;; XXX: This wouldn't work in practice, but if
+ ;; we append "/bin/bash" then we can't replace
+ ;; it with the bootstrap bash, which is a
+ ;; single file.
+ (derivation->output-path bash-full)
+
+ `("-e" ,script1)
+ #:inputs `((,bash-full) (,script1))))
+ (drv2 (map-derivation %store drv1
+ `((,bash-full . ,%bash)
+ (,script1 . ,script2))))
+ (out (derivation->output-path drv2)))
+ (and (build-derivations %store (list (pk 'remapped* drv2)))
+ (call-with-input-file out get-string-all))))
+
(test-end)
\f
(exit (= (test-runner-fail-count (test-runner-current)) 0))
-
-;;; Local Variables:
-;;; eval: (put 'test-assert 'scheme-indent-function 1)
-;;; eval: (put 'guard 'scheme-indent-function 1)
-;;; End:
HCoop / jackhill / guix / guix.git / blobdiff