1 ;;; GNU Guix --- Functional package management for GNU
2 ;;; Copyright © 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 Ludovic Courtès <ludo@gnu.org>
3 ;;; Copyright © 2014 Alex Kost <alezost@gmail.com>
5 ;;; This file is part of GNU Guix.
7 ;;; GNU Guix is free software; you can redistribute it and/or modify it
8 ;;; under the terms of the GNU General Public License as published by
9 ;;; the Free Software Foundation; either version 3 of the License, or (at
10 ;;; your option) any later version.
12 ;;; GNU Guix is distributed in the hope that it will be useful, but
13 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
14 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 ;;; GNU General Public License for more details.
17 ;;; You should have received a copy of the GNU General Public License
18 ;;; along with GNU Guix. If not, see <http://www.gnu.org/licenses/>.
20 (define-module (test-profiles)
21 #:use-module (guix tests)
22 #:use-module (guix profiles)
23 #:use-module (guix gexp)
24 #:use-module (guix store)
25 #:use-module (guix monads)
26 #:use-module (guix grafts)
27 #:use-module (guix packages)
28 #:use-module (guix derivations)
29 #:use-module (guix build-system trivial)
30 #:use-module (gnu packages bootstrap)
31 #:use-module ((gnu packages base) #:prefix packages:)
32 #:use-module ((gnu packages guile) #:prefix packages:)
33 #:use-module (ice-9 match)
34 #:use-module (ice-9 regex)
35 #:use-module (ice-9 popen)
36 #:use-module (rnrs io ports)
37 #:use-module (srfi srfi-1)
38 #:use-module (srfi srfi-11)
39 #:use-module (srfi srfi-34)
40 #:use-module (srfi srfi-64))
42 ;; Test the (guix profiles) module.
45 (open-connection-for-tests))
47 ;; Globally disable grafts because they can trigger early builds.
50 ;; Example manifest entries.
56 (item "/gnu/store/...")
63 (item "/gnu/store/...")
66 (define guile-2.0.9:debug
67 (manifest-entry (inherit guile-2.0.9)
74 (item "/gnu/store/...")
78 (test-begin "profiles")
80 (test-assert "manifest-installed?"
81 (let ((m (manifest (list guile-2.0.9 guile-2.0.9:debug))))
82 (and (manifest-installed? m (manifest-pattern (name "guile")))
83 (manifest-installed? m (manifest-pattern
84 (name "guile") (output "debug")))
85 (manifest-installed? m (manifest-pattern
86 (name "guile") (output "out")
88 (not (manifest-installed?
89 m (manifest-pattern (name "guile") (version "1.8.8"))))
90 (not (manifest-installed?
91 m (manifest-pattern (name "guile") (output "foobar")))))))
93 (test-assert "manifest-matching-entries"
94 (let* ((e (list guile-2.0.9 guile-2.0.9:debug))
97 (manifest-matching-entries m
98 (list (manifest-pattern
101 (equal? (list guile-2.0.9)
102 (manifest-matching-entries m
103 (list (manifest-pattern
105 (version "2.0.9"))))))))
107 (test-assert "manifest-matching-entries, no match"
108 (let ((m (manifest (list guile-2.0.9)))
109 (p (manifest-pattern (name "python"))))
110 (guard (c ((unmatched-pattern-error? c)
111 (and (eq? p (unmatched-pattern-error-pattern c))
112 (eq? m (unmatched-pattern-error-manifest c)))))
113 (manifest-matching-entries m (list p))
116 (test-equal "concatenate-manifests"
117 (manifest (list guile-2.0.9 glibc))
118 (concatenate-manifests (list (manifest (list guile-2.0.9))
119 (manifest (list glibc)))))
121 (test-assert "manifest-remove"
122 (let* ((m0 (manifest (list guile-2.0.9 guile-2.0.9:debug)))
123 (m1 (manifest-remove m0
124 (list (manifest-pattern (name "guile")))))
125 (m2 (manifest-remove m1
126 (list (manifest-pattern (name "guile"))))) ; same
127 (m3 (manifest-remove m2
128 (list (manifest-pattern
129 (name "guile") (output "debug")))))
130 (m4 (manifest-remove m3
131 (list (manifest-pattern (name "guile"))))))
132 (match (manifest-entries m2)
133 ((($ <manifest-entry> "guile" "2.0.9" "debug"))
135 (null? (manifest-entries m3))
136 (null? (manifest-entries m4)))))))
138 (test-assert "manifest-add"
139 (let* ((m0 (manifest '()))
140 (m1 (manifest-add m0 (list guile-1.8.8)))
141 (m2 (manifest-add m1 (list guile-2.0.9)))
142 (m3 (manifest-add m2 (list guile-2.0.9:debug)))
143 (m4 (manifest-add m3 (list guile-2.0.9:debug))))
144 (and (match (manifest-entries m1)
145 ((($ <manifest-entry> "guile" "1.8.8" "out")) #t)
147 (match (manifest-entries m2)
148 ((($ <manifest-entry> "guile" "2.0.9" "out")) #t)
152 (test-equal "manifest-add removes duplicates" ;<https://bugs.gnu.org/30569>
154 (manifest-entries (manifest-add (manifest '())
155 (list guile-2.0.9 guile-2.0.9))))
157 (test-equal "manifest->code, simple"
159 (specifications->manifest (list "guile" "guile:debug" "glibc")))
160 (manifest->code (manifest (list guile-2.0.9 guile-2.0.9:debug glibc))))
162 (test-equal "manifest->code, simple, versions"
164 (specifications->manifest (list "guile@2.0.9" "guile@2.0.9:debug"
166 (manifest->code (manifest (list guile-2.0.9 guile-2.0.9:debug glibc))
167 #:entry-package-version manifest-entry-version))
169 (test-equal "manifest->code, transformations"
171 (use-modules (guix transformations))
174 (options->transformation '((foo . "bar"))))
177 (list (transform1 (specification->package "guile"))
178 (specification->package "glibc"))))
179 (manifest->code (manifest (list (manifest-entry
180 (inherit guile-2.0.9)
181 (properties `((transformations
182 . ((foo . "bar"))))))
185 (test-assert "manifest-perform-transaction"
186 (let* ((m0 (manifest (list guile-2.0.9 guile-2.0.9:debug)))
187 (t1 (manifest-transaction
188 (install (list guile-1.8.8))
189 (remove (list (manifest-pattern (name "guile")
190 (output "debug"))))))
191 (t2 (manifest-transaction
192 (remove (list (manifest-pattern (name "guile")
195 (m1 (manifest-perform-transaction m0 t1))
196 (m2 (manifest-perform-transaction m1 t2))
197 (m3 (manifest-perform-transaction m0 t2)))
198 (and (match (manifest-entries m1)
199 ((($ <manifest-entry> "guile" "1.8.8" "out")) #t)
202 (null? (manifest-entries m3)))))
204 (test-assert "manifest-transaction-effects"
205 (let* ((m0 (manifest (list guile-1.8.8)))
206 (t (manifest-transaction
207 (install (list guile-2.0.9 glibc)))))
208 (let-values (((remove install upgrade downgrade)
209 (manifest-transaction-effects m0 t)))
210 (and (null? remove) (null? downgrade)
211 (equal? (list glibc) install)
212 (equal? (list (cons guile-1.8.8 guile-2.0.9)) upgrade)))))
214 (test-assert "manifest-transaction-effects no double install or upgrades"
215 (let* ((m0 (manifest (list guile-1.8.8)))
216 (t (manifest-transaction
217 (install (list guile-2.0.9 glibc glibc)))))
218 (let-values (((remove install upgrade downgrade)
219 (manifest-transaction-effects m0 t)))
220 (and (null? remove) (null? downgrade)
221 (equal? (list glibc) install)
222 (equal? (list (cons guile-1.8.8 guile-2.0.9)) upgrade)))))
224 (test-assert "manifest-transaction-effects and downgrades"
225 (let* ((m0 (manifest (list guile-2.0.9)))
226 (t (manifest-transaction (install (list guile-1.8.8)))))
227 (let-values (((remove install upgrade downgrade)
228 (manifest-transaction-effects m0 t)))
229 (and (null? remove) (null? install) (null? upgrade)
230 (equal? (list (cons guile-2.0.9 guile-1.8.8)) downgrade)))))
232 (test-assert "manifest-transaction-effects no double downgrade"
233 (let* ((m0 (manifest (list guile-2.0.9)))
234 (t (manifest-transaction (install (list guile-1.8.8 guile-1.8.8)))))
235 (let-values (((remove install upgrade downgrade)
236 (manifest-transaction-effects m0 t)))
237 (and (null? remove) (null? install) (null? upgrade)
238 (equal? (list (cons guile-2.0.9 guile-1.8.8)) downgrade)))))
240 (test-assert "manifest-transaction-effects and pseudo-upgrades"
241 (let* ((m0 (manifest (list guile-2.0.9)))
242 (t (manifest-transaction (install (list guile-2.0.9)))))
243 (let-values (((remove install upgrade downgrade)
244 (manifest-transaction-effects m0 t)))
245 (and (null? remove) (null? install) (null? downgrade)
246 (equal? (list (cons guile-2.0.9 guile-2.0.9)) upgrade)))))
248 (test-assert "manifest-transaction-null?"
249 (manifest-transaction-null? (manifest-transaction)))
251 (test-assert "manifest-transaction-removal-candidate?"
252 (let ((m (manifest (list guile-2.0.9)))
253 (t (manifest-transaction
254 (remove (list (manifest-pattern (name "guile")))))))
255 (and (manifest-transaction-removal-candidate? guile-2.0.9 t)
256 (not (manifest-transaction-removal-candidate? glibc t)))))
258 (test-assert "manifest-transaction-effects no double removal"
259 (let* ((m0 (manifest (list guile-2.0.9)))
260 (t (manifest-transaction
261 (remove (list (manifest-pattern (name "guile")))))))
262 (let-values (((remove install upgrade downgrade)
263 (manifest-transaction-effects m0 t)))
264 (and (= 1 (length remove))
265 (manifest-transaction-removal-candidate? guile-2.0.9 t)
266 (null? install) (null? downgrade) (null? upgrade)))))
268 (test-assertm "profile-derivation"
270 ((entry -> (package->manifest-entry %bootstrap-guile))
271 (guile (package->derivation %bootstrap-guile))
272 (drv (profile-derivation (manifest (list entry))
275 (profile -> (derivation->output-path drv))
276 (bindir -> (string-append profile "/bin"))
277 (_ (built-derivations (list drv))))
278 (return (and (file-exists? (string-append bindir "/guile"))
279 (string=? (dirname (readlink bindir))
280 (derivation->output-path guile))))))
282 (test-assertm "profile-derivation, ordering & collisions"
283 ;; ENTRY1 and ENTRY2 both provide 'bin/guile'--a collision. Make sure
284 ;; ENTRY1 "wins" over ENTRY2. See <https://bugs.gnu.org/49102>.
286 ((entry1 -> (package->manifest-entry %bootstrap-guile))
287 (entry2 -> (manifest-entry
294 (mkdir (string-append #$output "/bin"))
295 (call-with-output-file
296 (string-append #$output "/bin/guile")
298 (display "Fake!\n" port))))))))
299 (guile (package->derivation %bootstrap-guile))
300 (drv (profile-derivation (manifest (list entry1 entry2))
303 (profile -> (derivation->output-path drv))
304 (bindir -> (string-append profile "/bin"))
305 (file -> (string-append bindir "/guile"))
306 (_ (built-derivations (list drv))))
307 (return (string=? (readlink file)
309 (derivation->output-path guile)
312 (test-assertm "load-profile"
314 ((entry -> (package->manifest-entry %bootstrap-guile))
315 (guile (package->derivation %bootstrap-guile))
316 (drv (profile-derivation (manifest (list entry))
319 (profile -> (derivation->output-path drv))
320 (bindir -> (string-append profile "/bin"))
321 (_ (built-derivations (list drv))))
322 (define-syntax-rule (with-environment-excursion exp ...)
323 (let ((env (environ)))
327 (lambda () (environ env)))))
329 (return (and (with-environment-excursion
330 (load-profile profile)
331 (and (string-prefix? (string-append bindir ":")
333 (getenv "GUILE_LOAD_PATH")))
334 (with-environment-excursion
335 (load-profile profile #:pure? #t #:white-list '())
336 (equal? (list (string-append "PATH=" bindir))
339 (test-assertm "<profile>"
341 ((entry -> (package->manifest-entry %bootstrap-guile))
342 (profile -> (profile (hooks '()) (locales? #f)
343 (content (manifest (list entry)))))
344 (drv (lower-object profile))
345 (profile -> (derivation->output-path drv))
346 (bindir -> (string-append profile "/bin"))
347 (_ (built-derivations (list drv))))
348 (return (file-exists? (string-append bindir "/guile")))))
350 (test-assertm "profile-derivation relative symlinks, one entry"
352 ((entry -> (package->manifest-entry %bootstrap-guile))
353 (guile (package->derivation %bootstrap-guile))
354 (drv (profile-derivation (manifest (list entry))
355 #:relative-symlinks? #t
358 (profile -> (derivation->output-path drv))
359 (bindir -> (string-append profile "/bin"))
360 (_ (built-derivations (list drv))))
361 (return (and (file-exists? (string-append bindir "/guile"))
362 (string=? (readlink bindir)
365 (derivation->output-path guile))
368 (unless (network-reachable?) (test-skip 1))
369 (test-assertm "profile-derivation relative symlinks, two entries"
371 ((manifest -> (packages->manifest
372 (list %bootstrap-guile gnu-make-for-tests)))
373 (guile (package->derivation %bootstrap-guile))
374 (make (package->derivation gnu-make-for-tests))
375 (drv (profile-derivation manifest
376 #:relative-symlinks? #t
379 (profile -> (derivation->output-path drv))
380 (bindir -> (string-append profile "/bin"))
381 (_ (built-derivations (list drv))))
382 (return (and (file-exists? (string-append bindir "/guile"))
383 (file-exists? (string-append bindir "/make"))
384 (string=? (readlink (string-append bindir "/guile"))
385 (string-append "../../"
387 (derivation->output-path guile))
389 (string=? (readlink (string-append bindir "/make"))
390 (string-append "../../"
392 (derivation->output-path make))
395 (test-assertm "profile-derivation, inputs"
397 ((entry -> (package->manifest-entry packages:glibc "debug"))
398 (drv (profile-derivation (manifest (list entry))
401 (return (derivation-inputs drv))))
403 (test-assertm "profile-derivation, cross-compilation"
405 ((manifest -> (packages->manifest (list packages:sed packages:grep)))
406 (target -> "arm-linux-gnueabihf")
407 (grep (package->cross-derivation packages:grep target))
408 (sed (package->cross-derivation packages:sed target))
409 (locales (package->derivation packages:glibc-utf8-locales))
410 (drv (profile-derivation manifest
414 (define (find-input package)
415 (let ((name (string-append (package-full-name package "-") ".drv")))
417 (let ((input (derivation-input-path input)))
418 (and (string-suffix? name input) input)))
419 (derivation-inputs drv))))
421 ;; The inputs for grep and sed should be cross-build derivations, but that
422 ;; for the glibc-utf8-locales should be a native build.
423 (return (and (string=? (derivation-system drv) (%current-system))
424 (string=? (find-input packages:grep)
425 (derivation-file-name grep))
426 (string=? (find-input packages:sed)
427 (derivation-file-name sed))
428 (string=? (find-input packages:glibc-utf8-locales)
429 (derivation-file-name locales))))))
431 (test-assert "package->manifest-entry defaults to \"out\""
432 (let ((outputs (package-outputs packages:glibc)))
433 (equal? (manifest-entry-output
434 (package->manifest-entry (package
435 (inherit packages:glibc)
436 (outputs (reverse outputs)))))
437 (manifest-entry-output
438 (package->manifest-entry packages:glibc))
441 (test-assertm "profile-manifest, search-paths"
444 (inherit %bootstrap-guile)
446 (package-native-search-paths packages:guile-2.0))))
447 (entry -> (package->manifest-entry guile))
448 (drv (profile-derivation (manifest (list entry))
451 (profile -> (derivation->output-path drv)))
453 (built-derivations (list drv))
455 ;; Read the manifest back and make sure search paths are preserved.
456 (let ((manifest (profile-manifest profile)))
457 (match (manifest-entries manifest)
459 (return (equal? (manifest-entry-search-paths result)
460 (manifest-entry-search-paths entry)
461 (package-native-search-paths
462 packages:guile-2.0)))))))))
464 (test-assert "package->manifest-entry, search paths"
465 ;; See <http://bugs.gnu.org/22073>.
466 (let ((mpl (@ (gnu packages python-xyz) python2-matplotlib)))
468 (package-transitive-native-search-paths mpl)
469 (manifest-entry-search-paths
470 (package->manifest-entry mpl)))))
472 (test-assert "packages->manifest, no duplicates"
476 (package->manifest-entry packages:guile-2.2))))
477 (manifest (packages->manifest
478 (list packages:guile-2.2 packages:guile-2.2))))
479 (every manifest-entry=? (manifest-entries expected)
480 (manifest-entries manifest))))
482 (test-equal "packages->manifest, propagated inputs"
485 (list (package-name package) (package-version package)
487 (package-propagated-inputs packages:guile-2.2))
489 (list (manifest-entry-name entry)
490 (manifest-entry-version entry)
491 (manifest-entry-item entry)))
492 (manifest-entry-dependencies
493 (package->manifest-entry packages:guile-2.2))))
495 (test-assert "manifest-entry-parent"
496 (let ((entry (package->manifest-entry packages:guile-2.2)))
497 (match (manifest-entry-dependencies entry)
499 (and (every (lambda (parent)
500 (eq? entry (force parent)))
501 (map manifest-entry-parent dependencies))
502 (not (force (manifest-entry-parent entry))))))))
504 (test-assertm "read-manifest"
505 (mlet* %store-monad ((manifest -> (packages->manifest
507 (inherit %bootstrap-guile)
509 (package-native-search-paths
510 packages:guile-2.0))))))
511 (drv (profile-derivation manifest
514 (out -> (derivation->output-path drv)))
515 (define (entry->sexp entry)
516 (list (manifest-entry-name entry)
517 (manifest-entry-version entry)
518 (manifest-entry-search-paths entry)
519 (manifest-entry-dependencies entry)
520 (force (manifest-entry-parent entry))))
523 (built-derivations (list drv))
524 (let ((manifest2 (profile-manifest out)))
525 (return (equal? (map entry->sexp (manifest-entries manifest))
526 (map entry->sexp (manifest-entries manifest2))))))))
528 (test-equal "collision"
529 '(("guile-bootstrap" "2.0") ("guile-bootstrap" "42"))
530 (guard (c ((profile-collision-error? c)
531 (let ((entry1 (profile-collision-error-entry c))
532 (entry2 (profile-collision-error-conflict c)))
533 (list (list (manifest-entry-name entry1)
534 (manifest-entry-version entry1))
535 (list (manifest-entry-name entry2)
536 (manifest-entry-version entry2))))))
537 (run-with-store %store
538 (mlet* %store-monad ((p0 -> (package
539 (inherit %bootstrap-guile)
541 (p1 -> (dummy-package "p1"
542 (propagated-inputs `(("p0" ,p0)))))
543 (manifest -> (packages->manifest
544 (list %bootstrap-guile p1)))
545 (drv (profile-derivation manifest
550 (test-equal "collision of propagated inputs"
551 '(("guile-bootstrap" "2.0") ("guile-bootstrap" "42"))
552 (guard (c ((profile-collision-error? c)
553 (let ((entry1 (profile-collision-error-entry c))
554 (entry2 (profile-collision-error-conflict c)))
555 (list (list (manifest-entry-name entry1)
556 (manifest-entry-version entry1))
557 (list (manifest-entry-name entry2)
558 (manifest-entry-version entry2))))))
559 (run-with-store %store
560 (mlet* %store-monad ((p0 -> (package
561 (inherit %bootstrap-guile)
563 (p1 -> (dummy-package "p1"
565 `(("guile" ,%bootstrap-guile)))))
566 (p2 -> (dummy-package "p2"
569 (manifest -> (packages->manifest (list p1 p2)))
570 (drv (profile-derivation manifest
575 (test-assertm "no collision"
576 ;; Here we have an entry that is "lowered" (its 'item' field is a store file
577 ;; name) and another entry (its 'item' field is a package) that is
579 (mlet* %store-monad ((p -> (dummy-package "p"
581 `(("guile" ,%bootstrap-guile)))))
582 (guile (package->derivation %bootstrap-guile))
583 (entry -> (manifest-entry
584 (inherit (package->manifest-entry
586 (item (derivation->output-path guile))))
587 (manifest -> (manifest
589 (package->manifest-entry p))))
590 (drv (profile-derivation manifest)))
591 (return (->bool drv))))
593 (test-assertm "etc/profile"
594 ;; Make sure we get an 'etc/profile' file that at least defines $PATH.
597 (inherit %bootstrap-guile)
599 (package-native-search-paths packages:guile-2.0))))
600 (entry -> (package->manifest-entry guile))
601 (drv (profile-derivation (manifest (list entry))
604 (profile -> (derivation->output-path drv)))
606 (built-derivations (list drv))
607 (let* ((pipe (open-input-pipe
608 (string-append "unset GUIX_PROFILE; "
609 ;; 'source' is a Bashism; use '.' (dot).
610 ". " profile "/etc/profile; "
611 ;; Don't try to parse set(1) output because
612 ;; it differs among shells; just use echo.
614 (path (get-string-all pipe)))
616 (and (zero? (close-pipe pipe))
617 (string-contains path (string-append profile "/bin"))))))))
619 (test-assertm "etc/profile when etc/ already exists"
620 ;; Here 'union-build' makes the profile's etc/ a symlink to the package's
621 ;; etc/ directory, which makes it read-only. Make sure the profile build
624 ((thing -> (dummy-package "dummy"
625 (build-system trivial-build-system)
627 `(#:guile ,%bootstrap-guile
629 (let ((out (assoc-ref %outputs "out")))
631 (mkdir (string-append out "/etc"))
632 (call-with-output-file (string-append out "/etc/foo")
634 (display "foo!" port)))
636 (entry -> (package->manifest-entry thing))
637 (drv (profile-derivation (manifest (list entry))
640 (profile -> (derivation->output-path drv)))
642 (built-derivations (list drv))
643 (return (and (file-exists? (string-append profile "/etc/profile"))
644 (string=? (call-with-input-file
645 (string-append profile "/etc/foo")
649 (test-assertm "etc/profile when etc/ is a symlink"
650 ;; When etc/ is a symlink, the unsymlink code in 0.8.2 would fail
651 ;; gracelessly because 'scandir' would return #f.
653 ((thing -> (dummy-package "dummy"
654 (build-system trivial-build-system)
656 `(#:guile ,%bootstrap-guile
658 (let ((out (assoc-ref %outputs "out")))
660 (mkdir (string-append out "/foo"))
661 (symlink "foo" (string-append out "/etc"))
662 (call-with-output-file (string-append out "/etc/bar")
664 (display "foo!" port)))
666 (entry -> (package->manifest-entry thing))
667 (drv (profile-derivation (manifest (list entry))
670 (profile -> (derivation->output-path drv)))
672 (built-derivations (list drv))
673 (return (and (file-exists? (string-append profile "/etc/profile"))
674 (string=? (call-with-input-file
675 (string-append profile "/etc/bar")
679 (test-assertm "profile-derivation when etc/ is a relative symlink"
680 ;; See <https://bugs.gnu.org/32686>.
682 ((etc (gexp->derivation
686 (call-with-output-file (string-append #$output "/foo")
688 (display "Heya!" port))))))
689 (thing -> (dummy-package "dummy"
690 (build-system trivial-build-system)
694 `(#:guile ,%bootstrap-guile
696 (let ((out (assoc-ref %outputs "out"))
697 (etc (assoc-ref %build-inputs "etc")))
699 (symlink etc (string-append out "/etc"))
701 (entry -> (package->manifest-entry thing))
702 (drv (profile-derivation (manifest (list entry))
703 #:relative-symlinks? #t
706 (profile -> (derivation->output-path drv)))
708 (built-derivations (list drv))
709 (return (string=? (call-with-input-file
710 (string-append profile "/etc/foo")
714 (test-equalm "union vs. dangling symlink" ;<https://bugs.gnu.org/26949>
717 ((thing1 -> (dummy-package "dummy"
718 (build-system trivial-build-system)
720 `(#:guile ,%bootstrap-guile
722 (let ((out (assoc-ref %outputs "out")))
724 (symlink "does-not-exist"
725 (string-append out "/dangling"))
727 (thing2 -> (package (inherit thing1) (name "dummy2")))
728 (drv (profile-derivation (packages->manifest
729 (list thing1 thing2))
732 (profile -> (derivation->output-path drv)))
734 (built-derivations (list drv))
735 (return (readlink (readlink (string-append profile "/dangling")))))))
737 (test-equalm "profile in profile"
740 ;; Make sure we can build a profile that has another profile has one of its
741 ;; entries. The new profile's /manifest and /etc/profile must override the
744 ((prof0 (profile-derivation
746 (list (package->manifest-entry %bootstrap-guile)))
749 (prof1 (profile-derivation
750 (manifest (list (manifest-entry
757 (built-derivations (list prof1))
758 (let ((out (derivation->output-path prof1)))
759 (return (and (file-exists?
760 (string-append out "/bin/guile"))
761 (let ((manifest (profile-manifest out)))
762 (match (manifest-entries manifest)
764 (list (manifest-entry-name entry)
765 (manifest-entry-version entry)))))))))))
767 (test-end "profiles")
770 ;;; eval: (put 'dummy-package 'scheme-indent-function 1)